@deepseek-harness-tui/dsh-tui 0.8.0 → 0.8.2

package/lib/types/ink/output.js

@@ -1,10 +1,10 @@
-import { styledCharsFromTokens, tokenize, } from '@alcalzone/ansi-tokenize';
+import { ansiCodesToString, styledCharsFromTokens, tokenize, } from '@alcalzone/ansi-tokenize';
 import { logForDebugging } from '../utils/debug.js';
 import { getGraphemeSegmenter } from '../utils/intl.js';
 import sliceAnsi from '../utils/sliceAnsi.js';
 import { reorderBidi } from './bidi.js';
 import { unionRect } from './layout/geometry.js';
-import { blitRegion, extractHyperlinkFromStyles, filterOutHyperlinkStyles, markNoSelectRegion, OSC8_PREFIX, resetScreen, setCellAt, shiftRows, } from './screen.js';
+import { blitRegion, cellRunSpan, createCellRun, extractHyperlinkFromStyles, filterOutHyperlinkStyles, markNoSelectRegion, OSC8_PREFIX, recordCellRunEntry, recordSpacerRunEntry, replayCellRun, resetScreen, setCellAt, shiftRows, } from './screen.js';
 import { stringWidth } from './stringWidth.js';
 import { widestLine } from './widest-line.js';
 /**
@@ -29,6 +29,11 @@ import { widestLine } from './widest-line.js';
 const MAX_CACHEABLE_LINE = 500;
 const CHAR_CACHE_MAX_ENTRIES = 16384;
 const CHAR_CACHE_MAX_CHARS = 100_000;
+/** Packed-run line cap: runs are three integers per cell (no per-char
+ *  objects like charCache entries), so long ANSI-art lines (the whale
+ *  logo, ~700 chars) are worth caching — they would otherwise
+ *  re-tokenize and re-cluster every frame. */
+const PACKED_MAX_LINE = 4000;
 /** Copy a string into a fresh flat string with no parent references. */
 function detachString(s) {
     // Buffer round-trip guarantees a newly allocated flat string; cheaper
@@ -41,28 +46,58 @@ function detachString(s) {
  * no caller can accidentally grow it unboundedly.
  */
 export class CharCache {
+    /**
+     * LRU of line → clustered characters. A full clear on overflow
+     * (the original behavior) thrashes during long-session streaming: the
+     * mounted window's static lines alone approach the char budget, so the
+     * streaming row's per-frame new keys tip it over every frame or two,
+     * nuking the cache and forcing ~1800 line re-tokenizations per frame
+     * (measured ~100ms/frame at a 175-row session). Evicting oldest-first
+     * keeps the hot mounted lines resident while streaming churn falls out
+     * the back. Recency is refreshed on hit (delete + re-insert) so lines
+     * read every frame are never evicted by one-shot churn.
+     */
     map = new Map();
     chars = 0;
     /**
-     * Return the cached clustered characters for a line, if present.
+     * Return the cached clustered characters for a line, if present, and
+     * refresh the entry's recency.
      * @param line - the line to look up.
      * @returns the cached characters, or undefined on a miss.
      */
     get(line) {
-        return this.map.get(line);
+        const hit = this.map.get(line);
+        if (hit !== undefined) {
+            this.map.delete(line);
+            this.map.set(line, hit);
+        }
+        return hit;
     }
     /**
-     * Cache clustered characters for a line, enforcing the cache bounds.
+     * Cache clustered characters for a line, enforcing the cache bounds by
+     * evicting least-recently-used entries (never a full clear).
      * @param line - the line key.
      * @param characters - the clustered characters to cache.
      */
     set(line, characters) {
         if (line.length > MAX_CACHEABLE_LINE)
             return;
-        if (this.map.size >= CHAR_CACHE_MAX_ENTRIES ||
+        if (this.map.has(line)) {
+            this.map.delete(line);
+            this.chars -= line.length;
+        }
+        // Evict oldest entries until the new one fits. A single line longer
+        // than the whole budget cannot fit even empty — skip caching it.
+        if (line.length > CHAR_CACHE_MAX_CHARS)
+            return;
+        while (this.map.size >= CHAR_CACHE_MAX_ENTRIES ||
             this.chars + line.length > CHAR_CACHE_MAX_CHARS) {
-            this.map.clear();
-            this.chars = 0;
+            const oldest = this.map.keys().next();
+            if (oldest.done === true)
+                break;
+            const oldestKey = oldest.value;
+            this.chars -= oldestKey.length;
+            this.map.delete(oldestKey);
         }
         this.map.set(detachString(line), characters);
         this.chars += line.length;
@@ -106,6 +141,128 @@ function minDefined(a, b) {
         return a;
     return Math.min(a, b);
 }
+/**
+ * Slot-reuse ceiling: the clustered array is a second full memory image of
+ * the line, and pathological single-line output (base64 blobs, minified
+ * code) would pin it across frames on top of the string itself. Past this
+ * length every frame takes the full path — transient, GC-able.
+ */
+const STREAMING_SLOT_MAX_LINE = 65_536;
+/**
+ * Classify the tail of the line relative to its LAST ESC character.
+ * - 'none': no ESC at all
+ * - 'dangling': the last ESC starts an escape sequence that is cut off at
+ *   end-of-line - next frame's continuation completes it, so the prefix
+ *   clustering cannot be reused (the partial sequence was clustered as text)
+ * - 'bare': the last ESC's sequence is complete but ends exactly at
+ *   end-of-line - the SGR state after it never applied to any character, so
+ *   trailingStyles (derived from the last char) would be stale next frame
+ * - 'complete': last sequence terminated with plain text after it
+ */
+function escapeTailState(line) {
+    const i = line.lastIndexOf('\x1b');
+    if (i === -1)
+        return 'none';
+    const rest = line.slice(i);
+    const c1 = rest[1];
+    if (c1 === undefined)
+        return 'dangling';
+    if (c1 === '[') {
+        for (let k = 2; k < rest.length; k++) {
+            const ch = rest.charCodeAt(k);
+            if (ch >= 0x40 && ch <= 0x7e)
+                return k === rest.length - 1 ? 'bare' : 'complete';
+            if (ch < 0x20 || ch > 0x3f)
+                return 'complete';
+        }
+        return 'dangling';
+    }
+    if (c1 === ']' || c1 === 'P' || c1 === '_' || c1 === '^' || c1 === 'X') {
+        for (let k = 2; k < rest.length; k++) {
+            if (rest[k] === '\x07')
+                return k === rest.length - 1 ? 'bare' : 'complete';
+            if (rest[k] === '\x1b' && rest[k + 1] === '\\') {
+                return k + 1 === rest.length - 1 ? 'bare' : 'complete';
+            }
+        }
+        return 'dangling';
+    }
+    // Two-character sequence ESC <0x30-0x7E>: rest.length >= 2 means complete.
+    return rest.length === 2 ? 'bare' : 'complete';
+}
+/** True when the line's last code point may continue into a multi-codepoint
+ *  grapheme (ZWJ, variation selectors, combining marks, skin tones, regional
+ *  indicators) - appending to it would change the last grapheme's clustering. */
+function endsWithOpenGrapheme(line) {
+    const cp = line.codePointAt(line.length - 1);
+    if (cp === undefined)
+        return false;
+    return (cp === 0x200d ||
+        cp === 0xfe0f ||
+        cp === 0xfe0e ||
+        (cp >= 0x0300 && cp <= 0x036f) ||
+        (cp >= 0x1f3fb && cp <= 0x1f3ff) ||
+        (cp >= 0x1f1e6 && cp <= 0x1f1ff));
+}
+/** Hebrew / Arabic / Syriac and related RTL blocks - bidirectional reordering
+ *  is line-global, so prefix-reuse (which reorders only the suffix) is not
+ *  safe for these; take the full path. */
+function hasRtlChars(text) {
+    return /[\u0590-\u05FF\u0600-\u06FF\u0700-\u08FF\uFB1D-\uFDFF\uFE70-\uFEFF]/.test(text);
+}
+/** Update (or clear) the streaming slot after a full-path build of `line`.
+ *  The slot is only kept when the line can safely be extended next frame. */
+function updateStreamingSlot(slot, line, clustered, chars) {
+    if (line.length <= MAX_CACHEABLE_LINE ||
+        line.length > STREAMING_SLOT_MAX_LINE ||
+        endsWithOpenGrapheme(line) ||
+        hasRtlChars(line)) {
+        // Short lines are served by CharCache; complex tails always take the
+        // full path. Drop a stale slot when the stream settles.
+        if (slot.current)
+            slot.current = null;
+        return;
+    }
+    const tail = escapeTailState(line);
+    if (tail === 'dangling' || tail === 'bare') {
+        if (slot.current)
+            slot.current = null;
+        return;
+    }
+    slot.current = {
+        line: detachString(line),
+        clustered,
+        trailingStyles: chars.length > 0 ? chars[chars.length - 1].styles : [],
+    };
+}
+/**
+ * Build the clustered characters for one line, taking the streaming-prefix
+ * fast path when possible. `slot` is the instance-level streaming slot;
+ * `prevChars`/`fullChars` wiring is handled by updateStreamingSlot.
+ */
+function buildClusteredChars(line, stylePool, slot) {
+    const prev = slot.current;
+    if (prev &&
+        line.length > MAX_CACHEABLE_LINE &&
+        line.length > prev.line.length &&
+        line.startsWith(prev.line) &&
+        !endsWithOpenGrapheme(prev.line) &&
+        !hasRtlChars(line.slice(prev.line.length))) {
+        // Reuse the prefix clustering verbatim; tokenize only the appended
+        // suffix, replaying the line-end SGR state so new characters inherit
+        // the correct style. Bidi runs on the suffix alone (line verified RTL-free).
+        const suffix = line.slice(prev.line.length);
+        const replay = styledCharsFromTokens(tokenize(ansiCodesToString(prev.trailingStyles) + suffix));
+        const clustered = styledCharsWithGraphemeClustering(replay, stylePool);
+        const result = prev.clustered.concat(reorderBidi(clustered));
+        updateStreamingSlot(slot, line, result, replay);
+        return result;
+    }
+    const chars = styledCharsFromTokens(tokenize(line));
+    const clustered = reorderBidi(styledCharsWithGraphemeClustering(chars, stylePool));
+    updateStreamingSlot(slot, line, clustered, chars);
+    return clustered;
+}
 /**
  * Collects write/blit/clear/clip operations from the render tree, then
  * applies them to a Screen buffer in get(). The Screen is what gets
@@ -120,6 +277,48 @@ export default class Output {
     screen;
     operations = [];
     charCache = new CharCache();
+    /**
+     * LRU of line → recorded packed cell run, mirroring charCache's bounds.
+     * The main-screen architecture repaints every settled line each frame;
+     * the recorded run replays as raw two-word stores (no interning, no
+     * packing, no guard branches) — the long-session streaming fix. Runs are
+     * validated against the screen they were interned on and die with it.
+     */
+    packedLines = new Map();
+    packedChars = 0;
+    /** Stable owner handle passed to writeLineToScreen (no per-call closure). */
+    packedOwner = {
+        lines: this.packedLines,
+        commit: (line, run) => {
+            this.setPackedLine(line, run);
+        },
+    };
+    /** Insert into the packed-lines LRU, evicting oldest entries on budget. */
+    setPackedLine(line, run) {
+        if (line.length > PACKED_MAX_LINE)
+            return;
+        if (this.packedLines.has(line)) {
+            this.packedLines.delete(line);
+            this.packedChars -= line.length;
+        }
+        while (this.packedLines.size >= CHAR_CACHE_MAX_ENTRIES ||
+            this.packedChars + line.length > CHAR_CACHE_MAX_CHARS) {
+            const oldest = this.packedLines.keys().next();
+            if (oldest.done === true)
+                break;
+            this.packedChars -= oldest.value.length;
+            this.packedLines.delete(oldest.value);
+        }
+        this.packedLines.set(detachString(line), run);
+        this.packedChars += line.length;
+    }
+    /**
+     * Streaming-tail slot, shared by every writeLineToScreen call of this
+     * Output (only one line grows per frame during streaming). Survives reset()
+     * like charCache - it is keyed by strict line extension, so stale entries
+     * can never produce a wrong hit.
+     */
+    streamingSlot = { current: null };
     constructor(options) {
         const { width, height, stylePool, screen } = options;
         this.width = width;
@@ -361,6 +560,12 @@ export default class Output {
                                 const from = x < clip.x1 ? clip.x1 - x : 0;
                                 const width = stringWidth(line);
                                 const to = x + width > clip.x2 ? clip.x2 - x : width;
+                                // Fast path: the line sits entirely inside the clip — no
+                                // slice needed. sliceAnsi re-tokenizes the line (the
+                                // dominant per-frame cost of long sessions otherwise:
+                                // every settled line, every frame).
+                                if (from === 0 && to === width)
+                                    return line;
                                 let sliced = sliceAnsi(line, from, to);
                                 // Wide chars (CJK, emoji) occupy 2 cells. When `to` lands
                                 // on the first cell of a wide char, sliceAnsi includes the
@@ -403,7 +608,7 @@ export default class Output {
                         if (lineY >= screenHeight) {
                             break;
                         }
-                        const contentEnd = writeLineToScreen(screen, line, x, lineY, screenWidth, this.stylePool, this.charCache);
+                        const contentEnd = writeLineToScreen(screen, line, x, lineY, screenWidth, this.stylePool, this.charCache, this.streamingSlot, this.packedOwner);
                         writeCells += contentEnd - x;
                         // See Screen.softWrap docstring for the encoding. contentEnd
                         // from writeLineToScreen is tab-expansion-aware, unlike
@@ -520,12 +725,45 @@ function flushBuffer(buffer, styles, stylePool, out) {
  * the caller can record it in screen.softWrap without re-walking the
  * line via stringWidth(). Caller computes the debug cell-count as end-x.
  */
-function writeLineToScreen(screen, line, x, y, screenWidth, stylePool, charCache) {
+function writeLineToScreen(screen, line, x, y, screenWidth, stylePool, charCache, streamingSlot, packed) {
+    // Fast path: replay the recorded packed run for this exact line — two
+    // typed-array stores per cell, no interning/packing/guard work. The run
+    // dies with its screen; a width transition needs the slow path's guards
+    // and replayCellRun reports that.
+    if (packed !== undefined) {
+        const run = packed.lines.get(line);
+        if (run !== undefined &&
+            run.charPool === screen.charPool &&
+            x >= 0 &&
+            x + cellRunSpan(run) <= screenWidth) {
+            if (replayCellRun(screen, x, y, run)) {
+                // LRU refresh (chars budget unchanged: same key length).
+                packed.lines.delete(line);
+                packed.lines.set(line, run);
+                return x + cellRunSpan(run);
+            }
+            // fall through to the slow path for this line this frame
+        }
+    }
     let characters = charCache.get(line);
     if (!characters) {
-        characters = reorderBidi(styledCharsWithGraphemeClustering(styledCharsFromTokens(tokenize(line)), stylePool));
+        characters = buildClusteredChars(line, stylePool, streamingSlot);
         charCache.set(line, characters);
     }
+    // Recording for the packed fast path: only plain single/wide char cells
+    // are recordable — control chars (tab expansion is x-relative), edge
+    // SpacerHead substitution, and y/x off-screen abort it. The packed-run
+    // limit is far above the charCache's MAX_CACHEABLE_LINE: a run costs
+    // three small integers per cell (no per-char objects), so even the
+    // ~700-char ANSI-art whale lines belong — without this they
+    // re-tokenize and re-cluster EVERY frame.
+    const recordable = packed !== undefined &&
+        line.length <= PACKED_MAX_LINE &&
+        x >= 0 &&
+        y >= 0 &&
+        y < screen.height;
+    let run = recordable ? createCellRun(screen) : undefined;
+    let runAlive = run !== undefined;
     let offsetX = x;
     for (let charIdx = 0; charIdx < characters.length; charIdx++) {
         const character = characters[charIdx];
@@ -534,6 +772,8 @@ function writeLineToScreen(screen, line, x, y, screenWidth, stylePool, charCache
         // mismatches. stringWidth treats these as width 0, but terminals may
         // move the cursor differently.
         if (codePoint !== undefined && codePoint <= 0x1f) {
+            // Not recordable: tab expansion is x-relative, ESC handling varies.
+            runAlive = false;
             // Tab (0x09): expand to spaces to reach next tab stop
             if (codePoint === 0x09) {
                 const tabWidth = 8;
@@ -636,9 +876,10 @@ function writeLineToScreen(screen, line, x, y, screenWidth, stylePool, charCache
         }
         const isWideCharacter = charWidth >= 2;
         // Wide char at last column can't fit — terminal would wrap it to
-        // the next line, desyncing our cursor model. Place a SpacerHead
-        // to mark the blank column, matching terminal behavior.
+        // the next line, desyncing our cursor model. Place a SpacerHead to
+        // mark the blank column, matching terminal behavior.
         if (isWideCharacter && offsetX + 2 > screenWidth) {
+            runAlive = false;
             setCellAt(screen, offsetX, y, {
                 char: ' ',
                 styleId: stylePool.none,
@@ -651,13 +892,39 @@ function writeLineToScreen(screen, line, x, y, screenWidth, stylePool, charCache
         // styleId + hyperlink were precomputed during clustering (once per
         // style run, cached via charCache). Hot loop is now just property
         // reads — no intern, no extract, no filter per frame.
+        const cellWidth = isWideCharacter ? 1 /* CellWidth.Wide */ : 0 /* CellWidth.Narrow */;
         setCellAt(screen, offsetX, y, {
             char: character.value,
             styleId: character.styleId,
-            width: isWideCharacter ? 1 /* CellWidth.Wide */ : 0 /* CellWidth.Narrow */,
+            width: cellWidth,
             hyperlink: character.hyperlink,
         });
+        if (runAlive && run !== undefined) {
+            recordCellRunEntry(run, screen, offsetX, {
+                char: character.value,
+                styleId: character.styleId,
+                width: cellWidth,
+                hyperlink: character.hyperlink,
+            });
+            // setCellAt also writes a SpacerTail after a wide char (when it
+            // fits); record that deterministic write too, or abort at the edge.
+            if (isWideCharacter) {
+                if (offsetX + 1 < screenWidth) {
+                    recordSpacerRunEntry(run, offsetX + 1);
+                }
+                else {
+                    runAlive = false;
+                }
+            }
+        }
         offsetX += isWideCharacter ? 2 : 1;
     }
+    // Commit the recording for the packed fast path. Complete NON-EMPTY
+    // runs only: an empty line ('' from split('\n'), zero-width-only lines)
+    // records zero entries and would commit a degenerate run whose replay
+    // writes NaN damage (gaps[0] undefined) and poisons the whole frame diff.
+    if (runAlive && run !== undefined && packed !== undefined && run.gaps.length > 0) {
+        packed.commit(line, run);
+    }
     return offsetX;
 }

package/lib/types/ink/render-node-to-output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-node-to-output.d.ts","sourceRoot":"","sources":["../../../src/ink/render-node-to-output.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAK1C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAqBxC,6CAA6C;AAC7C,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAOD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAWvE,qFAAqF;AACrF,wBAAgB,eAAe,IAAI,IAAI,CAItC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAEjD;AASD,8DAA8D;AAC9D,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,UAAU,GAAG,IAAI,CAEtD;AAUD;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAGD;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,YAAY,GAAG,IAAI,CAIzD;AAoFD;;;;;GAKG;AACH,iBAAS,qBAAqB,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,MAAM,EAAE,CASlE;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,wBAAwB,CAC/B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,aAAa,EAAE,EACzB,aAAa,EAAE,MAAM,EAAE,EACvB,aAAa,EAAE,MAAM,EACrB,WAAW,GAAE,OAAe,GAC3B,MAAM,CA0GR;AA+DD;;;;;;;;;GASG;AACH,iBAAS,kBAAkB,CACzB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IACP,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAM9B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,wBAAwB,CAAC,EAAE,KAAK,CAAA;CACjC,GACA,IAAI,CAk2BN;AAyOD,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,CAAA;AAE1D,eAAe,kBAAkB,CAAA"}
+{"version":3,"file":"render-node-to-output.d.ts","sourceRoot":"","sources":["../../../src/ink/render-node-to-output.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAK1C,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EACL,KAAK,aAAa,EAEnB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAqBxC,6CAA6C;AAC7C,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAExC;AAOD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAWvE,qFAAqF;AACrF,wBAAgB,eAAe,IAAI,IAAI,CAItC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAEjD;AASD,8DAA8D;AAC9D,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,UAAU,GAAG,IAAI,CAEtD;AAUD;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAGD;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,YAAY,GAAG,IAAI,CAIzD;AAoFD;;;;;GAKG;AACH,iBAAS,qBAAqB,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,MAAM,EAAE,CASlE;AAED;;;;;;;;;;;GAWG;AACH,iBAAS,wBAAwB,CAC/B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,aAAa,EAAE,EACzB,aAAa,EAAE,MAAM,EAAE,EACvB,aAAa,EAAE,MAAM,EACrB,WAAW,GAAE,OAAe,GAC3B,MAAM,CA0GR;AA+DD;;;;;;;;;GASG;AACH,iBAAS,kBAAkB,CACzB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IACP,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAM9B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,wBAAwB,CAAC,EAAE,KAAK,CAAA;CACjC,GACA,IAAI,CA62BN;AAyOD,OAAO,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,CAAA;AAE1D,eAAe,kBAAkB,CAAA"}

package/lib/types/ink/render-node-to-output.js

@@ -701,7 +701,9 @@ function renderNodeToOutput(node, output, options) {
                 const pending = node.pendingScrollDelta;
                 const cMin = node.scrollClampMin;
                 const cMax = node.scrollClampMax;
-                const haveClamp = cMin !== undefined && cMax !== undefined;
+                // Single-sided clamps are valid: sticky virtualization sets only the
+                // min (scroll-up protection during the sticky->manual transition)
+                // and leaves the max open for bottom-follow.
                 if (pending !== undefined && pending !== 0) {
                     // Drain continues even past the clamp — the render-clamp below
                     // holds the VISUAL at the mounted edge regardless. Hard-stopping
@@ -715,8 +717,8 @@ function renderNodeToOutput(node, output, options) {
                     // perceived stall at the edge). Past-clamp drain caps at ~4 rows/
                     // frame, roughly matching React's slide rate so the gap stays
                     // bounded and catch-up is quick once input stops.
-                    const pastClamp = haveClamp &&
-                        ((pending < 0 && cur < cMin) || (pending > 0 && cur > cMax));
+                    const pastClamp = (pending < 0 && cMin !== undefined && cur < cMin) ||
+                        (pending > 0 && cMax !== undefined && cur > cMax);
                     const eff = pastClamp ? Math.min(4, innerHeight >> 3) : innerHeight;
                     cur += isXtermJsHost()
                         ? drainAdaptive(node, pending, eff)
@@ -739,9 +741,7 @@ function renderNodeToOutput(node, output, options) {
                 // the right range. Not scheduling scrollDrainNode here keeps the
                 // clamp passive — React's commit → resetAfterCommit → onRender will
                 // paint again with fresh bounds.
-                const clamped = haveClamp
-                    ? Math.max(cMin, Math.min(scrollTop, cMax))
-                    : scrollTop;
+                const clamped = Math.max(cMin ?? -Infinity, Math.min(scrollTop, cMax ?? Infinity));
                 node.scrollTop = scrollTop;
                 // Clamp hitting top/bottom consumes any remainder. Set drainPending
                 // only after clamp so a wasted no-op frame isn't scheduled.
@@ -819,6 +819,14 @@ function renderNodeToOutput(node, output, options) {
                     const scrollHeight = contentYoga.getComputedHeight();
                     const prevHeight = contentCached?.height ?? scrollHeight;
                     const heightDelta = scrollHeight - prevHeight;
+                    // NOTE: scroll-up + streaming growth (delta < 0, heightDelta > 0)
+                    // deliberately stays OUT of the fast path. Virtualization moves the
+                    // topPad spacer on the same frame (every mounted row's yogaTop
+                    // shifts), so the appended-content screen mapping is not derivable
+                    // from prevHeight - a widened edge region misses rows and leaves
+                    // blitted stale copies next to the new ones (content duplication).
+                    // Upstream observed the same class of bug ("content bleeding
+                    // through during scroll-up + streaming") and chose the full path.
                     const safeForFastPath = !hint ||
                         heightDelta === 0 ||
                         (hint.delta > 0 && heightDelta === hint.delta);

package/lib/types/ink/screen.d.ts

@@ -339,6 +339,45 @@ export declare function charInCellAt(screen: Screen, x: number, y: number): stri
  * @param cell - the cell data to write.
  */
 export declare function setCellAt(screen: Screen, x: number, y: number, cell: Cell): void;
+/** A recorded run of packed cell writes for one screen line. */
+export interface CellRun {
+    /** Char pool the words were interned against. Screens ping-pong
+     *  (front/back double buffering) but SHARE their pools for a whole
+     *  session, so pool identity — not screen identity — is the validation
+     *  token; runs survive the screen swap and die only with the pools
+     *  (renderer recreation/resize). */
+    charPool: CharPool;
+    /** The shared stylePool.none — the spacer cells' style word. */
+    emptyStyleId: number;
+    /** Column gap from the previous written cell; the first entry's gap is
+     *  0 (its absolute column is the run's base). */
+    gaps: number[];
+    charIdxs: number[];
+    word1s: number[];
+    /** Absolute column of the first written cell (record time). */
+    baseX: number;
+    /** Absolute column of the last written cell (record time). */
+    lastX: number;
+}
+/** Begin recording a run for the given screen. */
+export declare function createCellRun(screen: Screen): CellRun;
+/** Record the cell the slow path is about to write at column x. */
+export declare function recordCellRunEntry(run: CellRun, screen: Screen, x: number, cell: Cell): void;
+/** Record the deterministic SpacerTail that setCellAt writes after a wide
+ *  char at column x (only when x < screen.width - 1). */
+export declare function recordSpacerRunEntry(run: CellRun, x: number): void;
+/**
+ * Replay a recorded run at (x, y): plain two-word stores, with the damage
+ * rect extended over the written span. Mirrors setCellAt's guard-fire
+ * conditions exactly — a replay is only valid when none of the three
+ * state-dependent fixups (wide-overwrite spacer cleanup, spacer-tail
+ * orphan cleanup, wide's next-cell orphan cleanup) would trigger; any
+ * other width transition is a plain overwrite. Returns false so the
+ * caller falls back to the slow path when a guard WOULD fire.
+ */
+export declare function replayCellRun(screen: Screen, x: number, y: number, run: CellRun): boolean;
+/** Column just past the last written cell — the run's content end. */
+export declare function cellRunSpan(run: CellRun): number;
 /**
  * Replace the styleId of a cell in-place without disturbing char, width,
  * or hyperlink. Preserves empty cells as-is (char stays ' '). Tracks damage

package/lib/types/ink/screen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../../../src/ink/screen.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../../../src/ink/screen.ts"],"names":[],"mappings":"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"}

package/lib/types/ink/screen.js

@@ -721,6 +721,123 @@ export function setCellAt(screen, x, y, cell) {
         }
     }
 }
+/** Begin recording a run for the given screen. */
+export function createCellRun(screen) {
+    return {
+        charPool: screen.charPool,
+        emptyStyleId: screen.emptyStyleId,
+        gaps: [],
+        charIdxs: [],
+        word1s: [],
+        baseX: -1,
+        lastX: -1,
+    };
+}
+/** Record the cell the slow path is about to write at column x. */
+export function recordCellRunEntry(run, screen, x, cell) {
+    if (run.baseX < 0)
+        run.baseX = x;
+    run.gaps.push(run.lastX < 0 ? 0 : x - run.lastX);
+    run.charIdxs.push(internCharString(screen, cell.char));
+    run.word1s.push(packWord1(cell.styleId, internHyperlink(screen, cell.hyperlink), cell.width));
+    run.lastX = x;
+}
+/** Record the deterministic SpacerTail that setCellAt writes after a wide
+ *  char at column x (only when x < screen.width - 1). */
+export function recordSpacerRunEntry(run, x) {
+    run.gaps.push(x - run.lastX);
+    run.charIdxs.push(SPACER_CHAR_INDEX);
+    run.word1s.push(packWord1(run.emptyStyleId, 0, 2 /* CellWidth.SpacerTail */));
+    run.lastX = x;
+}
+/**
+ * Replay a recorded run at (x, y): plain two-word stores, with the damage
+ * rect extended over the written span. Mirrors setCellAt's guard-fire
+ * conditions exactly — a replay is only valid when none of the three
+ * state-dependent fixups (wide-overwrite spacer cleanup, spacer-tail
+ * orphan cleanup, wide's next-cell orphan cleanup) would trigger; any
+ * other width transition is a plain overwrite. Returns false so the
+ * caller falls back to the slow path when a guard WOULD fire.
+ */
+export function replayCellRun(screen, x, y, run) {
+    if (x < 0 || y < 0 || y >= screen.height || x >= screen.width)
+        return false;
+    // Defensive: an empty run has no cells and no span — its damage math
+    // would be NaN. Callers never cache empty runs, but a future one might.
+    if (run.gaps.length === 0)
+        return false;
+    const cells = screen.cells;
+    const width = screen.width;
+    let ox = x;
+    const gaps = run.gaps;
+    for (let i = 0; i < gaps.length; i++) {
+        ox += gaps[i];
+        if (ox >= width)
+            return false;
+        const ci = ((y * width) + ox) << 1;
+        const w1 = run.word1s[i];
+        const newW = w1 & WIDTH_MASK;
+        const prevW = cells[ci + 1] & WIDTH_MASK;
+        if (newW === 0 /* CellWidth.Narrow */) {
+            // G1 (prev Wide → narrow overwrite cleans the spacer at x+1) and
+            // G2 (prev SpacerTail → clears the orphan wide at x-1) would fire.
+            if (prevW !== 0 /* CellWidth.Narrow */)
+                return false;
+        }
+        else if (newW === 1 /* CellWidth.Wide */) {
+            // G2: a SpacerTail under a Wide write clears the orphan at x-1.
+            if (prevW === 2 /* CellWidth.SpacerTail */)
+                return false;
+            // G3: the spacer this write puts at x+1 would stomp a Wide cell
+            // and needs its orphan cleanup.
+            if (ox + 1 < width && (cells[ci + 3] & WIDTH_MASK) === 1 /* CellWidth.Wide */) {
+                return false;
+            }
+        }
+        else {
+            // SpacerTail: G1 fires when it overwrites a Wide cell; G2's
+            // SpacerHead variant (prev SpacerTail under a non-SpacerTail write)
+            // can't occur in a recorded run — SpacerHead is never recorded — but
+            // keep the guard honest for that day soft-wrap starts recording it.
+            if (prevW === 1 /* CellWidth.Wide */ ||
+                (newW !== 2 /* CellWidth.SpacerTail */ && prevW === 2 /* CellWidth.SpacerTail */)) {
+                return false;
+            }
+        }
+        cells[ci] = run.charIdxs[i];
+        cells[ci + 1] = w1;
+    }
+    // Damage: the full written span, matching what per-cell updates in
+    // setCellAt would have accumulated.
+    const firstX = x + gaps[0];
+    const endX = ox + 1;
+    const damage = screen.damage;
+    if (damage !== undefined) {
+        const right = damage.x + damage.width;
+        if (firstX < damage.x) {
+            damage.width += damage.x - firstX;
+            damage.x = firstX;
+        }
+        else if (endX > right) {
+            damage.width += endX - right;
+        }
+        if (y < damage.y) {
+            damage.height += damage.y - y;
+            damage.y = y;
+        }
+        else if (y >= damage.y + damage.height) {
+            damage.height = y - damage.y + 1;
+        }
+    }
+    else {
+        screen.damage = { x: firstX, y, width: endX - firstX, height: 1 };
+    }
+    return true;
+}
+/** Column just past the last written cell — the run's content end. */
+export function cellRunSpan(run) {
+    return run.lastX - run.baseX + 1;
+}
 /**
  * Replace the styleId of a cell in-place without disturbing char, width,
  * or hyperlink. Preserves empty cells as-is (char stays ' '). Tracks damage

package/lib/types/ink/terminal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../../src/ink/terminal.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAKtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAKtC;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,SAAS,GAAG,WAAW,GAAG,OAAO,GAAG,eAAe,CAAA;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CAuCtD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAwDvD;AAcD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEnD;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAGnC;AAyBD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAG9C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,GAAE,MAAM,CAAC,QAA2B,EAC5C,WAAW,GAAE,MAAM,GAAG,SAAoC,EAC1D,kBAAkB,GAAE,MAAM,GAAG,SAA4C,GACxE,OAAO,CAOT;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,SAAkC,CAAA;AAEpE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAuBD;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,QAAQ,CAAA;CACjB,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,IAAI,EACV,eAAe,UAAQ,GACtB,IAAI,CAqEN"}
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../../src/ink/terminal.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAKtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAYtC;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,SAAS,GAAG,WAAW,GAAG,OAAO,GAAG,eAAe,CAAA;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CAuCtD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAwDvD;AAcD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEnD;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAGnC;AAyBD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAG9C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,GAAE,MAAM,CAAC,QAA2B,EAC5C,WAAW,GAAE,MAAM,GAAG,SAAoC,EAC1D,kBAAkB,GAAE,MAAM,GAAG,SAA4C,GACxE,OAAO,CAOT;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,SAAkC,CAAA;AAEpE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAuBD;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,QAAQ,CAAA;CACjB,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,IAAI,EACV,eAAe,UAAQ,GACtB,IAAI,CAwFN"}