perf(terminal): eliminate adverse control and frame-gate cases (#11045)

* perf(terminal): eliminate dense control and frame gate regressions

* test(terminal): keep gate labels in valid expect shape

* test(terminal): expose the surviving sub-threshold control-density case

The only adverse strip fixture sat at 50% control density, which is exactly
where the fallback fires and wins. A shape at 31 controls per 64-unit block
evades the trigger and still loses to the per-character legacy (0.67x), so the
benchmark structurally could not show it.

Add that fixture, pin both density literals in the staleness guard so a retune
fails loudly instead of silently measuring a boundary that moved, and export
the probe constant the equivalence test was hardcoding.

src/main/runtime/rpc/terminal-output-frame-chunks-equivalence.test.ts

@@ -7,6 +7,8 @@ import {
 import { TERMINAL_STREAM_CHUNK_BYTES } from '../../../shared/terminal-multiplex-flow-control'
 import { measureClipboardTextByteLength } from '../../../shared/clipboard-text'
 import {
+  TERMINAL_STREAM_BYTE_PROBE_CODE_UNITS,
+  exceedsTerminalStreamChunkBytes,
   iterateTerminalOutputFrameChunks,
   type TerminalOutputFrameChunk,
   type TerminalOutputMeta
@@ -23,6 +25,19 @@ function legacyByteLengthExceeds(data: string, maxBytes: number): boolean {
   return measureClipboardTextByteLength(data, { stopAfterBytes: maxBytes }).exceededLimit
 }
 
+function expectGateEquivalent(data: string, label: string): void {
+  expect({ label, result: exceedsTerminalStreamChunkBytes(data) }).toEqual({
+    label,
+    result: legacyByteLengthExceeds(data, TERMINAL_STREAM_CHUNK_BYTES)
+  })
+}
+
+function makeExactByteLength(unit: string, byteLength: number): string {
+  const unitBytes = Buffer.byteLength(unit, 'utf8')
+  const repeats = Math.floor(byteLength / unitBytes)
+  return unit.repeat(repeats) + 'a'.repeat(byteLength - repeats * unitBytes)
+}
+
 function* legacyIterateTerminalOutputFrameChunks(
   data: string,
   meta?: TerminalOutputMeta
@@ -216,6 +231,50 @@ function randomText(random: () => number, parts: number): string {
 }
 
 describe('iterateTerminalOutputFrameChunks equivalence with the pre-optimization loop', () => {
+  it('matches the legacy gate at the byte cap ±3 for every UTF-8 shape', () => {
+    for (const [label, unit] of [
+      ['ascii', 'a'],
+      ['two-byte', '\u00e9'],
+      ['three-byte', '\u20ac'],
+      ['astral', SURROGATE_PAIR],
+      ['lone-high', LONE_HIGH],
+      ['lone-low', LONE_LOW],
+      ['reversed-surrogates', `${LONE_LOW}${LONE_HIGH}a`]
+    ] as const) {
+      for (let delta = -3; delta <= 3; delta += 1) {
+        const byteLength = TERMINAL_STREAM_CHUNK_BYTES + delta
+        const data = makeExactByteLength(unit, byteLength)
+        expect(Buffer.byteLength(data, 'utf8')).toBe(byteLength)
+        expectGateEquivalent(data, `${label} delta=${delta}`)
+      }
+    }
+  })
+
+  it('matches when probe boundaries bisect or surround surrogate pairs', () => {
+    const probe = TERMINAL_STREAM_BYTE_PROBE_CODE_UNITS
+    for (const offset of [-2, -1, 0, 1, 2]) {
+      const pairStart = probe + offset
+      const prefix = 'a'.repeat(pairStart)
+      const suffix = '\u20ac'.repeat(12_000)
+      for (const middle of [SURROGATE_PAIR, LONE_HIGH, LONE_LOW, LONE_LOW + LONE_HIGH]) {
+        const data = prefix + middle + suffix
+        expectGateEquivalent(data, `probe offset=${offset} middle=${escapeUnits(middle)}`)
+        expectEquivalent(data, undefined, `probe frames offset=${offset}`)
+      }
+    }
+  })
+
+  it('stops correctly when late wide text crosses the cap', () => {
+    const asciiPrefix = 'a'.repeat(16_000)
+    for (const wide of ['\u00e9', '\u20ac', SURROGATE_PAIR, LONE_HIGH]) {
+      for (const wideParts of [8_000, 12_000, 16_000]) {
+        const data = asciiPrefix + wide.repeat(wideParts)
+        expectGateEquivalent(data, `late-wide ${escapeUnits(wide)} parts=${wideParts}`)
+        expectEquivalent(data, undefined, `late-wide frames ${escapeUnits(wide)}`)
+      }
+    }
+  })
+
   it('matches on the small/no-chunking sizes', () => {
     for (const size of [0, 1, 2, 3, 7, 64, 1024, TERMINAL_STREAM_CHUNK_BYTES - 1]) {
       sweepAll('a'.repeat(size), `ascii ${size}`)
@@ -416,7 +475,7 @@ describe('iterateTerminalOutputFrameChunks equivalence with the pre-optimization
       expectEquivalent(data, { seq: 88_888, rawLength: data.length }, `fuzz-cap seq trial=${trial}`)
       expectEquivalent(data, { seq: 88_888 }, `fuzz-cap delayed trial=${trial}`)
     }
-  })
+  }, 15_000)
 
   it('keeps every emitted frame within the wire cap and reassembles to the input', () => {
     const data = `${'a'.repeat(200 * 1024)}${SURROGATE_PAIR.repeat(4096)}${LONE_HIGH}`

src/main/runtime/rpc/terminal-output-frame-chunks.ts

@@ -4,6 +4,7 @@ import {
   encodeTerminalStreamText
 } from '../../../shared/terminal-stream-protocol'
 import { TERMINAL_STREAM_CHUNK_BYTES } from '../../../shared/terminal-multiplex-flow-control'
+import { terminalStreamByteLength } from './terminal-stream-byte-length'
 
 export type TerminalOutputMeta = {
   seq?: number
@@ -18,12 +19,31 @@ export type TerminalOutputFrameChunk = {
   opcode?: TerminalStreamOpcode
 }
 
-// Why: UTF-8 length is never below UTF-16 length, so a code-unit count over the cap already proves the byte count is.
-function exceedsTerminalStreamChunkBytes(data: string): boolean {
-  return (
-    data.length > TERMINAL_STREAM_CHUNK_BYTES ||
-    Buffer.byteLength(data, 'utf8') > TERMINAL_STREAM_CHUNK_BYTES
-  )
+export const TERMINAL_STREAM_BYTE_PROBE_CODE_UNITS = 8 * 1024
+const MAX_UTF8_BYTES_PER_CODE_UNIT = 3
+
+export function exceedsTerminalStreamChunkBytes(data: string): boolean {
+  if (data.length > TERMINAL_STREAM_CHUNK_BYTES) {
+    return true
+  }
+  if (data.length * MAX_UTF8_BYTES_PER_CODE_UNIT <= TERMINAL_STREAM_CHUNK_BYTES) {
+    return false
+  }
+  let byteLength = 0
+  for (let start = 0; start < data.length; ) {
+    let end = Math.min(start + TERMINAL_STREAM_BYTE_PROBE_CODE_UNITS, data.length)
+    const high = data.charCodeAt(end - 1)
+    const low = data.charCodeAt(end)
+    if (end < data.length && high >= 0xd800 && high <= 0xdbff && low >= 0xdc00 && low <= 0xdfff) {
+      end -= 1
+    }
+    byteLength += terminalStreamByteLength(data.slice(start, end))
+    if (byteLength > TERMINAL_STREAM_CHUNK_BYTES) {
+      return true
+    }
+    start = end
+  }
+  return false
 }
 
 export function* iterateTerminalOutputFrameChunks(