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

package/lib/types/ink/ink.js

@@ -64,6 +64,7 @@ export default class Ink {
     options;
     log;
     terminal;
+    app = null;
     scheduleRender;
     // Ignore last render after unmounting a tree to prevent empty output before exit
     isUnmounted = false;
@@ -124,6 +125,11 @@ export default class Ink {
     // Set alongside altScreenActive so SIGCONT resume knows whether to
     // re-enable mouse tracking (not all <AlternateScreen> uses want it).
     altScreenMouseTracking = false;
+    // DEC 1049 preserves the physical main screen and cursor. Keep the matching
+    // renderer state while an inline full-screen view is active so its exit can
+    // diff from what the terminal actually restores instead of printing a full
+    // duplicate frame into main-screen scrollback.
+    mainScreenFrameState = null;
     // True when the previous frame's screen buffer cannot be trusted for
     // blit — selection overlay mutated it, resetFramesForAltScreen()
     // replaced it with blanks, or forceRedraw() reset it to 0×0. Forces
@@ -417,6 +423,24 @@ export default class Ink {
         // without the pop we'd accumulate depth on each editor round-trip).
         this.options.stdout.write('\x1b[?1004h' + (supportsWin32InputMode() ? ENABLE_WIN32_INPUT_MODE : supportsExtendedKeys() ? DISABLE_KITTY_KEYBOARD + ENABLE_KITTY_KEYBOARD + ENABLE_MODIFY_OTHER_KEYS : ''));
     }
+    /**
+     * One-shot viewport re-anchor for the NEXT main-screen frame: repaint the
+     * visible viewport in place instead of diffing. Exposed for callers that
+     * know a layout flip just rewrote the whole frame (Ctrl+O transcript
+     * toggle): the ordinary scroll-based diff pushes rows into terminal
+     * scrollback on every expand and nothing removes them on collapse — rapid
+     * toggles drift the virtual↔scrollback mapping until writes misland.
+     * In-place repaint adds nothing to scrollback. No-op in alt-screen
+     * (already CSI H-anchored every frame). ONLY sets the flag: the caller's
+     * own state change (setExpanded) drives the render that consumes it —
+     * forcing an extra render here would paint the OLD layout once more and
+     * burn the flag before the real frame lands.
+     */
+    reanchorViewport() {
+        if (this.altScreenActive)
+            return;
+        this.log.requestViewportReanchor();
+    }
     onRender() {
         if (this.isUnmounted || this.isPaused) {
             return;
@@ -855,9 +879,9 @@ export default class Ink {
     /**
      * Called by the <AlternateScreen> component on mount/unmount.
      * Controls cursor.y clamping in the renderer and gates alt-screen-aware
-     * behavior in SIGCONT/resize/unmount handlers. Repaints on change so
-     * the first alt-screen frame (and first main-screen frame on exit) is
-     * a full redraw with no stale diff state.
+     * behavior in SIGCONT/resize/unmount handlers. The first alt-screen frame
+     * redraws from blank; exit restores the saved main frame for a physical-
+     * screen-matched diff, with repaint as the resize fallback.
      */
     setAltScreenActive(active, mouseTracking = false) {
         if (this.altScreenActive === active)
@@ -865,10 +889,31 @@ export default class Ink {
         this.altScreenActive = active;
         this.altScreenMouseTracking = active && mouseTracking;
         if (active) {
+            this.mainScreenFrameState = {
+                frontFrame: this.frontFrame,
+                displayCursor: this.displayCursor,
+                columns: this.terminalColumns,
+                rows: this.terminalRows
+            };
             this.resetFramesForAltScreen();
         }
         else {
-            this.repaint();
+            const saved = this.mainScreenFrameState;
+            this.mainScreenFrameState = null;
+            if (saved && saved.columns === this.terminalColumns && saved.rows === this.terminalRows) {
+                this.frontFrame = saved.frontFrame;
+                this.displayCursor = saved.displayCursor;
+                this.log.reset();
+                // The main React subtree may have changed while the alternate screen
+                // was mounted. Disable blitting once, but keep the restored frame as
+                // the diff baseline that matches the terminal's physical contents.
+                this.prevFrameContaminated = true;
+            }
+            else {
+                // A resize reflows the terminal's saved main buffer, so the old frame
+                // is no longer a trustworthy physical baseline.
+                this.repaint();
+            }
         }
     }
     get isAltScreenActive() {
@@ -954,6 +999,7 @@ export default class Ink {
         // Cancel any pending throttled render so it doesn't fire between
         // cleanupTerminalModes() and process.exit() and write to main screen.
         this.scheduleRender.cancel?.();
+        this.app?.detachForShutdown();
         // Shutdown bypasses the normal unmount path, so release the process and
         // stdout listeners here as well. Otherwise a SIGCONT or resize arriving
         // while an updater is running can re-enter the alternate screen or render
@@ -988,6 +1034,39 @@ export default class Ink {
             }
         }
     }
+    /**
+     * Fully detach stdin before handing the terminal to a child process that
+     * inherits it (the /update restart). `detachForShutdown()` restores
+     * cooked mode but leaves the App's 'readable' pump attached — ordinary
+     * exits don't care because the process dies right after, but a parent
+     * that lingers waiting on the child keeps a libuv read pending on the
+     * console and races the child for every keypress: the restarted TUI
+     * sees dropped or entirely swallowed input (issues #284/#307). Remove
+     * the listeners and pause the pump so the child is the sole reader.
+     */
+    detachStdinForHandoff() {
+        const stdin = this.options.stdin;
+        try {
+            this.drainStdin();
+        }
+        catch {
+            // A destroyed stream must not block the handoff.
+        }
+        stdin.removeAllListeners('readable');
+        stdin.removeAllListeners('data');
+        try {
+            stdin.pause();
+        }
+        catch {
+            // Same destroyed-stream tolerance as above.
+        }
+        try {
+            stdin.unref();
+        }
+        catch {
+            // unref on a closed stream can throw on some Node versions.
+        }
+    }
     /** @see drainStdin */
     drainStdin() {
         drainStdin(this.options.stdin);
@@ -1468,9 +1547,12 @@ export default class Ink {
         }
         this.cursorDeclaration = decl;
     };
+    setAppRef(app) {
+        this.app = app;
+    }
     render(node) {
         this.currentNode = node;
-        const tree = _jsx(App, { stdin: this.options.stdin, stdout: this.options.stdout, stderr: this.options.stderr, exitOnCtrlC: this.options.exitOnCtrlC, onExit: this.unmount, terminalColumns: this.terminalColumns, terminalRows: this.terminalRows, selection: this.selection, onSelectionChange: this.notifySelectionChange, onClickAt: this.dispatchClick, onHoverAt: this.dispatchHover, getHyperlinkAt: this.getHyperlinkAt, onOpenHyperlink: this.openHyperlink, onMultiClick: this.handleMultiClick, onSelectionDrag: this.handleSelectionDrag, onStdinResume: this.reassertTerminalModes, onCursorDeclaration: this.setCursorDeclaration, dispatchKeyboardEvent: this.dispatchKeyboardEvent, children: _jsx(TerminalWriteProvider, { value: this.writeRaw, children: node }) });
+        const tree = _jsx(App, { ref: this.setAppRef, stdin: this.options.stdin, stdout: this.options.stdout, stderr: this.options.stderr, exitOnCtrlC: this.options.exitOnCtrlC, onExit: this.unmount, terminalColumns: this.terminalColumns, terminalRows: this.terminalRows, selection: this.selection, onSelectionChange: this.notifySelectionChange, onClickAt: this.dispatchClick, onHoverAt: this.dispatchHover, getHyperlinkAt: this.getHyperlinkAt, onOpenHyperlink: this.openHyperlink, onMultiClick: this.handleMultiClick, onSelectionDrag: this.handleSelectionDrag, onStdinResume: this.reassertTerminalModes, onCursorDeclaration: this.setCursorDeclaration, dispatchKeyboardEvent: this.dispatchKeyboardEvent, children: _jsx(TerminalWriteProvider, { value: this.writeRaw, children: node }) });
         // @ts-ignore -- ported CC build; type drift tolerated updateContainerSync exists in react-reconciler but not in @types/react-reconciler
         reconciler.updateContainerSync(tree, this.container, null, noop);
         // @ts-ignore -- ported CC build; type drift tolerated flushSyncWork exists in react-reconciler but not in @types/react-reconciler
@@ -1588,6 +1670,9 @@ export default class Ink {
         // them at the new pools so the next frame's IDs are comparable.
         this.backFrame.screen.charPool = this.charPool;
         this.backFrame.screen.hyperlinkPool = this.hyperlinkPool;
+        if (this.mainScreenFrameState) {
+            migrateScreenPools(this.mainScreenFrameState.frontFrame.screen, this.charPool, this.hyperlinkPool);
+        }
     }
     patchConsole() {
         // biome-ignore lint/suspicious/noConsole: intentionally patching global console

package/lib/types/ink/log-update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-update.d.ts","sourceRoot":"","sources":["../../../src/ink/log-update.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,IAAI,EAAiB,KAAK,EAAE,MAAM,YAAY,CAAA;AAE5D,OAAO,EASL,KAAK,SAAS,EAGf,MAAM,aAAa,CAAA;AAsBpB,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,OAAO,CAAA;IACd,SAAS,EAAE,SAAS,CAAA;CACrB,CAAA;AAKD;;;GAGG;AACH,qBAAa,SAAS;IAGR,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,KAAK,CAAO;gBAES,OAAO,EAAE,OAAO;IAO7C;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAAuB,IAAI,IAAI;IAI/B;;;;;OAKG;IACH,+BAA+B,CAAC,SAAS,EAAE,KAAK,GAAG,IAAI;IASvD,+HAA+H;IAC/H,KAAK,IAAI,IAAI;IAIb,OAAO,CAAC,eAAe;IAiDvB,OAAO,CAAC,mBAAmB;IAS3B;;;;;;;;OAQG;IACH,MAAM,CACJ,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,KAAK,EACX,SAAS,UAAQ,EACjB,WAAW,UAAO,GACjB,IAAI;CAgbR"}
+{"version":3,"file":"log-update.d.ts","sourceRoot":"","sources":["../../../src/ink/log-update.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,IAAI,EAAiB,KAAK,EAAE,MAAM,YAAY,CAAA;AAE5D,OAAO,EASL,KAAK,SAAS,EAGf,MAAM,aAAa,CAAA;AA4BpB,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,OAAO,CAAA;IACd,SAAS,EAAE,SAAS,CAAA;CACrB,CAAA;AAKD;;;GAGG;AACH,qBAAa,SAAS;IAGR,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,KAAK,CAAO;gBAES,OAAO,EAAE,OAAO;IAQ7C;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAAuB,IAAI,IAAI;IAI/B;;;;;OAKG;IACH,+BAA+B,CAAC,SAAS,EAAE,KAAK,GAAG,IAAI;IASvD,+HAA+H;IAC/H,KAAK,IAAI,IAAI;IASb,OAAO,CAAC,eAAe;IAiDvB,OAAO,CAAC,mBAAmB;IAS3B;;;;;;;;OAQG;IACH,MAAM,CACJ,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,KAAK,EACX,SAAS,UAAQ,EACjB,WAAW,UAAO,GACjB,IAAI;CAsfR"}

package/lib/types/ink/log-update.js

@@ -1,7 +1,7 @@
 import { ansiCodesToString, diffAnsiCodes, } from '@alcalzone/ansi-tokenize';
 import { logForDebugging } from '../utils/debug.js';
 import { cellAt, charInCellAt, diffEach, isEmptyCellAt, shiftRows, visibleCellAtIndex, } from './screen.js';
-import { CURSOR_HOME, cursorUp, eraseToEndOfScreen, scrollDown as csiScrollDown, scrollUp as csiScrollUp, RESET_SCROLL_REGION, SGR_RESET, setScrollRegion, } from './termio/csi.js';
+import { CURSOR_HOME, cursorDown, eraseToEndOfScreen, scrollDown as csiScrollDown, scrollUp as csiScrollUp, RESET_SCROLL_REGION, SGR_RESET, setScrollRegion, } from './termio/csi.js';
 import { isJetBrainsIdeTerminal } from './terminal.js';
 import { LINK_END, link as oscLink } from './termio/osc.js';
 const CARRIAGE_RETURN = { type: 'carriageReturn' };
@@ -18,6 +18,7 @@ export class LogUpdate {
         this.state = {
             previousOutput: '',
             reanchorPending: false,
+            anchoredPad: 0,
         };
     }
     /**
@@ -58,6 +59,11 @@ export class LogUpdate {
     /** Drop the previous-output state after the process resumes from suspension (SIGCONT) so terminal content is not clobbered. */
     reset() {
         this.state.previousOutput = '';
+        // Any anchored-pad offset is void: the next frame repaints from the
+        // physical cursor without it (SIGCONT resume, repaint(), forceRedraw,
+        // and alt-screen entry all land here — without the clear, rows the
+        // repaint just drew at the viewport top would stay marked unreachable).
+        this.state.anchoredPad = 0;
     }
     renderFullFrame(frame) {
         const { screen } = frame;
@@ -134,8 +140,13 @@ export class LogUpdate {
         // not reset here but that would involve predicting the current layout
         // _after_ the viewport change which means calcuating text wrapping.
         // Resizing is a rare enough event that it's not practically a big issue.
-        if (next.viewport.height < prev.viewport.height ||
+        if (next.viewport.height !== prev.viewport.height ||
             (prev.viewport.width !== 0 && next.viewport.width !== prev.viewport.width)) {
+            // A resize re-aligns the whole terminal (reflow rewraps scrollback):
+            // any anchored-pad offset from a previous shrink repaint is void.
+            // Height-only growth is included: the shrink branches below would
+            // otherwise mix the old and new viewport heights in their geometry.
+            this.state.anchoredPad = 0;
             return fullResetSequence_CAUSES_FLICKER(next, 'resize', stylePool);
         }
         // One-shot viewport re-anchor (see requestViewportReanchor): repaint
@@ -147,6 +158,15 @@ export class LogUpdate {
         // mutually exclusive anyway).
         if (this.state.reanchorPending && !altScreen) {
             this.state.reanchorPending = false;
+            // Plain in-place viewport repaint, and the anchored layout (if any)
+            // is superseded: pad 0. An earlier revision routed pad>0 frames
+            // through shrinkAnchoredRepaint here to preserve the anchored layout
+            // — empirically that occasionally painted nothing after alt-screen
+            // exits (verify-trace-scene's settle-gap check, ~15% flake), while
+            // the plain path is verified stable; a reanchor-with-pad is rare
+            // (idle gap right after a settle shrink) and its cost is one stale
+            // scrollback copy, not a lost paint.
+            this.state.anchoredPad = 0;
             return repaintViewportInPlace(prev, next, stylePool);
         }
         // DECSTBM scroll optimization: when a ScrollBox's scrollTop changed,
@@ -207,19 +227,35 @@ export class LogUpdate {
         const prevHadScrollback = cursorAtBottom && prev.screen.height >= prev.viewport.height;
         const isShrinking = next.screen.height < prev.screen.height;
         const nextFitsViewport = next.screen.height <= prev.viewport.height;
-        // When shrinking from above-viewport to at-or-below-viewport, content
-        // that was in scrollback stays there — terminal clears can't pull it
-        // back — but the viewport itself can be rebuilt in place: the cursor is
-        // parked at the physical bottom (prevHadScrollback implies it), so the
-        // viewport rows are all reachable. Repainting them directly avoids the
-        // former full reset here, whose clearTerminal + whole-frame reprint
-        // deposited one stale UI copy into the scrollback per shrink.
+        // When shrinking from above-viewport to at-or-below-viewport, the rows
+        // that scrolled into scrollback during growth come BACK into the live
+        // frame, so their scrollback snapshots are now duplicates (seen as the
+        // duplicated whale logo after the first turn). Use a clear-terminal
+        // reset, not an in-place repaint: at this point the UI's scrollback
+        // footprint is at most a viewport tall (prev was at most one row past
+        // the viewport), which is exactly what the clear sequence blanks — the
+        // in-place repaint kept both copies (snapshot + live). The former full
+        // reset here was once changed to an in-place repaint to stop the
+        // per-shrink stale-copy deposits (#38 #39 #19), but that fix traded
+        // them for a different duplication: the repainted viewport overlaps
+        // rows whose growth snapshots are still in scrollback.
         // Use <= (not <) because even when next height equals viewport height,
         // the scrollback depth from the previous render differs from a fresh
         // render.
-        if (prevHadScrollback && nextFitsViewport && isShrinking) {
-            logForDebugging(`Viewport repaint (shrink->below): prevHeight=${prev.screen.height}, nextHeight=${next.screen.height}, viewport=${prev.viewport.height}`);
-            return repaintViewportInPlace(prev, next, stylePool);
+        if (!altScreen && prevHadScrollback && nextFitsViewport && isShrinking) {
+            // Anchored tail repaint (see shrinkAnchoredRepaint): rows already in
+            // scrollback keep their originals; only the changed tail is
+            // repainted. The former full reset here reprinted the whole short
+            // frame from the viewport top — duplicating every pre-shrink row the
+            // user scrolls up to (the whale-logo / duplicated-transcript
+            // reports).
+            const scrollbackRows = Math.max(0, Math.max(prev.screen.height, next.screen.height) -
+                next.viewport.height +
+                (prevHadScrollback ? 1 : 0));
+            const { patches, anchoredPad } = shrinkAnchoredRepaint(prev, next, stylePool, scrollbackRows);
+            this.state.anchoredPad = anchoredPad;
+            logForDebugging(`Anchored shrink repaint (shrink->below): prevHeight=${prev.screen.height}, nextHeight=${next.screen.height}, viewport=${prev.viewport.height}, skip=${anchoredPad}`);
+            return patches;
         }
         // Steady-state scrollback check removed: rows above the viewport used
         // to force a full reset (ESC[2J+ESC[3J) whenever they changed, which
@@ -240,21 +276,42 @@ export class LogUpdate {
             const linesToClear = prev.screen.height - next.screen.height;
             // Main-screen mode + content taller than the viewport: the terminal
             // viewport does NOT follow the content bottom when content shrinks —
-            // a diff-loop path would write rows at stale physical offsets. But
-            // when the cursor sits on its park row (the invariant the renderer
-            // maintains every main-screen frame), the whole viewport is directly
-            // addressable: repaint it in place. This branch fires on EVERY turn
-            // (thinking fold, spinner/esc-hint unmount, markdown reflow shrink
-            // the frame by a row or two while it is taller than the viewport) —
-            // the former full reset here was the copy machine behind the
-            // duplicated-UI scrollback reports (#38 #39 #19). Fall back to the
-            // full reset only if the cursor is somewhere unexpected.
-            if (!altScreen && prev.screen.height > prev.viewport.height) {
-                if (cursorAtBottom) {
-                    logForDebugging(`Viewport repaint (shrink tall): prevHeight=${prev.screen.height}, nextHeight=${next.screen.height}, viewport=${prev.viewport.height}`);
-                    return repaintViewportInPlace(prev, next, this.options.stylePool);
-                }
-                return fullResetSequence_CAUSES_FLICKER(next, 'offscreen', this.options.stylePool);
+            // a diff-loop path would write rows at stale physical offsets. Two
+            // sub-cases:
+            //
+            // 1. Frame shrinks but stays >= viewport height: take the ordinary
+            //    diff loop. Its viewportY bookkeeping (the shrinking formula plus
+            //    cursorRestoreScroll below) addresses rows through the parked
+            //    cursor correctly, and the diff only touches the few rows that
+            //    actually changed. A viewport repaint here re-paints the whole
+            //    window from the viewport top while the frame top sits a few rows
+            //    ABOVE it (frame is taller than the window) — the growth frames
+            //    around the shrink freeze those overlapped rows into scrollback
+            //    as snapshots while the same rows stay live in the window, which
+            //    the user sees as duplicated transcript rows when scrolling up.
+            // 2. Frame shrinks to BELOW the viewport (content now fits): the rows
+            //    that scrolled into scrollback during growth come BACK into the
+            //    live frame, so their scrollback snapshots are now duplicates
+            //    (seen as the duplicated whale logo after the first turn). Use a
+            //    clear-terminal reset here, not an in-place repaint: at this
+            //    point the UI's scrollback footprint is at most a viewport tall,
+            //    which is exactly what the clear sequence blanks, while the
+            //    in-place repaint would keep both copies. Only fires early in a
+            //    session (frame ~= viewport); once the transcript outgrows the
+            //    viewport, case 1 handles every shrink.
+            if (!altScreen &&
+                prev.screen.height > prev.viewport.height &&
+                next.screen.height < next.viewport.height) {
+                // Same anchored tail repaint as the shrink->below branch above —
+                // rows already in scrollback keep their originals; only the
+                // non-scrollback tail is repainted. The former full reset
+                // reprinted the whole frame, duplicating the scrollback rows
+                // (whale-logo / duplicated-transcript reports).
+                const scrollbackRows = Math.max(0, prev.screen.height - prev.viewport.height + cursorRestoreScroll);
+                const { patches, anchoredPad } = shrinkAnchoredRepaint(prev, next, this.options.stylePool, scrollbackRows);
+                this.state.anchoredPad = anchoredPad;
+                logForDebugging(`Anchored shrink repaint (shrink to fit): prevHeight=${prev.screen.height}, nextHeight=${next.screen.height}, viewport=${prev.viewport.height}, skip=${anchoredPad}`);
+                return patches;
             }
             // eraseLines only works within the viewport - it can't clear scrollback.
             // If we need to clear more lines than fit in the viewport, some are in
@@ -280,11 +337,18 @@ export class LogUpdate {
         // an additional row out of view at the end of the previous frame. Without
         // this, the diff loop treats that row as reachable — but the cursor clamps
         // at viewport top, causing writes to land 1 row off and garbling the output.
-        const viewportY = growing
+        // Unreachable frame rows = terminal scrollback. Two contributors, take
+        // the MAX, never the sum: after an anchored shrink repaint the pad rows
+        // ARE the scrollback (heights undercount while H < V); once growth
+        // scrolls the blank band away, the heights formula takes over (summing
+        // would overcount and skip REACHABLE viewport rows — changes inside
+        // the viewport would never paint, scrambling the layout on mid-frame
+        // edits like Ctrl+O expansion).
+        const viewportY = Math.max(this.state.anchoredPad, growing
             ? Math.max(0, prev.screen.height - prev.viewport.height + cursorRestoreScroll)
             : Math.max(prev.screen.height, next.screen.height) -
                 next.viewport.height +
-                cursorRestoreScroll;
+                cursorRestoreScroll);
         // Rows above viewportY live in terminal scrollback and are skipped by the
         // diff loop (see below). Clip the damage region to the visible area so the
         // loop doesn't scan scrollback rows cell-by-cell every frame — with a tall
@@ -518,9 +582,82 @@ function fullResetSequence_CAUSES_FLICKER(frame, reason, stylePool, debug) {
     const contentRows = Math.min(height, Math.max(1, frame.viewport.height - 1));
     const startY = height - contentRows;
     const screen = new VirtualScreen({ x: 0, y: startY }, frame.viewport.width);
-    renderFrameSlice(screen, frame, startY, height, stylePool);
+    renderFrameSlice(screen, frame, startY, height, stylePool, false);
     return [{ type: 'clearTerminal', reason, debug }, ...screen.diff];
 }
+/**
+ * Anchored tail repaint for shrink-to-fit frames — the fix for the
+ * duplicated-whale/duplicated-transcript family. When growth pushed frame
+ * rows into terminal scrollback and a shrink then brings the frame back
+ * below the viewport, repainting the whole (short) frame from the viewport
+ * top re-prints rows whose originals already sit in scrollback — the user
+ * scrolls up and sees every pre-shrink row twice.
+ *
+ * Two layouts, decided by content:
+ *  - The new frame's top rows are UNCHANGED from the previous frame (the
+ *    common small shrink — a fold, a spinner unmounting): those rows
+ *    already live in scrollback and keep their originals. Erase the
+ *    viewport in place (no 2J — history untouched) and repaint ONLY the
+ *    changed tail, anchored at the viewport BOTTOM so the frame continues
+ *    the scrollback seamlessly. The leading blank band is recorded as
+ *    `anchoredPad` so later frames' viewportY math skips the scrollback
+ *    rows and relative addressing stays consistent (the band scrolls away
+ *    naturally as the next turn grows).
+ *  - The frame's top content CHANGED (a panel collapsing, 38 rows → 2):
+ *    nothing in scrollback represents the new frame — repaint the whole
+ *    short frame top-anchored, matching a fresh render (collapse-shrink's
+ *    contract), pad 0.
+ */
+function shrinkAnchoredRepaint(prev, next, stylePool, scrollbackRows) {
+    // Seam check, not prefix equality: the scrollback's DEEPEST row (old row
+    // skip-1) sits directly above the region we are about to paint — if it
+    // equals the new frame's row at the same index, the frame's lineage is
+    // intact (the shrink removed rows from the bottom region) and the
+    // scrollback originals stay authoritative. Volatile top rows (the
+    // status header's ticking counters) don't matter — only the seam does.
+    // Walk the skip down until the seam matches; 0 means the frame's top
+    // content changed (a collapsing panel) and the whole short frame gets a
+    // top-anchored repaint instead.
+    const width = Math.min(prev.screen.width, next.screen.width);
+    const rowsDiffer = (y) => {
+        if (y >= prev.screen.height || y >= next.screen.height)
+            return true;
+        const po = y * prev.screen.width * 2;
+        const no = y * next.screen.width * 2;
+        for (let x = 0; x < width * 2; x++) {
+            if (prev.screen.cells[po + x] !== next.screen.cells[no + x])
+                return true;
+        }
+        return false;
+    };
+    let skip = Math.min(scrollbackRows, next.screen.height);
+    while (skip > 0 && rowsDiffer(skip - 1))
+        skip -= 1;
+    const viewportHeight = prev.viewport.height;
+    const height = next.screen.height;
+    if (skip <= 0) {
+        // Top-anchored whole-frame repaint — the fresh-render layout.
+        const contentRows = Math.min(height, Math.max(1, viewportHeight - 1));
+        const startY = height - contentRows;
+        const anchor = CURSOR_HOME + eraseToEndOfScreen();
+        const screen = new VirtualScreen({ x: 0, y: startY }, next.viewport.width);
+        renderFrameSlice(screen, next, startY, height, stylePool, false);
+        return { patches: [{ type: 'stdout', content: anchor }, ...screen.diff], anchoredPad: 0 };
+    }
+    const rowsToPaint = Math.max(1, Math.min(height, viewportHeight - 1, height - skip));
+    const startY = height - rowsToPaint;
+    const blankBand = Math.max(0, viewportHeight - 1 - rowsToPaint);
+    const anchor = CURSOR_HOME + eraseToEndOfScreen() + (blankBand > 0 ? cursorDown(blankBand) : '');
+    const screen = new VirtualScreen({ x: 0, y: startY }, next.viewport.width);
+    renderFrameSlice(screen, next, startY, height, stylePool, false);
+    return {
+        patches: [{ type: 'stdout', content: anchor }, ...screen.diff],
+        // Cap at height-1: a seam that matches every row of a very short frame
+        // must not mark the WHOLE frame as scrollback — the last row (the
+        // input area) stays live and repaintable.
+        anchoredPad: Math.min(skip, height - 1),
+    };
+}
 /**
  * Repaint the visible viewport in place — the main-screen shrink recovery
  * that replaces fullResetSequence's clearTerminal + whole-frame reprint.
@@ -576,27 +713,42 @@ function viewportRepaintPatches(prev, next, stylePool, resetPrefix, origin) {
     // steady state, where the park LF materializes one row below the frame).
     const contentRows = Math.min(height, viewportHeight - 1);
     const startY = height - contentRows;
-    // A standalone recovery starts at the parked physical bottom row and must
-    // reach the viewport top. An appended repaint starts at next.cursor (the
-    // frame end), so moving up contentRows reaches the actual visible-frame
-    // start for both short and overflowing frames without crossing into shell
-    // history. Erase down from there (BCE fill — the SGR reset guarantees the
-    // default background). The erase also blanks the park row, so no stale
+    // Anchor with CSI H (cursor to viewport origin) instead of a RELATIVE
+    // cursor-up walk. The relative form assumed the physical cursor sits
+    // exactly on the park row — an assumption that breaks after a terminal
+    // reflow (a width change rewraps scrollback, shifting the buffer/cursor
+    // bookkeeping by a row or two). The over-shot cursor-up lands ABOVE the
+    // viewport top, and the subsequent erase+repaint writes a full UI copy
+    // into the scrollback (duplicated-history reports). CSI H has absolute
+    // semantics — it always lands on the current viewport's top-left — so the
+    // repaint can never cross into scrollback regardless of cursor drift.
+    // Erase down from there (BCE fill — the SGR reset guarantees the default
+    // background). The erase also blanks the park row, so no stale
     // prompt/status pixels survive below short content.
-    const rowsToStart = origin === 'viewport-bottom' ? viewportHeight - 1 : contentRows;
     const anchor = (resetPrefix ? SGR_RESET + LINK_END : '') +
-        '\r' +
-        cursorUp(rowsToStart) +
+        CURSOR_HOME +
         eraseToEndOfScreen();
     const screen = new VirtualScreen({ x: 0, y: startY }, next.viewport.width);
-    renderFrameSlice(screen, next, startY, height, stylePool);
+    renderFrameSlice(screen, next, startY, height, stylePool, false);
     return [{ type: 'stdout', content: anchor }, ...screen.diff];
 }
 /**
  * Render a slice of rows from the frame's screen.
  * Each row is rendered followed by a newline. Cursor ends at (0, endY).
  */
-function renderFrameSlice(screen, frame, startY, endY, stylePool) {
+function renderFrameSlice(screen, frame, startY, endY, stylePool, 
+/**
+ * When false (repaint / full-reset paths), advance rows with
+ * CR + cursor-down instead of bare LFs. The repaint paints exactly a
+ * viewport of rows starting at the viewport top; a trailing LF on the
+ * bottom row SCROLLS the terminal, pushing a copy of the just-painted
+ * rows into the scrollback that the cursor bookkeeping never accounted
+ * for — every later relative move lands offset, writing content into
+ * the history (duplicated transcript rows on scroll-up). cursor-down
+ * clamps at the bottom margin instead of scrolling, so the physical
+ * cursor stays exactly where the model expects it.
+ */
+allowScroll = true) {
     let currentStyleId = stylePool.none;
     let currentHyperlink = undefined;
     // Track the styleId of the last rendered cell on this line (-1 if none).
@@ -605,22 +757,30 @@ function renderFrameSlice(screen, frame, startY, endY, stylePool) {
     const { width: screenWidth, cells, charPool, hyperlinkPool } = frame.screen;
     let index = startY * screenWidth;
     for (let y = startY; y < endY; y += 1) {
-        // Advance cursor to this row using LF (not CSI CUD / cursor-down).
-        // CSI CUD stops at the viewport bottom margin and cannot scroll,
-        // but LF scrolls the viewport to create new lines. Without this,
+        // Advance cursor to this row. With allowScroll, use LF (not CSI CUD /
+        // cursor-down): CSI CUD stops at the viewport bottom margin and cannot
+        // scroll, but LF scrolls the viewport to create new lines. Without this,
         // when the cursor is at the viewport bottom, moveCursorTo's
         // cursor-down silently fails, creating a permanent off-by-one
         // between the virtual cursor and the real terminal cursor.
         if (screen.cursor.y < y) {
             const rowsToAdvance = y - screen.cursor.y;
-            screen.txn(prev => {
-                const patches = new Array(1 + rowsToAdvance);
-                patches[0] = CARRIAGE_RETURN;
-                for (let i = 0; i < rowsToAdvance; i++) {
-                    patches[1 + i] = NEWLINE;
-                }
-                return [patches, { dx: -prev.x, dy: rowsToAdvance }];
-            });
+            if (allowScroll) {
+                screen.txn(prev => {
+                    const patches = new Array(1 + rowsToAdvance);
+                    patches[0] = CARRIAGE_RETURN;
+                    for (let i = 0; i < rowsToAdvance; i++) {
+                        patches[1 + i] = NEWLINE;
+                    }
+                    return [patches, { dx: -prev.x, dy: rowsToAdvance }];
+                });
+            }
+            else {
+                screen.txn(prev => [
+                    [CARRIAGE_RETURN, { type: 'cursorMove', x: 0, y: rowsToAdvance }],
+                    { dx: -prev.x, dy: rowsToAdvance },
+                ]);
+            }
         }
         // Reset at start of each line — no cell rendered yet
         lastRenderedStyleId = -1;
@@ -650,10 +810,19 @@ function renderFrameSlice(screen, frame, startY, endY, stylePool) {
         // skip empty cells, we must reset explicitly.
         currentStyleId = transitionStyle(screen.diff, stylePool, currentStyleId, stylePool.none);
         currentHyperlink = transitionHyperlink(screen.diff, currentHyperlink, undefined);
-        // CR+LF at end of row — \r resets to column 0, \n moves to next line.
-        // Without \r, the terminal cursor stays at whatever column content ended
-        // (since we skip trailing spaces, this can be mid-row).
-        screen.txn(prev => [[CARRIAGE_RETURN, NEWLINE], { dx: -prev.x, dy: 1 }]);
+        // CR+LF (or CR+cursor-down for non-scrolling slices) at end of row —
+        // \r resets to column 0. Without \r, the terminal cursor stays at
+        // whatever column content ended (since we skip trailing spaces, this
+        // can be mid-row).
+        if (allowScroll) {
+            screen.txn(prev => [[CARRIAGE_RETURN, NEWLINE], { dx: -prev.x, dy: 1 }]);
+        }
+        else {
+            screen.txn(prev => [
+                [CARRIAGE_RETURN, { type: 'cursorMove', x: 0, y: 1 }],
+                { dx: -prev.x, dy: 1 },
+            ]);
+        }
     }
     // Reset any open style/hyperlink at end of slice
     transitionStyle(screen.diff, stylePool, currentStyleId, stylePool.none);

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

@@ -22,16 +22,29 @@ type ClusteredChar = {
  * no caller can accidentally grow it unboundedly.
  */
 export declare 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.
+     */
     private map;
     private chars;
     /**
-     * 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: string): ClusteredChar[] | undefined;
     /**
-     * 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.
      */
@@ -130,6 +143,26 @@ export default class Output {
     private screen;
     private readonly operations;
     private 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.
+     */
+    private packedLines;
+    private packedChars;
+    /** Stable owner handle passed to writeLineToScreen (no per-call closure). */
+    private readonly packedOwner;
+    /** Insert into the packed-lines LRU, evicting oldest entries on budget. */
+    private setPackedLine;
+    /**
+     * 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.
+     */
+    private streamingSlot;
     constructor(options: Options);
     /**
      * Reuse this Output for a new frame. Zeroes the screen buffer, clears

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

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