@deepseek-harness-tui/dsh-tui 0.8.1 → 0.8.3

package/lib/types/ink/output.js

@@ -4,7 +4,7 @@ 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,13 @@ 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
@@ -172,6 +214,7 @@ function hasRtlChars(text) {
  *  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
@@ -234,6 +277,41 @@ 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()
@@ -482,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
@@ -524,7 +608,7 @@ export default class Output {
                         if (lineY >= screenHeight) {
                             break;
                         }
-                        const contentEnd = writeLineToScreen(screen, line, x, lineY, screenWidth, this.stylePool, this.charCache, this.streamingSlot);
+                        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
@@ -641,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, streamingSlot) {
+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 = 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];
@@ -655,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;
@@ -757,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,
@@ -772,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/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;AAatC;;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,CAgFN"}
+{"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"}

package/lib/types/ink/terminal.js

@@ -2,7 +2,7 @@ import { coerce } from 'semver';
 import { appendFileSync } from 'node:fs';
 import { env } from '../utils/env.js';
 import { gte } from '../utils/semver.js';
-import { CURSOR_HOME, cursorMove, cursorTo, ERASE_SCREEN, ERASE_SCROLLBACK, eraseLines, SGR_RESET, } from './termio/csi.js';
+import { CURSOR_HOME, cursorMove, cursorTo, ERASE_SCREEN, eraseLines, SGR_RESET, } from './termio/csi.js';
 import { BSU, ESU, HIDE_CURSOR, SHOW_CURSOR } from './termio/dec.js';
 import { link } from './termio/osc.js';
 /**
@@ -321,11 +321,19 @@ export function writeDiffToTerminal(terminal, diff, skipSyncMarkers = false) {
                 // scrollback snapshots (the duplicated whale-logo class of bugs);
                 // the old soft clear (CSI n S) PUSHED the live viewport into the
                 // scrollback instead, depositing a fresh full-UI copy per reset.
+                // Screen-only hard clear: 2J + home, NO 3J. Erasing the scrollback
+                // here destroyed the user's entire visible history on every settle
+                // shrink (the "context lost / cannot scroll" reports) — the inline
+                // transcript IS the scrollback; wiping it to avoid duplicate
+                // snapshots is never an acceptable trade. 2J clears the screen for
+                // the repaint while everything above the viewport survives.
+                // Executed OUTSIDE the DEC 2026 sync block (split begin/end): WT
+                // yanks the viewport to top when 2J runs inside a synchronized
+                // update (claude-code#35580).
                 buffer +=
                     (useSync ? ESU : '') +
                         SGR_RESET +
                         ERASE_SCREEN +
-                        ERASE_SCROLLBACK +
                         CURSOR_HOME +
                         (useSync ? BSU : '');
                 break;

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

@@ -7,7 +7,7 @@ type WrapAnsiOptions = {
  * Wrap a string to a maximum column width, preserving ANSI escape sequences.
  *
  * Uses Bun.wrapAnsi when available; otherwise falls back to the wrap-ansi
- * package.
+ * package (with the incremental fast path for growing streaming inputs).
  * @param input - the string to wrap.
  * @param columns - the maximum width in columns.
  * @param options - wrap options: hard breaks long words, wordWrap splits on word boundaries, trim strips trailing whitespace.

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

@@ -1 +1 @@
-{"version":3,"file":"wrapAnsi.d.ts","sourceRoot":"","sources":["../../../src/ink/wrapAnsi.ts"],"names":[],"mappings":"AAEA,KAAK,eAAe,GAAG;IACrB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAOD;;;;;;;;;GASG;AACH,QAAA,MAAM,QAAQ,EAAE,CACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,KACtB,MAAmC,CAAA;AAExC,OAAO,EAAE,QAAQ,EAAE,CAAA"}
+{"version":3,"file":"wrapAnsi.d.ts","sourceRoot":"","sources":["../../../src/ink/wrapAnsi.ts"],"names":[],"mappings":"AAEA,KAAK,eAAe,GAAG;IACrB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AA0DD;;;;;;;;;GASG;AACH,QAAA,MAAM,QAAQ,EAAE,CACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,KACtB,MAEmB,CAAA;AAExB,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/lib/types/ink/wrapAnsi.js

@@ -2,15 +2,42 @@ import wrapAnsiNpm from 'wrap-ansi';
 const wrapAnsiBun = typeof Bun !== 'undefined' && typeof Bun.wrapAnsi === 'function'
     ? Bun.wrapAnsi
     : null;
+const SLOT_MIN_LENGTH = 2048;
+let slot = null;
+function slotOptionsApply(options) {
+    return options?.hard === true && (options?.trim ?? false) === false;
+}
+function wrapAnsiNpmIncremental(input, columns, options) {
+    const slottable = input.length > SLOT_MIN_LENGTH && slotOptionsApply(options);
+    if (slottable && slot !== null && slot.columns === columns && input.startsWith(slot.input)) {
+        const suffix = input.slice(slot.input.length);
+        if (!suffix.includes('\x1b') && !slot.remainder.includes('\x1b')) {
+            const tail = wrapAnsiNpm(slot.remainder + suffix, columns, options).split('\n');
+            const rows = [...slot.headRows, ...tail];
+            slot = { columns, input, headRows: rows.slice(0, -1), remainder: rows[rows.length - 1] ?? '' };
+            return rows.join('\n');
+        }
+    }
+    const result = wrapAnsiNpm(input, columns, options);
+    if (slottable && !input.includes('\x1b')) {
+        const rows = result.split('\n');
+        slot = { columns, input, headRows: rows.slice(0, -1), remainder: rows[rows.length - 1] ?? '' };
+    }
+    else {
+        slot = null;
+    }
+    return result;
+}
 /**
  * Wrap a string to a maximum column width, preserving ANSI escape sequences.
  *
  * Uses Bun.wrapAnsi when available; otherwise falls back to the wrap-ansi
- * package.
+ * package (with the incremental fast path for growing streaming inputs).
  * @param input - the string to wrap.
  * @param columns - the maximum width in columns.
  * @param options - wrap options: hard breaks long words, wordWrap splits on word boundaries, trim strips trailing whitespace.
  * @returns the wrapped string.
  */
-const wrapAnsi = wrapAnsiBun ?? wrapAnsiNpm;
+const wrapAnsi = wrapAnsiBun ??
+    wrapAnsiNpmIncremental;
 export { wrapAnsi };

package/lib/types/plugin-host.d.ts

@@ -1,13 +1,15 @@
-export * from './dsh-adapter/plugin-host.js';
-export * from './dsh-adapter/grants.js';
-export * from './dsh-adapter/host-descriptor.js';
-export * from './dsh-adapter/plugin-storage.js';
-export * from './dsh-adapter/message-observer.js';
-export * from './dsh-adapter/effect-ledger.js';
-export * from './dsh-adapter/command-errors.js';
-export { commandOwner, fiberNameOf, stampCommandOwner, unstampCommandOwner } from './dsh-adapter/command-attribution.js';
-export { DECISION_EVENT_PERMISSIONS, decisionHandlersOf, registerDecisionHandler, withDecisionRegistration, } from './dsh-adapter/decision-guard.js';
-export { DECISION_HANDLER_TIMEOUT_MS, DECISION_TOTAL_TIMEOUT_MS, dispatchTuiNotification, } from './dsh-adapter/extension-events.js';
+export { name, apply } from './dsh-adapter/plugin-host.js';
+export type { TuiPluginHost } from './dsh-adapter/plugin-host.js';
+export type { GrantPrincipal, GrantStore } from './dsh-adapter/grants.js';
+export type { HostContract, HostDescriptor, ContractCoordinate, ContractRef, NegotiationDecision, PermissionEntry, PermissionRegistry } from './plugin-spec/types.js';
+export type { TuiPluginStorage, PluginStorageErrorCode, TuiPluginStorageRuntime } from './dsh-adapter/plugin-storage.js';
+export { PluginStorageError, STORAGE_KEY_MAX_LENGTH, STORAGE_MAX_BYTES, STORAGE_MAX_KEYS } from './dsh-adapter/plugin-storage.js';
+export { OBSERVE_CALLBACK_QUEUE_LIMIT, OBSERVE_CALLBACK_TIMEOUT_MS, OBSERVE_CONTENT_MAX_CHARS, OBSERVE_ID_MAX_CHARS, OBSERVE_IMAGE_BASE64_MAX_CHARS, OBSERVE_IMAGE_MAX_BYTES, OBSERVE_SCOPE_MAX_CHARS, OBSERVE_SUMMARY_CELLS, } from './dsh-adapter/message-observer.js';
+export type { MessagesObserveContentBlock, MessagesObserveEnvelope, MessagesObserveListener, MessagesObservePayload, TuiMessageObserverRuntime, } from './dsh-adapter/message-observer.js';
+export type { LedgerEntry, LedgerOperation, LedgerResult, TuiEffectLedgerRuntime } from './dsh-adapter/effect-ledger.js';
+export { COMMAND_ERROR_CODES, hasCommandErrorCode, mapCommandError, withCommandErrorMapping, } from './dsh-adapter/command-errors.js';
+export type { CommandErrorCode, CodedCommandError } from './dsh-adapter/command-errors.js';
+export { DECISION_EVENT_PERMISSIONS, } from './dsh-adapter/decision-guard.js';
+export { DECISION_HANDLER_TIMEOUT_MS, DECISION_TOTAL_TIMEOUT_MS, } from './dsh-adapter/extension-events.js';
 export { DECISION_EVENTS_COORDINATE, TUI_EXTENSION_API_VERSION, TUI_DECISION_EVENT_NAMES, TUI_EXTENSION_PERMISSION_NAMES, createAdmissionCatalog, } from './plugin-spec/tui-extension.js';
-export type { ContractCoordinate, ContractRef, HostContract, HostDescriptor, NegotiationDecision, PermissionEntry, PermissionRegistry, } from './plugin-spec/types.js';
 //# sourceMappingURL=plugin-host.d.ts.map

package/lib/types/plugin-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-host.d.ts","sourceRoot":"","sources":["../../src/plugin-host.ts"],"names":[],"mappings":"AAMA,cAAc,8BAA8B,CAAA;AAC5C,cAAc,yBAAyB,CAAA;AACvC,cAAc,kCAAkC,CAAA;AAChD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,mCAAmC,CAAA;AACjD,cAAc,gCAAgC,CAAA;AAC9C,cAAc,iCAAiC,CAAA;AAC/C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAA;AACxH,OAAO,EACL,0BAA0B,EAC1B,kBAAkB,EAClB,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,iCAAiC,CAAA;AACxC,OAAO,EACL,2BAA2B,EAC3B,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,EACxB,8BAA8B,EAC9B,sBAAsB,GACvB,MAAM,gCAAgC,CAAA;AAEvC,YAAY,EACV,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,kBAAkB,GACnB,MAAM,wBAAwB,CAAA"}
+{"version":3,"file":"plugin-host.d.ts","sourceRoot":"","sources":["../../src/plugin-host.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAA;AAC1D,YAAY,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AACjE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACzE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,mBAAmB,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AACrK,YAAY,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AACxH,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAIjI,OAAO,EACL,4BAA4B,EAC5B,2BAA2B,EAC3B,yBAAyB,EACzB,oBAAoB,EACpB,8BAA8B,EAC9B,uBAAuB,EACvB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,mCAAmC,CAAA;AAC1C,YAAY,EACV,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,mCAAmC,CAAA;AAE1C,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAA;AACxH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,eAAe,EACf,uBAAuB,GACxB,MAAM,iCAAiC,CAAA;AACxC,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AAK1F,OAAO,EACL,0BAA0B,GAC3B,MAAM,iCAAiC,CAAA;AACxC,OAAO,EACL,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,EACxB,8BAA8B,EAC9B,sBAAsB,GACvB,MAAM,gCAAgC,CAAA"}