[Init] Initial commit - NetMesh terminal manager

components/terminal/runtime/terminalOutputPressure.test.ts

@@ -0,0 +1,276 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { Terminal as XTerm } from "@xterm/xterm";
+
+import {
+  getTerminalOutputPressure,
+  isTerminalScrollbackSaturated,
+  noteTerminalOutputPressureData,
+  resetTerminalOutputPressure,
+  setTerminalOutputPressureVisibility,
+  shouldDegradeTerminalSideWork,
+  shouldDegradeTerminalKeywordHighlight,
+  shouldSkipTerminalLineTimestamps,
+} from "./terminalOutputPressure.ts";
+import { TERMINAL_LONG_LINE_PRESSURE_BYTES } from "./terminalFlowConstants.ts";
+import { XTERM_PERFORMANCE_CONFIG } from "../../../infrastructure/config/xtermPerformance.ts";
+
+const createFakeTerm = (overrides: Record<string, unknown> = {}) => ({
+  rows: 24,
+  options: { scrollback: 1000 },
+  buffer: { active: { length: 10, baseY: 0 } },
+  ...overrides,
+}) as unknown as XTerm;
+
+test("tracks long unbroken terminal output pressure until a line break arrives", () => {
+  const term = createFakeTerm();
+
+  noteTerminalOutputPressureData(term, "x".repeat(TERMINAL_LONG_LINE_PRESSURE_BYTES - 1));
+  assert.equal(getTerminalOutputPressure(term).longLine, false);
+
+  noteTerminalOutputPressureData(term, "x");
+  assert.equal(getTerminalOutputPressure(term).longLine, true);
+  assert.equal(getTerminalOutputPressure(term).mode, "long-line");
+
+  noteTerminalOutputPressureData(term, "\nshort");
+  assert.equal(getTerminalOutputPressure(term).longLine, false);
+  // Crossing the long-line threshold also arms the high-rate large-output window.
+  assert.equal(getTerminalOutputPressure(term).largeOutput, true);
+  assert.equal(getTerminalOutputPressure(term).mode, "large-output");
+
+  resetTerminalOutputPressure(term);
+});
+
+test("reports newline-terminated long terminal lines as long-line pressure", () => {
+  const term = createFakeTerm();
+
+  noteTerminalOutputPressureData(term, `${"x".repeat(TERMINAL_LONG_LINE_PRESSURE_BYTES)}\n`);
+  assert.equal(getTerminalOutputPressure(term).longLine, true);
+  assert.equal(getTerminalOutputPressure(term).mode, "long-line");
+  assert.equal(getTerminalOutputPressure(term).consecutiveUnbrokenBytes, 0);
+
+  noteTerminalOutputPressureData(term, "short\n");
+  assert.equal(getTerminalOutputPressure(term).longLine, false);
+  assert.equal(getTerminalOutputPressure(term).largeOutput, true);
+  assert.equal(getTerminalOutputPressure(term).mode, "large-output");
+
+  resetTerminalOutputPressure(term);
+});
+
+test("reports background pressure separately from output volume", () => {
+  const term = createFakeTerm();
+
+  setTerminalOutputPressureVisibility(term, false);
+  assert.equal(getTerminalOutputPressure(term).background, true);
+  assert.equal(getTerminalOutputPressure(term).mode, "background");
+  assert.equal(shouldDegradeTerminalSideWork(term), false);
+
+  setTerminalOutputPressureVisibility(term, true);
+  assert.equal(getTerminalOutputPressure(term).background, false);
+  assert.equal(getTerminalOutputPressure(term).mode, "normal");
+
+  resetTerminalOutputPressure(term);
+});
+
+test("keeps large-output pressure through small input echoes until output is quiet", () => {
+  const term = createFakeTerm();
+  const originalNow = performance.now.bind(performance);
+  let now = 1_000;
+
+  Object.defineProperty(performance, "now", {
+    configurable: true,
+    value: () => now,
+  });
+
+  try {
+    noteTerminalOutputPressureData(term, "x\n".repeat(Math.ceil(TERMINAL_LONG_LINE_PRESSURE_BYTES / 2)));
+    assert.equal(getTerminalOutputPressure(term).largeOutput, true);
+    assert.equal(getTerminalOutputPressure(term).mode, "large-output");
+
+    now += 16;
+    noteTerminalOutputPressureData(term, "a");
+    assert.equal(getTerminalOutputPressure(term).largeOutput, true);
+    assert.equal(getTerminalOutputPressure(term).mode, "large-output");
+
+    now += XTERM_PERFORMANCE_CONFIG.highlighting.largeOutputQuietMs + 1;
+    assert.equal(getTerminalOutputPressure(term).largeOutput, false);
+    assert.equal(getTerminalOutputPressure(term).mode, "normal");
+  } finally {
+    Object.defineProperty(performance, "now", {
+      configurable: true,
+      value: originalNow,
+    });
+    resetTerminalOutputPressure(term);
+  }
+});
+
+test("detects large-output pressure from high-rate small chunks", () => {
+  const term = createFakeTerm();
+  const originalNow = performance.now.bind(performance);
+  let now = 5_000;
+
+  Object.defineProperty(performance, "now", {
+    configurable: true,
+    value: () => now,
+  });
+
+  try {
+    // ~16KB of short lines inside the 100ms rate window (not one unbroken run).
+    // Threshold is intentionally below one Tabby-sized xterm shard.
+    for (let index = 0; index < 16; index += 1) {
+      noteTerminalOutputPressureData(term, `${"y".repeat(1023)}\n`);
+    }
+    assert.equal(getTerminalOutputPressure(term).largeOutput, true);
+    assert.equal(getTerminalOutputPressure(term).longLine, false);
+    assert.equal(getTerminalOutputPressure(term).mode, "large-output");
+  } finally {
+    Object.defineProperty(performance, "now", {
+      configurable: true,
+      value: originalNow,
+    });
+    resetTerminalOutputPressure(term);
+  }
+});
+
+test("arms large-output early on multi-line writes when scrollback is saturated", () => {
+  // rows(24) + scrollback(1000) = 1024 max; length near cap → second-seq path.
+  const term = createFakeTerm({
+    rows: 24,
+    options: { scrollback: 1000 },
+    buffer: { active: { length: 1020, baseY: 996 } },
+  });
+  const originalNow = performance.now.bind(performance);
+  let now = 9_000;
+
+  Object.defineProperty(performance, "now", {
+    configurable: true,
+    value: () => now,
+  });
+
+  try {
+    assert.equal(isTerminalScrollbackSaturated(term), true);
+    // Far below the long-line / 16KB rate thresholds — only saturated multi-line
+    // arming should trip bulk mode (second `seq` cold start).
+    noteTerminalOutputPressureData(term, "1\n2\n3\n4\n5\n");
+    assert.equal(getTerminalOutputPressure(term).scrollbackSaturated, true);
+    assert.equal(getTerminalOutputPressure(term).largeOutput, true);
+    assert.equal(shouldDegradeTerminalSideWork(term), true);
+    assert.equal(getTerminalOutputPressure(term).mode, "large-output");
+
+    // Quiet window is extended while saturated so prompt-echo gaps do not
+    // reopen the expensive timestamp/highlight path before a second dump.
+    now += XTERM_PERFORMANCE_CONFIG.highlighting.largeOutputQuietMs + 1;
+    assert.equal(getTerminalOutputPressure(term).largeOutput, true);
+    now += XTERM_PERFORMANCE_CONFIG.highlighting.largeOutputQuietMs + 1;
+    assert.equal(getTerminalOutputPressure(term).largeOutput, false);
+  } finally {
+    Object.defineProperty(performance, "now", {
+      configurable: true,
+      value: originalNow,
+    });
+    resetTerminalOutputPressure(term);
+  }
+});
+
+test("a one-line prompt does not degrade keyword coloring on saturated scrollback", () => {
+  const term = createFakeTerm({
+    rows: 24,
+    options: { scrollback: 1000 },
+    buffer: { active: { length: 1020, baseY: 996 } },
+  });
+  const prompt = "\r\nplain prompt # ";
+
+  noteTerminalOutputPressureData(term, prompt);
+
+  assert.equal(shouldDegradeTerminalSideWork(term), true);
+  assert.equal(shouldDegradeTerminalKeywordHighlight(term, prompt), false);
+  resetTerminalOutputPressure(term);
+});
+
+test("does not treat an empty buffer as scrollback-saturated", () => {
+  const term = createFakeTerm({
+    rows: 24,
+    options: { scrollback: 1000 },
+    buffer: { active: { length: 12, baseY: 0 } },
+  });
+  assert.equal(isTerminalScrollbackSaturated(term), false);
+  noteTerminalOutputPressureData(term, "1\n2\n3\n");
+  assert.equal(getTerminalOutputPressure(term).largeOutput, false);
+  assert.equal(getTerminalOutputPressure(term).scrollbackSaturated, false);
+  resetTerminalOutputPressure(term);
+});
+
+test("saturated multi-line degrades side work but keeps line timestamps", () => {
+  const term = createFakeTerm({
+    rows: 24,
+    options: { scrollback: 1000 },
+    buffer: { active: { length: 1020, baseY: 996 } },
+  });
+
+  // docker-ps-sized multi-line on a full scrollback: highlight/prep may degrade,
+  // but per-line gutter timestamps must still stamp.
+  noteTerminalOutputPressureData(term, "CONTAINER ID   IMAGE\n".repeat(20));
+  assert.equal(shouldDegradeTerminalSideWork(term), true);
+  assert.equal(
+    shouldDegradeTerminalKeywordHighlight(term, "CONTAINER ID   IMAGE\n".repeat(20)),
+    false,
+  );
+  assert.equal(shouldSkipTerminalLineTimestamps(term), false);
+
+  resetTerminalOutputPressure(term);
+});
+
+test("true flood rate skips line timestamps", () => {
+  const term = createFakeTerm();
+  const originalNow = performance.now.bind(performance);
+  let now = 20_000;
+
+  Object.defineProperty(performance, "now", {
+    configurable: true,
+    value: () => now,
+  });
+
+  try {
+    // 64KB+ inside the rate window → timestamp flood gate.
+    for (let index = 0; index < 64; index += 1) {
+      noteTerminalOutputPressureData(term, `${"z".repeat(1023)}\n`);
+    }
+    assert.equal(shouldSkipTerminalLineTimestamps(term), true);
+    assert.equal(shouldDegradeTerminalSideWork(term), true);
+  } finally {
+    Object.defineProperty(performance, "now", {
+      configurable: true,
+      value: originalNow,
+    });
+    resetTerminalOutputPressure(term);
+  }
+});
+
+test("rate detector uses a true rolling window across early tiny samples", () => {
+  const term = createFakeTerm();
+  const originalNow = performance.now.bind(performance);
+  let now = 1;
+
+  Object.defineProperty(performance, "now", {
+    configurable: true,
+    value: () => now,
+  });
+
+  try {
+    noteTerminalOutputPressureData(term, "x\n");
+    now = 60;
+    noteTerminalOutputPressureData(term, `${"x".repeat(40 * 1024)}\n`);
+    now = 102;
+    noteTerminalOutputPressureData(term, `${"x".repeat(40 * 1024)}\n`);
+    // 80KB arrived within 42ms; the tiny sample at t=1 should age out, not reset the window.
+    assert.equal(getTerminalOutputPressure(term).largeOutput, true);
+    assert.equal(getTerminalOutputPressure(term).mode, "large-output");
+  } finally {
+    Object.defineProperty(performance, "now", {
+      configurable: true,
+      value: originalNow,
+    });
+    resetTerminalOutputPressure(term);
+  }
+});