[Init] Initial commit - NetMesh terminal manager

application/state/useOutputTriggers.test.ts

@@ -0,0 +1,970 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import React from 'react';
+import { act, create, type ReactTestRenderer } from 'react-test-renderer';
+import {
+  createDeferredOutputTriggerEventProcessor,
+  createOutputTriggerScanBuffer,
+  droppedOutputOverflowMayAffectAlternateScreenState,
+  findMatchEndingAfter,
+  hasApplicableOutputTriggerSnippet,
+  inspectDroppedOutputOverflowAlternateScreenState,
+  useOutputTriggers,
+} from './useOutputTriggers.ts';
+import { createTerminalOutputTriggerFilter } from '@/domain/terminalOutputTriggerFilter.ts';
+import type { Snippet } from '@/domain/models';
+
+test('findMatchEndingAfter skips stale overlap matches and finds current output', () => {
+  const text = 'NETCATTY_TRIGGER_PROBE old\r\nprompt# NETCATTY_TRIGGER_PROBE: command not found\r\n';
+  const minEndOffset = 'NETCATTY_TRIGGER_PROBE old\r\n'.length;
+  const match = findMatchEndingAfter(text, 'NETCATTY_TRIGGER_PROBE', minEndOffset);
+  assert.deepEqual(match, {
+    value: 'NETCATTY_TRIGGER_PROBE',
+    endOffset: 'NETCATTY_TRIGGER_PROBE old\r\nprompt# NETCATTY_TRIGGER_PROBE'.length,
+  });
+});
+
+test('findMatchEndingAfter supports regex patterns', () => {
+  const text = 'old done\r\nservice ready: 200\r\n';
+  const minEndOffset = 'old done\r\n'.length;
+  const match = findMatchEndingAfter(text, 'ready:\\s+\\d+', minEndOffset);
+  assert.deepEqual(match, {
+    value: 'ready: 200',
+    endOffset: 'old done\r\nservice ready: 200'.length,
+  });
+});
+
+test('findMatchEndingAfter returns null when matches are only stale', () => {
+  const text = 'NETCATTY_TRIGGER_PROBE old\r\nnew output\r\n';
+  const minEndOffset = 'NETCATTY_TRIGGER_PROBE old\r\n'.length;
+  assert.equal(findMatchEndingAfter(text, 'NETCATTY_TRIGGER_PROBE', minEndOffset), null);
+});
+
+test('hasApplicableOutputTriggerSnippet ignores non-output-trigger snippets', () => {
+  const snippets: Snippet[] = [
+    {
+      id: 'plain',
+      label: 'Plain',
+      command: 'echo hello',
+      kind: 'snippet',
+    },
+    {
+      id: 'manual-script',
+      label: 'Manual',
+      command: '',
+      kind: 'script',
+      trigger: 'manual',
+      triggerPattern: 'READY',
+    },
+  ];
+
+  assert.equal(hasApplicableOutputTriggerSnippet(snippets, 'host-a'), false);
+});
+
+test('hasApplicableOutputTriggerSnippet requires a runnable output trigger for this host', () => {
+  const snippets: Snippet[] = [
+    {
+      id: 'wrong-host',
+      label: 'Wrong host',
+      command: '',
+      kind: 'script',
+      trigger: 'onOutput',
+      triggerPattern: 'READY',
+      targets: ['host-b'],
+    },
+    {
+      id: 'missing-pattern',
+      label: 'Missing pattern',
+      command: '',
+      kind: 'script',
+      trigger: 'onOutput',
+    },
+  ];
+
+  assert.equal(hasApplicableOutputTriggerSnippet(snippets, 'host-a'), false);
+
+  snippets.push({
+    id: 'right-host',
+    label: 'Right host',
+    command: '',
+    kind: 'script',
+    trigger: 'onOutput',
+    triggerPattern: 'READY',
+    targets: ['host-a'],
+  });
+
+  assert.equal(hasApplicableOutputTriggerSnippet(snippets, 'host-a'), true);
+});
+
+test('hasApplicableOutputTriggerSnippet follows the host current group', () => {
+  const snippets: Snippet[] = [{
+    id: 'group-trigger',
+    label: 'Group trigger',
+    command: '',
+    kind: 'script',
+    trigger: 'onOutput',
+    triggerPattern: 'READY',
+    targetGroups: ['Production'],
+  }];
+  assert.equal(
+    hasApplicableOutputTriggerSnippet(snippets, { id: 'host-a', group: 'Production/Web' }),
+    true,
+  );
+  assert.equal(
+    hasApplicableOutputTriggerSnippet(snippets, { id: 'host-a', group: 'Staging' }),
+    false,
+  );
+});
+
+test('equivalent host objects do not reset a pending output trigger match', async () => {
+  const actEnvironment = globalThis as typeof globalThis & {
+    IS_REACT_ACT_ENVIRONMENT?: boolean;
+  };
+  const previousActEnvironment = actEnvironment.IS_REACT_ACT_ENVIRONMENT;
+  actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+  const snippets: Snippet[] = [{
+    id: 'stable-host-trigger',
+    label: 'Stable host trigger',
+    command: '',
+    kind: 'script',
+    trigger: 'onOutput',
+    triggerPattern: 'READY',
+    targetGroups: ['Production'],
+  }];
+  let appendOutput: ((chunk: string) => void) | undefined;
+  let runCount = 0;
+  let renderer: ReactTestRenderer | null = null;
+  const onRunScript = () => {
+    runCount += 1;
+  };
+
+  const Probe = ({ host }: { host: { id: string; group: string } }) => {
+    appendOutput = useOutputTriggers({
+      sessionId: 'session-1',
+      host,
+      snippets,
+      onRunScript,
+    }).appendOutput;
+    return null;
+  };
+
+  await act(async () => {
+    renderer = create(React.createElement(Probe, {
+      host: { id: 'host-a', group: 'Production/Web' },
+    }));
+  });
+  try {
+    await act(async () => {
+      appendOutput?.('REA');
+      renderer?.update(React.createElement(Probe, {
+        host: { id: 'host-a', group: 'Production/Web' },
+      }));
+      appendOutput?.('DY');
+      await new Promise((resolve) => setTimeout(resolve, 40));
+    });
+  } finally {
+    await act(async () => renderer?.unmount());
+    actEnvironment.IS_REACT_ACT_ENVIRONMENT = previousActEnvironment;
+  }
+
+  assert.equal(runCount, 1);
+});
+
+test('output trigger scan buffer consumes scanned content and only keeps overlap', () => {
+  const buffer = createOutputTriggerScanBuffer(4);
+
+  assert.deepEqual(buffer.append('abcdef'), {
+    text: 'abcdef',
+    minEndOffset: 0,
+    baseOffset: 0,
+  });
+
+  assert.deepEqual(buffer.append('gh'), {
+    text: 'cdefgh',
+    minEndOffset: 4,
+    baseOffset: 2,
+  });
+});
+
+test('output trigger scan buffer scans all new large output instead of only the tail', () => {
+  const buffer = createOutputTriggerScanBuffer(4);
+
+  assert.deepEqual(buffer.append('abc'), {
+    text: 'abc',
+    minEndOffset: 0,
+    baseOffset: 0,
+  });
+
+  assert.deepEqual(buffer.append('defghijkl'), {
+    text: 'abcdefghijkl',
+    minEndOffset: 3,
+    baseOffset: 0,
+  });
+});
+
+test('deferred output trigger processor schedules output instead of processing synchronously', () => {
+  const processed: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    processOutput: (chunk) => processed.push(chunk),
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('READY');
+
+  assert.deepEqual(processed, []);
+  assert.equal(scheduled.length, 1);
+
+  scheduled.shift()?.();
+
+  assert.deepEqual(processed, ['READY']);
+});
+
+test('deferred output trigger processor coalesces output while preserving input order', () => {
+  const events: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    processOutput: (chunk) => events.push(`output:${chunk}`),
+    processInput: (data) => events.push(`input:${data}`),
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('he');
+  processor.enqueueOutput('llo');
+  processor.enqueueInput('cmd');
+  processor.enqueueOutput('world');
+
+  scheduled.shift()?.();
+
+  assert.deepEqual(events, ['output:hello', 'input:cmd', 'output:world']);
+});
+
+test('deferred output trigger processor splits large output and yields between flushes', () => {
+  const processed: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 4,
+    maxOutputBytesPerFlush: 8,
+    processOutput: (chunk) => processed.push(chunk),
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('abcdefghijkl');
+
+  scheduled.shift()?.();
+
+  assert.deepEqual(processed, ['abcd', 'efgh']);
+  assert.equal(scheduled.length, 1);
+
+  scheduled.shift()?.();
+
+  assert.deepEqual(processed, ['abcd', 'efgh', 'ijkl']);
+});
+
+test('deferred output trigger processor splits large input and yields between flushes', () => {
+  const processed: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 4,
+    maxOutputBytesPerFlush: 8,
+    processOutput: () => {},
+    processInput: (chunk) => processed.push(chunk),
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueInput('abcdefghijkl');
+
+  scheduled.shift()?.();
+
+  assert.deepEqual(processed, ['abcd', 'efgh']);
+  assert.equal(scheduled.length, 1);
+
+  scheduled.shift()?.();
+
+  assert.deepEqual(processed, ['abcd', 'efgh', 'ijkl']);
+});
+
+test('deferred output trigger processor caps pending input and resets input state', () => {
+  const processed: string[] = [];
+  const scheduled: Array<() => void> = [];
+  let inputOverflows = 0;
+  let inputOverflowLines = 0;
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 4,
+    maxOutputBytesPerFlush: 8,
+    maxPendingInputBytes: 8,
+    processOutput: () => {},
+    processInput: (chunk) => processed.push(chunk),
+    processInputOverflow: (lineCount) => {
+      inputOverflows += 1;
+      inputOverflowLines += lineCount;
+    },
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueInput('abcdefghijkl');
+
+  while (scheduled.length > 0) {
+    scheduled.shift()?.();
+  }
+
+  assert.equal(inputOverflows, 1);
+  assert.equal(inputOverflowLines, 1);
+
+  assert.deepEqual(processed, ['efgh', 'ijkl']);
+});
+
+test('deferred output trigger processor reports dropped input echo line count', () => {
+  const scheduled: Array<() => void> = [];
+  const overflowLines: number[] = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 16,
+    maxOutputBytesPerFlush: 32,
+    maxPendingInputBytes: 5,
+    processOutput: () => {},
+    processInput: () => {},
+    processInputOverflow: (lineCount) => {
+      overflowLines.push(lineCount);
+    },
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueInput('one\r\ntwo\nthree');
+  processor.flush();
+
+  assert.deepEqual(overflowLines, [3]);
+});
+
+test('deferred output trigger processor reports more than 1024 dropped input echo lines', () => {
+  const scheduled: Array<() => void> = [];
+  const overflowLines: number[] = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 16,
+    maxOutputBytesPerFlush: 32,
+    maxPendingInputBytes: 4,
+    processOutput: () => {},
+    processInput: () => {},
+    processInputOverflow: (lineCount) => {
+      overflowLines.push(lineCount);
+    },
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueInput(`${'x\n'.repeat(1100)}tail`);
+  processor.flush();
+
+  assert.deepEqual(overflowLines, [1101]);
+});
+
+test('deferred output trigger processor includes retained input lines in overflow echo suppression', () => {
+  const scheduled: Array<() => void> = [];
+  const overflowLines: number[] = [];
+  const retainedInput = 'READY c\nREADY d\n';
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 64,
+    maxOutputBytesPerFlush: 128,
+    maxPendingInputBytes: retainedInput.length,
+    processOutput: () => {},
+    processInput: () => {},
+    processInputOverflow: (lineCount) => {
+      overflowLines.push(lineCount);
+    },
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueInput(`READY a\nREADY b\n${retainedInput}`);
+  processor.flush();
+
+  assert.deepEqual(overflowLines, [4]);
+});
+
+test('deferred output trigger processor accumulates repeated input overflows before flush', () => {
+  const overflowLines: number[] = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxPendingInputBytes: 0,
+    processOutput: () => {},
+    processInput: () => {},
+    processInputOverflow: (lineCount) => {
+      overflowLines.push(lineCount);
+    },
+    schedule: () => () => {},
+  });
+
+  processor.enqueueInput('one\ntwo\n');
+  processor.enqueueInput('three\nfour\n');
+  processor.flush();
+
+  assert.deepEqual(overflowLines, [4]);
+});
+
+test('deferred output trigger processor counts input split across overflow boundary as one line', () => {
+  const overflowLines: number[] = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxPendingInputBytes: 'def\n'.length,
+    processOutput: () => {},
+    processInput: () => {},
+    processInputOverflow: (lineCount) => {
+      overflowLines.push(lineCount);
+    },
+    schedule: () => () => {},
+  });
+
+  processor.enqueueInput('abcdef\n');
+  processor.flush();
+
+  assert.deepEqual(overflowLines, [1]);
+});
+
+test('deferred output trigger processor resets input overflow accounting after flush', () => {
+  const scheduled: Array<() => void> = [];
+  const overflowLines: number[] = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxPendingInputBytes: 0,
+    processOutput: () => {},
+    processInput: () => {},
+    processInputOverflow: (lineCount) => {
+      overflowLines.push(lineCount);
+    },
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueInput('one\ntwo\n');
+  scheduled.shift()?.();
+  processor.enqueueInput('three\n');
+  scheduled.shift()?.();
+
+  assert.deepEqual(overflowLines, [2, 1]);
+});
+
+test('deferred output trigger processor preserves output before later input overflow', () => {
+  const processed: string[] = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxPendingInputBytes: 0,
+    processOutput: (chunk) => {
+      processed.push(`output:${chunk}`);
+    },
+    processInput: () => {},
+    processInputOverflow: (lineCount) => {
+      processed.push(`overflow:${lineCount}`);
+    },
+    schedule: () => () => {},
+  });
+
+  processor.enqueueOutput('READY\n');
+  processor.enqueueInput('abcdef\n');
+  processor.flush();
+
+  assert.deepEqual(processed, ['output:READY\n', 'overflow:1']);
+});
+
+test('deferred output trigger processor suppresses retained multi-line input echo after overflow', () => {
+  const scheduled: Array<() => void> = [];
+  const filter = createTerminalOutputTriggerFilter();
+  const retainedInput = 'READY c\nREADY d\n';
+  const fullInput = `READY a\nREADY b\n${retainedInput}`;
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 64,
+    maxOutputBytesPerFlush: 128,
+    maxPendingInputBytes: retainedInput.length,
+    processOutput: () => {},
+    processInput: (chunk) => {
+      filter.noteUserInput(chunk);
+    },
+    processInputOverflow: (lineCount) => {
+      filter.markInputEchoUncertain(lineCount);
+    },
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueInput(fullInput);
+  while (scheduled.length > 0) {
+    scheduled.shift()?.();
+  }
+
+  const result = filter.processServerChunk(`${fullInput}server READY\n`);
+  assert.equal(result.scannableText, 'server READY\n');
+});
+
+test('deferred output trigger processor keeps pending scan output bounded', () => {
+  const processed: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 4,
+    maxOutputBytesPerFlush: 64,
+    maxPendingOutputBytes: 8,
+    pendingOutputOverlapChars: 4,
+    processOutput: (chunk) => processed.push(chunk),
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('x'.repeat(80));
+  processor.enqueueOutput('READY');
+
+  assert.equal(processor.getPendingOutputBytes(), 12);
+
+  scheduled.shift()?.();
+
+  assert.equal(processed.join('').length, 12);
+  assert.equal(processed.join('').endsWith('READY'), true);
+});
+
+test('deferred output trigger processor defers dropped output maintenance work', () => {
+  const dropped: string[] = [];
+  const processed: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 4,
+    maxOutputBytesPerFlush: 8,
+    maxPendingOutputBytes: 8,
+    pendingOutputOverlapChars: 0,
+    processDroppedOutput: (chunk) => dropped.push(chunk),
+    processOutput: (chunk) => processed.push(chunk),
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('x'.repeat(40));
+  processor.enqueueOutput('READY');
+
+  assert.deepEqual(dropped, []);
+  assert.deepEqual(processed, []);
+
+  scheduled.shift()?.();
+
+  assert.equal(dropped.join('').length, 8);
+  assert.deepEqual(processed, []);
+  assert.equal(scheduled.length, 1);
+});
+
+test('deferred output trigger processor applies output metadata in queue order', () => {
+  const scanned: string[] = [];
+  const scheduled: Array<() => void> = [];
+  let suppressed = false;
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 64,
+    maxOutputBytesPerFlush: 64,
+    processOutput: (chunk, meta) => {
+      if (meta?.droppedOutputMayAffectTerminalState) {
+        suppressed = true;
+      }
+      if (!suppressed) {
+        scanned.push(chunk);
+      }
+    },
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('READY');
+  processor.enqueueOutput('AFTER_DROP', { droppedOutputMayAffectTerminalState: true });
+
+  scheduled.shift()?.();
+
+  assert.deepEqual(scanned, ['READY']);
+});
+
+test('deferred output trigger processor preserves metadata when trimmed output is fully dropped', () => {
+  const scanned: string[] = [];
+  const scheduled: Array<() => void> = [];
+  let suppressed = false;
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 64,
+    maxOutputBytesPerFlush: 64,
+    maxPendingOutputBytes: 5,
+    pendingOutputOverlapChars: 0,
+    processDroppedOutput: (_chunk, meta) => {
+      if (meta?.droppedOutputMayAffectTerminalState) {
+        suppressed = true;
+      }
+    },
+    processOutput: (chunk) => {
+      if (!suppressed) {
+        scanned.push(chunk);
+      }
+    },
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('DROP', { droppedOutputMayAffectTerminalState: true });
+  processor.enqueueOutput('READY');
+
+  while (scheduled.length > 0) {
+    scheduled.shift()?.();
+  }
+
+  assert.deepEqual(scanned, []);
+});
+
+test('deferred output trigger processor caps dropped maintenance before retained output', () => {
+  const dropped: string[] = [];
+  const processed: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 4,
+    maxOutputBytesPerFlush: 8,
+    maxPendingOutputBytes: 8,
+    pendingOutputOverlapChars: 0,
+    processDroppedOutput: (chunk) => dropped.push(chunk),
+    processOutput: (chunk) => processed.push(chunk),
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('x'.repeat(200));
+  processor.enqueueOutput('READY');
+
+  scheduled.shift()?.();
+  assert.equal(dropped.join('').length, 8);
+  assert.deepEqual(processed, []);
+
+  scheduled.shift()?.();
+  assert.equal(processed.join('').endsWith('READY'), true);
+});
+
+test('deferred output trigger processor inspects dropped overflow with retained context', () => {
+  let mayAffectAlternateScreen = false;
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputBytesPerFlush: 5,
+    maxPendingOutputBytes: 0,
+    pendingOutputOverlapChars: 0,
+    processDroppedOutput: () => {},
+    processDroppedOutputOverflow: (overflow) => {
+      mayAffectAlternateScreen ||= droppedOutputOverflowMayAffectAlternateScreenState(overflow);
+    },
+    processOutput: () => {},
+    processInput: () => {},
+    schedule: () => () => {},
+  });
+
+  processor.enqueueOutput('\x1b[?10');
+  processor.enqueueOutput('49hREADY');
+
+  assert.equal(mayAffectAlternateScreen, true);
+});
+
+test('deferred output trigger processor does not carry dropped context across real output', () => {
+  const scheduled: Array<() => void> = [];
+  let mayAffectAlternateScreen = false;
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 8,
+    maxOutputBytesPerFlush: 3,
+    maxPendingOutputBytes: 1,
+    pendingOutputOverlapChars: 0,
+    processDroppedOutput: () => {},
+    processDroppedOutputOverflow: (overflow) => {
+      mayAffectAlternateScreen ||= droppedOutputOverflowMayAffectAlternateScreenState(overflow);
+    },
+    processOutput: () => {},
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('\x1b[?Z');
+  while (scheduled.length > 0) {
+    scheduled.shift()?.();
+  }
+  processor.enqueueOutput('1049hREADY');
+
+  assert.equal(mayAffectAlternateScreen, false);
+});
+
+test('deferred output trigger processor suppresses retained scans after dropped maintenance overflow', () => {
+  const scannable: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const filter = createTerminalOutputTriggerFilter();
+  let suppressScan = false;
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 4,
+    maxOutputBytesPerFlush: 8,
+    maxPendingOutputBytes: 8,
+    pendingOutputOverlapChars: 0,
+    processDroppedOutput: (chunk) => {
+      filter.processServerChunk(chunk);
+    },
+    processDroppedOutputOverflow: (overflow) => {
+      if (droppedOutputOverflowMayAffectAlternateScreenState(overflow)) {
+        suppressScan = true;
+      }
+    },
+    processOutput: (chunk) => {
+      const result = filter.processServerChunk(chunk);
+      if (!suppressScan && result.scannableText && !result.alternateScreenActive) {
+        scannable.push(result.scannableText);
+      }
+    },
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput(`${'x'.repeat(40)}\x1b[?1049h${'y'.repeat(40)}`);
+  processor.enqueueOutput('READY');
+
+  while (scheduled.length > 0) {
+    scheduled.shift()?.();
+  }
+
+  assert.equal(suppressScan, true);
+  assert.deepEqual(scannable, []);
+});
+
+test('deferred output trigger processor can recover from dropped split alternate-screen leave', () => {
+  const scannable: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const filter = createTerminalOutputTriggerFilter();
+  const recoveryFilter = createTerminalOutputTriggerFilter();
+  let suppressScan = true;
+  const maybeRecover = (chunk: string) => {
+    const recovery = recoveryFilter.processServerChunk(chunk);
+    if (recovery.meta.alternateScreenAction === 'leave' && !recovery.alternateScreenActive) {
+      suppressScan = false;
+      recoveryFilter.reset();
+      return true;
+    }
+    return false;
+  };
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 16,
+    maxOutputBytesPerFlush: 16,
+    maxPendingOutputBytes: 8,
+    pendingOutputOverlapChars: 0,
+    processDroppedOutput: (chunk) => {
+      filter.processServerChunk(chunk);
+      if (suppressScan) {
+        maybeRecover(chunk);
+      }
+    },
+    processOutput: (chunk) => {
+      const result = filter.processServerChunk(chunk);
+      if (suppressScan) {
+        maybeRecover(chunk);
+        return;
+      }
+      if (result.scannableText && !result.alternateScreenActive) {
+        scannable.push(result.scannableText);
+      }
+    },
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('\x1b[?10');
+  processor.enqueueOutput('49lREADY');
+
+  while (scheduled.length > 0) {
+    scheduled.shift()?.();
+  }
+
+  assert.equal(suppressScan, false);
+  assert.deepEqual(scannable, []);
+
+  processor.enqueueOutput('NEXT');
+  while (scheduled.length > 0) {
+    scheduled.shift()?.();
+  }
+
+  assert.deepEqual(scannable, ['NEXT']);
+});
+
+test('deferred output trigger processor keeps scanning after plain dropped maintenance overflow', () => {
+  const scannable: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const filter = createTerminalOutputTriggerFilter();
+  let suppressScan = false;
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 4,
+    maxOutputBytesPerFlush: 8,
+    maxPendingOutputBytes: 8,
+    pendingOutputOverlapChars: 0,
+    processDroppedOutput: (chunk) => {
+      filter.processServerChunk(chunk);
+    },
+    processDroppedOutputOverflow: (overflow) => {
+      if (droppedOutputOverflowMayAffectAlternateScreenState(overflow)) {
+        suppressScan = true;
+      }
+    },
+    processOutput: (chunk) => {
+      const result = filter.processServerChunk(chunk);
+      if (!suppressScan && result.scannableText && !result.alternateScreenActive) {
+        scannable.push(result.scannableText);
+      }
+    },
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput('x'.repeat(200));
+  processor.enqueueOutput('READY');
+
+  while (scheduled.length > 0) {
+    scheduled.shift()?.();
+  }
+
+  assert.equal(suppressScan, false);
+  assert.equal(scannable.join('').endsWith('READY'), true);
+});
+
+test('dropped output overflow detection ignores color sequences but catches alternate screen candidates', () => {
+  assert.equal(droppedOutputOverflowMayAffectAlternateScreenState({
+    retainedPrefix: 'plain',
+    discardedSuffix: '\x1b[31mcolored text',
+  }), false);
+  assert.equal(droppedOutputOverflowMayAffectAlternateScreenState({
+    retainedPrefix: '\x1b[?10',
+    discardedSuffix: '49hmore output',
+  }), true);
+  assert.equal(droppedOutputOverflowMayAffectAlternateScreenState({
+    retainedPrefix: 'plain',
+    discardedSuffix: '\x1b[?1;1049l',
+  }), true);
+  assert.equal(droppedOutputOverflowMayAffectAlternateScreenState({
+    retainedPrefix: `before\x1b[?1;2;3;4;5;6;7;8;9;10`,
+    discardedSuffix: ';1049hafter',
+  }), true);
+  assert.deepEqual(inspectDroppedOutputOverflowAlternateScreenState({
+    retainedPrefix: '\x1b[?1049h',
+    discardedSuffix: `${'x'.repeat(5000)}\x1b[?1;1049l`,
+  }), {
+    mayAffectAlternateScreen: true,
+    mayAffectScanState: false,
+    finalAction: 'leave',
+  });
+  assert.deepEqual(inspectDroppedOutputOverflowAlternateScreenState({
+    retainedPrefix: 'plain',
+    discardedSuffix: `${'x'.repeat(3000)}\x1b[?1049h${'y'.repeat(3000)}`,
+  }), {
+    mayAffectAlternateScreen: true,
+    mayAffectScanState: false,
+    finalAction: undefined,
+  });
+  assert.deepEqual(inspectDroppedOutputOverflowAlternateScreenState({
+    retainedPrefix: 'plain',
+    discardedSuffix: `\x1b[?1049l${'x'.repeat(3000)}\x1b[?1049h${'y'.repeat(3000)}`,
+  }), {
+    mayAffectAlternateScreen: true,
+    mayAffectScanState: false,
+    finalAction: undefined,
+  });
+  assert.deepEqual(inspectDroppedOutputOverflowAlternateScreenState({
+    retainedPrefix: 'plain',
+    discardedSuffix: `${'x'.repeat(5000)}\x1b[?1049lplain\x1b[?10`,
+  }), {
+    mayAffectAlternateScreen: true,
+    mayAffectScanState: true,
+    finalAction: undefined,
+  });
+  assert.deepEqual(inspectDroppedOutputOverflowAlternateScreenState({
+    retainedPrefix: 'plain',
+    discardedSuffix: `\x1b[?1049l${'x'.repeat(2500)}\x1b[?10`,
+  }), {
+    mayAffectAlternateScreen: true,
+    mayAffectScanState: true,
+    finalAction: undefined,
+  });
+  assert.deepEqual(inspectDroppedOutputOverflowAlternateScreenState({
+    retainedPrefix: '\x1b[31',
+    discardedSuffix: 'mREADY',
+  }), {
+    mayAffectAlternateScreen: false,
+    mayAffectScanState: true,
+    finalAction: undefined,
+  });
+});
+
+test('deferred output trigger processor preserves filter state for trimmed output', () => {
+  const scannable: string[] = [];
+  const scheduled: Array<() => void> = [];
+  const filter = createTerminalOutputTriggerFilter();
+  const processor = createDeferredOutputTriggerEventProcessor({
+    maxOutputChunkBytes: 4,
+    maxOutputBytesPerFlush: 64,
+    maxPendingOutputBytes: 8,
+    pendingOutputOverlapChars: 0,
+    processDroppedOutput: (chunk) => {
+      filter.processServerChunk(chunk);
+    },
+    processOutput: (chunk) => {
+      const result = filter.processServerChunk(chunk);
+      if (result.scannableText && !result.alternateScreenActive) {
+        scannable.push(result.scannableText);
+      }
+    },
+    processInput: () => {},
+    schedule: (callback) => {
+      scheduled.push(callback);
+      return () => {};
+    },
+  });
+
+  processor.enqueueOutput(`\x1b[?1049h${'x'.repeat(80)}`);
+  processor.enqueueOutput('READY');
+
+  assert.equal(processor.getPendingOutputBytes(), 8);
+
+  while (scheduled.length > 0) {
+    scheduled.shift()?.();
+  }
+
+  assert.deepEqual(scannable, []);
+});