@code-yeongyu/senpi-tui 2026.10.1 → 2026.10.3

package/dist/autocomplete.d.ts

@@ -3,7 +3,7 @@ export interface AutocompleteItem {
     label: string;
     description?: string;
     /**
-     * The command declares an argument hint: confirming the row completes `/name ` and waits for
+     * The command requires arguments: confirming the row completes `/name ` and waits for
      * arguments instead of submitting.
      */
     awaitsArguments?: boolean;
@@ -13,6 +13,8 @@ export interface SlashCommand {
     name: string;
     description?: string;
     argumentHint?: string;
+    /** Whether picker Enter must wait for arguments. Omitted means: wait only when `argumentHint` is set. */
+    requiresArguments?: boolean;
     getArgumentCompletions?(argumentPrefix: string): Awaitable<AutocompleteItem[] | null>;
 }
 export interface AutocompleteSuggestions {

package/dist/autocomplete.js

@@ -240,16 +240,17 @@ export class CombinedAutocompleteProvider {
                 prefix: dollarContext.prefix,
             };
         }
-        if (!options.force && textBeforeCursor.startsWith("/")) {
-            const spaceIndex = textBeforeCursor.indexOf(" ");
+        const commandText = textBeforeCursor.trimStart();
+        if (!options.force && commandText.startsWith("/")) {
+            const spaceIndex = commandText.indexOf(" ");
             if (spaceIndex === -1) {
-                const prefix = textBeforeCursor.slice(1);
+                const prefix = commandText.slice(1);
                 const filtered = getSlashCommandSuggestions(this.commands, prefix);
                 if (filtered.length === 0)
                     return null;
                 return {
                     items: filtered,
-                    prefix: textBeforeCursor,
+                    prefix: commandText,
                 };
             }
             const tokenStart = textBeforeCursor.search(/\S+$/);
@@ -268,8 +269,8 @@ export class CombinedAutocompleteProvider {
                     prefix: currentToken,
                 };
             }
-            const commandName = textBeforeCursor.slice(1, spaceIndex);
-            const argumentText = textBeforeCursor.slice(spaceIndex + 1);
+            const commandName = commandText.slice(1, spaceIndex);
+            const argumentText = commandText.slice(spaceIndex + 1);
             const command = this.commands.find((cmd) => {
                 const name = "name" in cmd ? cmd.name : cmd.value;
                 return name === commandName;

package/dist/components/box.d.ts

@@ -10,6 +10,7 @@ export declare class Box implements Component {
     private disposed;
     private cache?;
     private mouseLayout?;
+    private readonly composite;
     constructor(paddingX?: number, paddingY?: number, bgFn?: (text: string) => string);
     addChild(component: Component): void;
     removeChild(component: Component): void;
@@ -20,6 +21,10 @@ export declare class Box implements Component {
     private invalidateCache;
     private matchCache;
     invalidate(): void;
+    /** Padding plus background over the children: exact `Box` instances change only with them (see `Container`). */
+    getRenderRevision(): number | undefined;
+    protected childRenderRevision(): number | undefined;
+    protected bumpRenderRevision(): void;
     handleMouse(event: TuiMouseEvent): TuiMouseDispatchResult | undefined;
     render(width: number): string[];
     private applyBg;

package/dist/components/box.js

@@ -1,5 +1,5 @@
-import { dispatchMouseEvent } from "../tui.js";
-import { applyBackgroundToLine, visibleWidth } from "../utils.js";
+import { CompositeRevision, dispatchMouseEvent, } from "../tui.js";
+import { applyBackgroundToLine, flattenLines, visibleWidth } from "../utils.js";
 /**
  * Box component - a container that applies padding and background to all children
  */
@@ -7,6 +7,7 @@ export class Box {
     constructor(paddingX = 1, paddingY = 1, bgFn) {
         this.children = [];
         this.disposed = false;
+        this.composite = new CompositeRevision();
         this.paddingX = paddingX;
         this.paddingY = paddingY;
         this.bgFn = bgFn;
@@ -45,10 +46,12 @@ export class Box {
     }
     setBgFn(bgFn) {
         this.bgFn = bgFn;
+        this.composite.bump();
         // Don't invalidate here - we'll detect bgFn changes by sampling output
     }
     invalidateCache() {
         this.cache = undefined;
+        this.composite.bump();
     }
     matchCache(width, childLines, bgSample) {
         const cache = this.cache;
@@ -60,10 +63,21 @@ export class Box {
     }
     invalidate() {
         this.invalidateCache();
+        this.composite.bump();
         for (const child of this.children) {
             child.invalidate?.();
         }
     }
+    /** Padding plus background over the children: exact `Box` instances change only with them (see `Container`). */
+    getRenderRevision() {
+        return Object.getPrototypeOf(this) === Box.prototype ? this.childRenderRevision() : undefined;
+    }
+    childRenderRevision() {
+        return this.composite.read(this.children);
+    }
+    bumpRenderRevision() {
+        this.composite.bump();
+    }
     handleMouse(event) {
         const contentWidth = Math.max(1, event.width - this.paddingX * 2);
         const contentY = event.y - this.paddingY;
@@ -131,6 +145,7 @@ export class Box {
             result.push(this.applyBg("", width));
         }
         // Update cache
+        flattenLines(result);
         this.cache = { childLines, width, bgSample, lines: result };
         return result;
     }

package/dist/components/markdown.d.ts

@@ -1,4 +1,4 @@
-import type { Component } from "../tui.ts";
+import { type Component } from "../tui.ts";
 export declare function clearRenderCache(): void;
 export declare function getMarkdownHighlightCallCount(): number;
 export declare function resetMarkdownHighlightCallCount(): void;
@@ -64,9 +64,14 @@ export declare class Markdown implements Component {
     private cachedText?;
     private cachedWidth?;
     private cachedLines?;
+    private revision;
     constructor(text: string, paddingX: number, paddingY: number, theme: MarkdownTheme, defaultTextStyle?: DefaultTextStyle, options?: MarkdownOptions);
     setText(text: string): void;
     invalidate(): void;
+    /** Instances that expose a revision advance the shared clock; others (e.g. an animated subclass) stay local. */
+    private markRevision;
+    /** Exact `Markdown` instances only; a subclass may render more than its source text. */
+    getRenderRevision(): number | undefined;
     render(width: number): string[];
     /**
      * Apply default text style to a string.

package/dist/components/markdown.js

@@ -1,7 +1,8 @@
 // allow: SIZE_OK - existing markdown renderer is oversized; this merge only preserves behavior and cache-key correctness.
 import { Marked, Tokenizer } from "marked";
 import { getCapabilities, hyperlink, isImageLine } from "../terminal-image.js";
-import { applyBackgroundToLine, visibleWidth, wrapTextWithAnsi } from "../utils.js";
+import { nextRenderRevision } from "../tui.js";
+import { applyBackgroundToLine, flattenLines, visibleWidth, wrapTextWithAnsi } from "../utils.js";
 import { latexToUnicode } from "./latex.js";
 const STRICT_STRIKETHROUGH_REGEX = /^(~~)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/;
 class StrictStrikethroughTokenizer extends Tokenizer {
@@ -326,6 +327,7 @@ export function resetMarkdownHighlightCallCount() {
 }
 export class Markdown {
     constructor(text, paddingX, paddingY, theme, defaultTextStyle, options) {
+        this.revision = nextRenderRevision();
         this.text = text;
         this.paddingX = paddingX;
         this.paddingY = paddingY;
@@ -341,6 +343,15 @@ export class Markdown {
         this.cachedText = undefined;
         this.cachedWidth = undefined;
         this.cachedLines = undefined;
+        this.markRevision();
+    }
+    /** Instances that expose a revision advance the shared clock; others (e.g. an animated subclass) stay local. */
+    markRevision() {
+        this.revision = this.getRenderRevision() === undefined ? this.revision + 1 : nextRenderRevision();
+    }
+    /** Exact `Markdown` instances only; a subclass may render more than its source text. */
+    getRenderRevision() {
+        return Object.getPrototypeOf(this) === Markdown.prototype ? this.revision : undefined;
     }
     render(width) {
         // Check cache
@@ -448,6 +459,7 @@ export class Markdown {
         }
         // Combine top padding, content, and bottom padding
         const result = emptyLines.concat(contentLines, emptyLines);
+        flattenLines(result);
         // Update cache
         this.cachedText = this.text;
         this.cachedWidth = width;

package/dist/components/mouse-region.d.ts

@@ -6,6 +6,8 @@ export declare class MouseRegion implements Component {
     private readonly onMouse;
     constructor(child: Component, onMouse: MouseRegionHandler);
     render(width: number): string[];
+    /** Exact regions render their child unchanged; a subclass may add state and opts in itself. */
+    getRenderRevision(): number | undefined;
     handleMouse(event: TuiMouseEvent): TuiMouseDispatchResult | TuiMouseEventResult | undefined;
     invalidate(): void;
 }

package/dist/components/mouse-region.js

@@ -8,6 +8,10 @@ export class MouseRegion {
     render(width) {
         return this.child.render(width);
     }
+    /** Exact regions render their child unchanged; a subclass may add state and opts in itself. */
+    getRenderRevision() {
+        return Object.getPrototypeOf(this) === MouseRegion.prototype ? this.child.getRenderRevision?.() : undefined;
+    }
     handleMouse(event) {
         const childResult = dispatchMouseEvent(this.child, event);
         return childResult ?? this.onMouse(event);

package/dist/components/spacer.d.ts

@@ -1,12 +1,16 @@
-import type { Component } from "../tui.ts";
+import { type Component } from "../tui.ts";
 /**
  * Spacer component that renders empty lines
  */
 export declare class Spacer implements Component {
     private lines;
+    private revision;
     constructor(lines?: number);
     setLines(lines: number): void;
     invalidate(): void;
+    /** Instances that expose a revision advance the shared clock; others (e.g. an animated subclass) stay local. */
+    private markRevision;
+    getRenderRevision(): number | undefined;
     render(_width: number): string[];
 }
 //# sourceMappingURL=spacer.d.ts.map

package/dist/components/spacer.js

@@ -1,15 +1,25 @@
+import { nextRenderRevision } from "../tui.js";
 /**
  * Spacer component that renders empty lines
  */
 export class Spacer {
     constructor(lines = 1) {
+        this.revision = nextRenderRevision();
         this.lines = lines;
     }
     setLines(lines) {
         this.lines = lines;
+        this.markRevision();
     }
     invalidate() {
-        // No cached state to invalidate currently
+        this.markRevision();
+    }
+    /** Instances that expose a revision advance the shared clock; others (e.g. an animated subclass) stay local. */
+    markRevision() {
+        this.revision = this.getRenderRevision() === undefined ? this.revision + 1 : nextRenderRevision();
+    }
+    getRenderRevision() {
+        return Object.getPrototypeOf(this) === Spacer.prototype ? this.revision : undefined;
     }
     render(_width) {
         const result = [];

package/dist/components/text.d.ts

@@ -1,4 +1,4 @@
-import type { Component } from "../tui.ts";
+import { type Component } from "../tui.ts";
 /**
  * Text component - displays multi-line text with word wrapping
  */
@@ -10,10 +10,17 @@ export declare class Text implements Component {
     private cachedText?;
     private cachedWidth?;
     private cachedLines?;
+    private revision;
     constructor(text?: string, paddingX?: number, paddingY?: number, customBgFn?: (text: string) => string);
     setText(text: string): void;
     setCustomBgFn(customBgFn?: (text: string) => string): void;
     invalidate(): void;
+    /** Instances that expose a revision advance the shared clock; others (e.g. an animated subclass) stay local. */
+    private markRevision;
+    /** Exact `Text` instances only: a subclass may render more than its text and opts in with {@link textRenderRevision}. */
+    getRenderRevision(): number | undefined;
+    /** Revision of the text, padding and background state this class renders. */
+    protected textRenderRevision(): number;
     render(width: number): string[];
 }
 //# sourceMappingURL=text.d.ts.map

package/dist/components/text.js

@@ -1,15 +1,19 @@
-import { applyBackgroundToLine, visibleWidth, wrapTextWithAnsi } from "../utils.js";
+import { nextRenderRevision } from "../tui.js";
+import { applyBackgroundToLine, flattenLines, visibleWidth, wrapTextWithAnsi } from "../utils.js";
 /**
  * Text component - displays multi-line text with word wrapping
  */
 export class Text {
     constructor(text = "", paddingX = 1, paddingY = 1, customBgFn) {
+        this.revision = nextRenderRevision();
         this.text = text;
         this.paddingX = paddingX;
         this.paddingY = paddingY;
         this.customBgFn = customBgFn;
     }
     setText(text) {
+        if (text !== this.text)
+            this.markRevision();
         this.text = text;
         this.cachedText = undefined;
         this.cachedWidth = undefined;
@@ -17,6 +21,7 @@ export class Text {
     }
     setCustomBgFn(customBgFn) {
         this.customBgFn = customBgFn;
+        this.markRevision();
         this.cachedText = undefined;
         this.cachedWidth = undefined;
         this.cachedLines = undefined;
@@ -25,6 +30,19 @@ export class Text {
         this.cachedText = undefined;
         this.cachedWidth = undefined;
         this.cachedLines = undefined;
+        this.markRevision();
+    }
+    /** Instances that expose a revision advance the shared clock; others (e.g. an animated subclass) stay local. */
+    markRevision() {
+        this.revision = this.getRenderRevision() === undefined ? this.revision + 1 : nextRenderRevision();
+    }
+    /** Exact `Text` instances only: a subclass may render more than its text and opts in with {@link textRenderRevision}. */
+    getRenderRevision() {
+        return Object.getPrototypeOf(this) === Text.prototype ? this.revision : undefined;
+    }
+    /** Revision of the text, padding and background state this class renders. */
+    textRenderRevision() {
+        return this.revision;
     }
     render(width) {
         // Check cache
@@ -72,6 +90,7 @@ export class Text {
             emptyLines.push(line);
         }
         const result = [...emptyLines, ...contentLines, ...emptyLines];
+        flattenLines(result);
         // Update cache
         this.cachedText = this.text;
         this.cachedWidth = width;

package/dist/index.d.ts

@@ -29,12 +29,12 @@ export { getNativeClipboard, type NativeClipboard } from "./native-platform.ts";
 export { oklabToOkhslLightness } from "./oklab.ts";
 export { type EditorPasteState, expandPasteMarkers } from "./paste-markers.ts";
 export { StdinBuffer, type StdinBufferEventMap, type StdinBufferOptions } from "./stdin-buffer.ts";
-export { type CursorPosition, ProcessTerminal, type ProcessTerminalOptions, type Terminal } from "./terminal.ts";
+export { type CursorPosition, isAppleTerminalSession, isWarpWslSession, ProcessTerminal, type ProcessTerminalOptions, type Terminal, } from "./terminal.ts";
 export { parseTerminalColorSchemeReport, type RgbColor, type TerminalColorScheme, type TerminalColors, } from "./terminal-colors.ts";
 export declare function calculateImageRows(imageDimensions: ImageDimensions, targetWidthCells: number, cellDimensions?: CellDimensions): number;
 export { allocateImageId, buildKittyPlaceholderRow, type CellDimensions, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getTerminalColorMode, getWebpDimensions, hyperlink, type ImageDimensions, type ImageProtocol, type ImageRenderOptions, imageFallback, KITTY_PLACEHOLDER_MAX, outerKittyGraphicsMode, renderImage, resetCapabilitiesCache, setCapabilities, setCapabilityOverrides, setCellDimensions, type TerminalCapabilities, type TmuxPassthroughState, wrapTmuxPassthrough, } from "./terminal-image.ts";
 export { sanitizeTerminalLabel, shortenImagePath } from "./terminal-text.ts";
-export { type Component, Container, CURSOR_MARKER, compositeTuiLine, type Focusable, isFocusable, isViewportTUI, type OverlayAnchor, type OverlayBounds, type OverlayHandle, type OverlayMargin, type OverlayOptions, type OverlayUnfocusOptions, type SizeValue, TUI, type TuiInputListener, type TuiInputListenerResult, type TuiMode, type TuiMouseButton, type TuiMouseEvent, type TuiMouseEventResult, type TuiMouseEventType, type TuiStopOptions, type ViewportTUI, } from "./tui.ts";
+export { type Component, CompositeRevision, Container, CURSOR_MARKER, claimFrameRow, compositeTuiLine, currentRenderRevision, dispatchMouseEvent, type Focusable, frameMode, frameScrollbackRows, isFocusable, isViewportTUI, joinLineArrays, mainScreenHistoryLines, nextRenderRevision, type OverlayAnchor, type OverlayBounds, type OverlayHandle, type OverlayMargin, type OverlayOptions, type OverlayUnfocusOptions, renderAtFrameRow, resetMainScreenHistoryLines, type SizeValue, TUI, type TuiInputListener, type TuiInputListenerResult, type TuiMode, type TuiMouseButton, type TuiMouseDispatchResult, type TuiMouseEvent, type TuiMouseEventResult, type TuiMouseEventType, type TuiStopOptions, type ViewportTUI, } from "./tui.ts";
 export { TuiAltScreen, type TuiAltScreenOptions } from "./tui-alt-screen.ts";
 export { TuiMainScreen, type TuiMainScreenRenderState } from "./tui-main-screen.ts";
 export { getGraphemeSegmenter, getOsc8LinkAtColumn, getWordSegmenter, sliceByColumn, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "./utils.ts";

package/dist/index.js

@@ -40,7 +40,7 @@ export { expandPasteMarkers } from "./paste-markers.js";
 // Input buffering for batch splitting
 export { StdinBuffer } from "./stdin-buffer.js";
 // Terminal interface and implementations
-export { ProcessTerminal } from "./terminal.js";
+export { isAppleTerminalSession, isWarpWslSession, ProcessTerminal, } from "./terminal.js";
 // Terminal colors
 export { parseTerminalColorSchemeReport, } from "./terminal-colors.js";
 // Terminal image support
@@ -49,7 +49,7 @@ export function calculateImageRows(imageDimensions, targetWidthCells, cellDimens
 }
 export { allocateImageId, buildKittyPlaceholderRow, deleteAllKittyImages, deleteKittyImage, detectCapabilities, encodeITerm2, encodeKitty, getCapabilities, getCellDimensions, getGifDimensions, getImageDimensions, getJpegDimensions, getPngDimensions, getTerminalColorMode, getWebpDimensions, hyperlink, imageFallback, KITTY_PLACEHOLDER_MAX, outerKittyGraphicsMode, renderImage, resetCapabilitiesCache, setCapabilities, setCapabilityOverrides, setCellDimensions, wrapTmuxPassthrough, } from "./terminal-image.js";
 export { sanitizeTerminalLabel, shortenImagePath } from "./terminal-text.js";
-export { Container, CURSOR_MARKER, compositeTuiLine, isFocusable, isViewportTUI, TUI, } from "./tui.js";
+export { CompositeRevision, Container, CURSOR_MARKER, claimFrameRow, compositeTuiLine, currentRenderRevision, dispatchMouseEvent, frameMode, frameScrollbackRows, isFocusable, isViewportTUI, joinLineArrays, mainScreenHistoryLines, nextRenderRevision, renderAtFrameRow, resetMainScreenHistoryLines, TUI, } from "./tui.js";
 export { TuiAltScreen } from "./tui-alt-screen.js";
 export { TuiMainScreen } from "./tui-main-screen.js";
 // Utilities

package/dist/slash-command-autocomplete.js

@@ -38,6 +38,8 @@ export function getSlashCommandSuggestions(commands, prefix) {
             return [];
         }
         const hint = "argumentHint" in cmd && cmd.argumentHint ? cmd.argumentHint : undefined;
+        // A hint without an explicit `requiresArguments` means the command expects input.
+        const requiresArguments = ("requiresArguments" in cmd ? cmd.requiresArguments : undefined) ?? hint !== undefined;
         const desc = cmd.description ?? "";
         const fullDesc = hint ? (desc ? `${hint} — ${desc}` : hint) : desc;
         return [
@@ -46,7 +48,7 @@ export function getSlashCommandSuggestions(commands, prefix) {
                 label: name,
                 description: fullDesc || undefined,
                 searchText: isSkill && !explicitSkillNamespace ? skillName : name,
-                awaitsArguments: hint !== undefined,
+                awaitsArguments: requiresArguments || ("awaitsArguments" in cmd && cmd.awaitsArguments === true),
             },
         ];
     });

package/dist/terminal.d.ts

@@ -23,6 +23,7 @@ export declare function isAppleTerminalSession(): boolean;
 export declare function refreshTerminalDimensions(): void;
 export declare function normalizeNativeShiftEnterInput(data: string, shouldDetectNativeShiftEnter: boolean, isShiftPressed: boolean): string;
 export declare function normalizeAppleTerminalInput(data: string, isAppleTerminal: boolean, isShiftPressed: boolean): string;
+export declare function isWarpWslSession(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, socketExists?: (socketPath: string) => boolean): boolean;
 export declare function normalizeWarpWslShiftEnterInput(data: string, env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, socketExists?: (socketPath: string) => boolean): string;
 export declare function keyboardEnhancementEnabled(): boolean;
 export declare function __stdinErrorSubscriberCountForTests(): number;

package/dist/terminal.js

@@ -77,7 +77,7 @@ export function normalizeNativeShiftEnterInput(data, shouldDetectNativeShiftEnte
 export function normalizeAppleTerminalInput(data, isAppleTerminal, isShiftPressed) {
     return normalizeNativeShiftEnterInput(data, isAppleTerminal, isShiftPressed);
 }
-export function normalizeWarpWslShiftEnterInput(data, env = process.env, platform = process.platform, socketExists = (socketPath) => {
+export function isWarpWslSession(env = process.env, platform = process.platform, socketExists = (socketPath) => {
     try {
         return fs.statSync(socketPath).isSocket();
     }
@@ -85,15 +85,18 @@ export function normalizeWarpWslShiftEnterInput(data, env = process.env, platfor
         return false;
     }
 }) {
-    if (data !== "\n" || platform !== "linux")
-        return data;
+    if (platform !== "linux")
+        return false;
     if (isMultiplexerSession(env) || env.SSH_CONNECTION?.trim() || env.SSH_CLIENT?.trim() || env.SSH_TTY?.trim()) {
-        return data;
+        return false;
     }
     const isWarp = Boolean(env.WARP_SESSION_ID?.trim() || env.WARP_TERMINAL_SESSION_UUID?.trim());
     const interopPath = env.WSL_INTEROP?.trim();
     const isWsl = isWarp && interopPath !== undefined && /^\/run\/WSL\/\d+_interop$/.test(interopPath) && socketExists(interopPath);
-    return isWarp && isWsl ? NATIVE_SHIFT_ENTER_SEQUENCE : data;
+    return isWarp && isWsl;
+}
+export function normalizeWarpWslShiftEnterInput(data, env = process.env, platform = process.platform, socketExists) {
+    return data === "\n" && isWarpWslSession(env, platform, socketExists) ? NATIVE_SHIFT_ENTER_SEQUENCE : data;
 }
 export function keyboardEnhancementEnabled() {
     const value = process.env.PI_TUI_KEYBOARD_PROTOCOL;

package/dist/tui-alt-screen.d.ts

@@ -90,6 +90,8 @@ export declare class TuiAltScreen extends TuiBase implements ViewportTUI {
     hasActiveSelection(): boolean;
     /** Copy the active fullscreen text selection, if any, using the configured selection clipboard path. */
     copyActiveSelectionToClipboard(): Promise<boolean>;
+    /** The lines of the last rendered frame, one per terminal row, as written to the terminal. */
+    getScreenLines(): string[];
     setLayoutRoot(component: Component | undefined): void;
     render(width: number): string[];
     protected getMountedRoots(): readonly Component[];

package/dist/tui-alt-screen.js

@@ -102,6 +102,10 @@ export class TuiAltScreen extends TuiBase {
             return false;
         return this.copyTextToClipboard(text);
     }
+    /** The lines of the last rendered frame, one per terminal row, as written to the terminal. */
+    getScreenLines() {
+        return [...this.previousScreen];
+    }
     setLayoutRoot(component) {
         if (this.layoutRoot === component)
             return;

package/dist/tui-main-screen.d.ts

@@ -13,14 +13,17 @@ export declare class TuiMainScreen extends TuiBase {
     readonly mode: "regular";
     private trackingEnabled;
     private readonly clicks;
+    /**
+     * A press stays clickable only while the committed frame and component tree it hit are unchanged.
+     * Both are captured at press time and compared at release, so ordinary frames pay nothing for it.
+     */
     private mousePress?;
-    private layoutRevision;
-    private committedMouseLines;
-    private committedMouseComponents;
     constructor(...args: ConstructorParameters<typeof TuiBase>);
     protected applyMouseTracking(enabled: boolean): void;
     protected beforeTerminalStop(): void;
     protected doRender(): void;
+    private collectMouseComponents;
+    private pressLayoutUnchanged;
     private applyMouseResult;
     private handleMouseInput;
     captureRenderState(): TuiMainScreenRenderState;

package/dist/tui-main-screen.js

@@ -8,9 +8,6 @@ export class TuiMainScreen extends TuiBase {
         this.mode = "regular";
         this.trackingEnabled = false;
         this.clicks = new MouseClickSynthesizer();
-        this.layoutRevision = 0;
-        this.committedMouseLines = [];
-        this.committedMouseComponents = [];
         this.addInputListener((data) => this.handleMouseInput(data));
     }
     applyMouseTracking(enabled) {
@@ -51,6 +48,9 @@ export class TuiMainScreen extends TuiBase {
         }
         super.doRender();
         this.noteCommittedMouseFrame();
+        this.calibrateMouseAnchor();
+    }
+    collectMouseComponents() {
         const components = [];
         const visit = (component) => {
             components.push(component);
@@ -60,15 +60,20 @@ export class TuiMainScreen extends TuiBase {
         };
         for (const root of this.getMouseLayoutRoots())
             visit(root);
-        if (this.previousLines.length !== this.committedMouseLines.length ||
-            this.previousLines.some((line, index) => line !== this.committedMouseLines[index]) ||
-            components.length !== this.committedMouseComponents.length ||
-            components.some((component, index) => component !== this.committedMouseComponents[index])) {
-            this.layoutRevision++;
+        return components;
+    }
+    pressLayoutUnchanged(press) {
+        const lines = this.previousLines;
+        if (press.frame !== lines) {
+            if (press.frame.length !== lines.length)
+                return false;
+            for (let index = 0; index < lines.length; index++)
+                if (press.frame[index] !== lines[index])
+                    return false;
         }
-        this.committedMouseLines = [...this.previousLines];
-        this.committedMouseComponents = components;
-        this.calibrateMouseAnchor();
+        const components = this.collectMouseComponents();
+        return (components.length === press.components.length &&
+            components.every((component, index) => component === press.components[index]));
     }
     applyMouseResult(result) {
         if (!result?.focus)
@@ -105,7 +110,8 @@ export class TuiMainScreen extends TuiBase {
                 this.mousePress = {
                     target: result.target,
                     epoch: this.placementEpoch,
-                    revision: this.layoutRevision,
+                    frame: this.previousLines,
+                    components: this.collectMouseComponents(),
                     x: raw.x,
                     y: raw.y,
                 };
@@ -120,7 +126,7 @@ export class TuiMainScreen extends TuiBase {
             this.mousePress = undefined;
             if (!press ||
                 press.epoch !== this.placementEpoch ||
-                press.revision !== this.layoutRevision ||
+                !this.pressLayoutUnchanged(press) ||
                 press.x !== raw.x ||
                 press.y !== raw.y) {
                 this.clicks.cancel();

package/dist/tui.d.ts

@@ -86,6 +86,15 @@ export interface Component {
      * Called when theme changes or when component needs to re-render from scratch.
      */
     invalidate(): void;
+    /**
+     * Optional render revision for containers that cache child output.
+     *
+     * A number promises that `render(width)` returns the same lines for the same width, terminal
+     * capabilities and theme until the number changes; the component must change it whenever its
+     * state changes (including in `invalidate()`). `undefined` means the output may change at any
+     * time (streaming, animation, unknown dependencies), so the component is rendered every frame.
+     */
+    getRenderRevision?(): number | undefined;
     dispose?(): void;
 }
 export type TuiInputListenerResult = {
@@ -217,12 +226,55 @@ type TuiConstructorOptions = {
     showHardwareCursor?: boolean;
     muxDetector?: () => boolean;
 };
+/** Mode of the renderer drawing the current frame, or `undefined` outside a frame. */
+export declare function frameMode(): TuiMode | undefined;
 /**
- * Container - a component that contains other components
+ * Lines of transcript history a main-screen frame keeps above the live area: the terminal's own
+ * scrollback size where it can be read (tmux `history-limit`, or `PI_TUI_HISTORY_LINES`), else
+ * 2,000; never less than two screens, never more than 5,000 so a resume or repaint stays instant.
  */
+export declare function mainScreenHistoryLines(rows?: number): number;
+/** Forget the measured terminal scrollback size, e.g. after the environment changed in a test. */
+export declare function resetMainScreenHistoryLines(): void;
+/**
+ * Rows at the top of the last committed frame that now live in the terminal's native scrollback
+ * (main-screen renderer, same terminal size). Changing any of them forces a full scrollback replay.
+ * 0 outside such a frame.
+ */
+export declare function frameScrollbackRows(): number;
+/**
+ * The absolute frame row where `component` starts, when its parent rendered it through
+ * {@link renderAtFrameRow}; `undefined` when the position is unknown (any other parent).
+ */
+export declare function claimFrameRow(component: Component): number | undefined;
+/** Render `child` as starting at absolute frame row `row`, so it can {@link claimFrameRow} it. */
+export declare function renderAtFrameRow(child: Component, width: number, row: number | undefined): string[];
+/**
+ * Draw a new value from the process-wide render revision clock. Every revisioned state change uses
+ * one, so "the clock has not moved" proves no revisioned component changed and caches may skip
+ * re-reading their children's revisions.
+ */
+export declare function nextRenderRevision(): number;
+/** Current value of the render revision clock (see {@link nextRenderRevision}). */
+export declare function currentRenderRevision(): number;
+/**
+ * Render revision of a component whose output is a pure function of its own state and its children's
+ * output. `bump()` records an own-state change; `read(children)` returns a revision that also changes
+ * whenever a child is replaced or a child's revision changes, and `undefined` while any child is live.
+ * Child revisions are re-read only after the clock moved, so an unchanged subtree costs one identity pass.
+ */
+export declare class CompositeRevision {
+    private revision;
+    private children;
+    private childRevisions;
+    private checkedAt;
+    bump(): void;
+    read(children: readonly Component[]): number | undefined;
+}
 export declare class Container implements Component {
     children: Component[];
     private disposed;
+    private readonly composite;
     private mouseLayout?;
     addChild(component: Component): void;
     removeChild(component: Component): void;
@@ -231,9 +283,25 @@ export declare class Container implements Component {
     detachAll(): void;
     dispose(): void;
     invalidate(): void;
+    /**
+     * A plain `Container` only concatenates its children, so its output changes exactly when a child
+     * changes. Subclasses may render more than their children and therefore opt in explicitly by
+     * overriding this (usually via {@link childRenderRevision}); an inherited revision would let a
+     * cache keep their stale output.
+     */
+    getRenderRevision(): number | undefined;
+    /** Revision of this container's children, for subclasses whose output depends only on them and `bump()`ed state. */
+    protected childRenderRevision(): number | undefined;
+    /** Record an own-state change for {@link childRenderRevision}. */
+    protected bumpRenderRevision(): void;
     handleMouse(event: TuiMouseEvent): TuiMouseDispatchResult | undefined;
     render(width: number): string[];
 }
+/**
+ * Concatenate rendered line arrays into one new array. Native `concat` copies whole arrays at once,
+ * which keeps a frame over a long transcript from paying a per-line iterator and push.
+ */
+export declare function joinLineArrays(chunks: readonly (readonly string[])[]): string[];
 /** Composite overlay content into a terminal line at a fixed column. */
 export declare function compositeTuiLine(baseLine: string, overlayLine: string, startCol: number, overlayWidth: number, totalWidth: number): string;
 export type TuiMode = "regular" | "fullscreen";
@@ -260,6 +328,9 @@ export declare abstract class TuiBase extends Container {
     terminal: Terminal;
     protected previousLines: string[];
     private previousRawLines;
+    private previousImageScan;
+    /** Image presence the normalization pass already measured for the array it produced. */
+    private normalizedImageHint;
     private normalizeMemo;
     protected previousKittyImageIds: Set<number>;
     protected previousWidth: number;
@@ -419,6 +490,7 @@ export declare abstract class TuiBase extends Container {
     /** Composite all overlays into content lines (sorted by focusOrder, higher = on top). */
     protected compositeOverlays(lines: string[], termWidth: number, termHeight: number): string[];
     private static readonly SEGMENT_RESET;
+    private static readonly NORMALIZE_MEMO_MIN;
     /**
      * Every frame write is bracketed by synchronized output (DECSET 2026) and
      * disables autowrap (DECAWM, DECRST 7) while rows are painted. Differential
@@ -433,10 +505,21 @@ export declare abstract class TuiBase extends Container {
     private static readonly FRAME_BEGIN;
     private static readonly FRAME_END;
     private setPreviousLines;
+    /** Image presence of the committed frame, measured once per frame array instead of once per check. */
+    protected previousLinesHaveImage(): boolean;
+    /** Record image presence for a produced array; `undefined` leaves it to a scan when it is committed. */
+    private hintNormalizedImages;
     private normalizeLine;
     protected applyLineResets(lines: string[]): string[];
     private applyLineResetResult;
     private applyViewportLineResets;
+    /**
+     * A frame whose line count changed (an append, a growing editor, a removed row) keeps every
+     * leading line that is unchanged since the last frame. Normalization is a pure function of the
+     * raw line, so the previous normalized prefix is reused and only the changed tail is normalized;
+     * the diff then starts where the raw lines first differ.
+     */
+    private applyResizedLineResets;
     private collectKittyImageIds;
     private deleteKittyImages;
     private getKittyImageReservedRows;

package/dist/tui.js

@@ -1,6 +1,7 @@
 /**
  * Minimal TUI implementation with differential rendering
  */
+import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -274,18 +275,179 @@ function parseSizeValue(value, referenceSize) {
 /**
  * Container - a component that contains other components
  */
+/**
+ * Facts about the frame being rendered, published by the main-screen renderer for containers that
+ * can skip work for rows the terminal cannot repaint cheaply.
+ */
+const renderFrame = {
+    scrollbackRows: 0,
+    offset: 0,
+    next: undefined,
+    mode: undefined,
+    rows: 0,
+};
+/** Mode of the renderer drawing the current frame, or `undefined` outside a frame. */
+export function frameMode() {
+    return renderFrame.mode;
+}
+const DEFAULT_HISTORY_LINES = 2000;
+/** Writing this many lines into a terminal takes ~0.2 s, the most a resume or repaint may spend on history. */
+const MAX_HISTORY_LINES = 5000;
+let terminalScrollbackLines;
+/** Bumped by {@link resetMainScreenHistoryLines}, so a tmux answer for an older environment is dropped. */
+let scrollbackLookupGeneration = 0;
+/**
+ * The override is read at once; tmux is asked in the background (a process run inside the first
+ * render would hold input and painting while tmux answers), and the default applies until it does.
+ */
+function readTerminalScrollbackLines() {
+    const override = Number(process.env.PI_TUI_HISTORY_LINES);
+    if (Number.isFinite(override) && override > 0)
+        return Math.floor(override);
+    if (!process.env.TMUX)
+        return null;
+    const generation = scrollbackLookupGeneration;
+    try {
+        execFile("tmux", ["display-message", "-p", "#{history_limit}"], { encoding: "utf8", timeout: 500 }, (error, stdout) => {
+            if (generation !== scrollbackLookupGeneration)
+                return;
+            const limit = Number(stdout.trim());
+            if (!error && Number.isFinite(limit) && limit > 0)
+                terminalScrollbackLines = limit;
+        });
+    }
+    catch {
+        // tmux is not runnable: keep the default.
+    }
+    return null;
+}
+/**
+ * Lines of transcript history a main-screen frame keeps above the live area: the terminal's own
+ * scrollback size where it can be read (tmux `history-limit`, or `PI_TUI_HISTORY_LINES`), else
+ * 2,000; never less than two screens, never more than 5,000 so a resume or repaint stays instant.
+ */
+export function mainScreenHistoryLines(rows = renderFrame.rows) {
+    if (terminalScrollbackLines === undefined)
+        terminalScrollbackLines = readTerminalScrollbackLines();
+    const preferred = Math.min(MAX_HISTORY_LINES, terminalScrollbackLines ?? DEFAULT_HISTORY_LINES);
+    return Math.min(MAX_HISTORY_LINES, Math.max(2 * Math.max(1, rows), preferred));
+}
+/** Forget the measured terminal scrollback size, e.g. after the environment changed in a test. */
+export function resetMainScreenHistoryLines() {
+    terminalScrollbackLines = undefined;
+    scrollbackLookupGeneration += 1;
+}
+/**
+ * Rows at the top of the last committed frame that now live in the terminal's native scrollback
+ * (main-screen renderer, same terminal size). Changing any of them forces a full scrollback replay.
+ * 0 outside such a frame.
+ */
+export function frameScrollbackRows() {
+    return renderFrame.scrollbackRows;
+}
+/**
+ * The absolute frame row where `component` starts, when its parent rendered it through
+ * {@link renderAtFrameRow}; `undefined` when the position is unknown (any other parent).
+ */
+export function claimFrameRow(component) {
+    if (renderFrame.next !== component)
+        return undefined;
+    renderFrame.next = undefined;
+    return renderFrame.offset;
+}
+/** Render `child` as starting at absolute frame row `row`, so it can {@link claimFrameRow} it. */
+export function renderAtFrameRow(child, width, row) {
+    if (row === undefined)
+        return child.render(width);
+    const previousOffset = renderFrame.offset;
+    const previousNext = renderFrame.next;
+    renderFrame.offset = row;
+    renderFrame.next = child;
+    try {
+        return child.render(width);
+    }
+    finally {
+        renderFrame.offset = previousOffset;
+        renderFrame.next = previousNext;
+    }
+}
+let renderRevisionClock = 0;
+/**
+ * Draw a new value from the process-wide render revision clock. Every revisioned state change uses
+ * one, so "the clock has not moved" proves no revisioned component changed and caches may skip
+ * re-reading their children's revisions.
+ */
+export function nextRenderRevision() {
+    renderRevisionClock += 1;
+    return renderRevisionClock;
+}
+/** Current value of the render revision clock (see {@link nextRenderRevision}). */
+export function currentRenderRevision() {
+    return renderRevisionClock;
+}
+/**
+ * Render revision of a component whose output is a pure function of its own state and its children's
+ * output. `bump()` records an own-state change; `read(children)` returns a revision that also changes
+ * whenever a child is replaced or a child's revision changes, and `undefined` while any child is live.
+ * Child revisions are re-read only after the clock moved, so an unchanged subtree costs one identity pass.
+ */
+export class CompositeRevision {
+    constructor() {
+        this.revision = nextRenderRevision();
+        this.children = [];
+        this.childRevisions = [];
+        this.checkedAt = -1;
+    }
+    bump() {
+        this.revision = nextRenderRevision();
+    }
+    read(children) {
+        let replaced = children.length !== this.children.length;
+        for (let index = 0; !replaced && index < children.length; index++) {
+            if (children[index] !== this.children[index])
+                replaced = true;
+        }
+        if (!replaced && this.checkedAt === renderRevisionClock)
+            return this.revision;
+        const revisions = [];
+        for (const child of children) {
+            const revision = child.getRenderRevision?.();
+            if (revision === undefined) {
+                // Unrevisioned: nothing to compare against next time, and removed children must not stay referenced.
+                this.children = [];
+                this.childRevisions = [];
+                this.checkedAt = -1;
+                return undefined;
+            }
+            revisions.push(revision);
+        }
+        const changed = replaced || revisions.some((revision, index) => revision !== this.childRevisions[index]);
+        if (changed) {
+            this.revision = nextRenderRevision();
+            this.children = [...children];
+        }
+        this.childRevisions = revisions;
+        this.checkedAt = renderRevisionClock;
+        return this.revision;
+    }
+}
 export class Container {
     constructor() {
         this.children = [];
         this.disposed = false;
+        this.composite = new CompositeRevision();
     }
+    // Every structural change moves the render revision clock, so a cache that saw the clock stand
+    // still may trust that no revisioned subtree gained, lost or swapped a child.
     addChild(component) {
         this.children.push(component);
+        this.composite.bump();
     }
     removeChild(component) {
         const index = this.children.indexOf(component);
         if (index !== -1) {
             this.children.splice(index, 1);
+            this.composite.bump();
             component.dispose?.();
         }
     }
@@ -293,6 +455,7 @@ export class Container {
         const index = this.children.indexOf(component);
         if (index !== -1) {
             this.children.splice(index, 1);
+            this.composite.bump();
         }
     }
     clear() {
@@ -300,9 +463,11 @@ export class Container {
             child.dispose?.();
         }
         this.children = [];
+        this.composite.bump();
     }
     detachAll() {
         this.children = [];
+        this.composite.bump();
     }
     dispose() {
         if (this.disposed)
@@ -313,10 +478,28 @@ export class Container {
         }
     }
     invalidate() {
+        this.composite.bump();
         for (const child of this.children) {
             child.invalidate?.();
         }
     }
+    /**
+     * A plain `Container` only concatenates its children, so its output changes exactly when a child
+     * changes. Subclasses may render more than their children and therefore opt in explicitly by
+     * overriding this (usually via {@link childRenderRevision}); an inherited revision would let a
+     * cache keep their stale output.
+     */
+    getRenderRevision() {
+        return Object.getPrototypeOf(this) === Container.prototype ? this.childRenderRevision() : undefined;
+    }
+    /** Revision of this container's children, for subclasses whose output depends only on them and `bump()`ed state. */
+    childRenderRevision() {
+        return this.composite.read(this.children);
+    }
+    /** Record an own-state change for {@link childRenderRevision}. */
+    bumpRenderRevision() {
+        this.composite.bump();
+    }
     handleMouse(event) {
         if (event.y < 0 || event.y >= event.height)
             return undefined;
@@ -340,12 +523,13 @@ export class Container {
         return undefined;
     }
     render(width) {
-        const lines = [];
+        const chunks = [];
         const mouseChildren = [];
+        let row = claimFrameRow(this);
         for (const child of this.children) {
             let childLines;
             try {
-                childLines = child.render(width);
+                childLines = renderAtFrameRow(child, width, row);
             }
             catch (error) {
                 logRenderErrorOnce(child, error);
@@ -354,14 +538,28 @@ export class Container {
                 childLines = [`[render error: ${componentName}]`];
             }
             mouseChildren.push({ component: child, height: childLines.length });
-            for (const line of childLines) {
-                lines.push(line);
-            }
+            chunks.push(childLines);
+            if (row !== undefined)
+                row += childLines.length;
         }
         this.mouseLayout = { width, children: mouseChildren };
-        return lines;
+        return joinLineArrays(chunks);
     }
 }
+const JOIN_BATCH = 1024;
+/**
+ * Concatenate rendered line arrays into one new array. Native `concat` copies whole arrays at once,
+ * which keeps a frame over a long transcript from paying a per-line iterator and push.
+ */
+export function joinLineArrays(chunks) {
+    if (chunks.length <= JOIN_BATCH)
+        return [].concat(...chunks);
+    const batches = [];
+    for (let start = 0; start < chunks.length; start += JOIN_BATCH) {
+        batches.push([].concat(...chunks.slice(start, start + JOIN_BATCH)));
+    }
+    return [].concat(...batches);
+}
 /**
  * TUI - Main class for managing terminal UI with differential rendering
  */
@@ -528,7 +726,7 @@ export class TuiBase extends Container {
         if (this.mouseCommittedLineCount !== this.previousLines.length)
             this.placementEpoch++;
         this.mouseCommittedLineCount = this.previousLines.length;
-        if (this.previousLines.some(isImageLine)) {
+        if (this.previousLinesHaveImage()) {
             this.placementEpoch++;
             this.anchor.kind = "unknown";
             return;
@@ -560,7 +758,7 @@ export class TuiBase extends Container {
             this.mouseExternalWritePending ||
             !this.terminal.queryCursorPosition ||
             this.previousLines.length === 0 ||
-            this.previousLines.some(isImageLine))
+            this.previousLinesHaveImage())
             return;
         if (this.anchor.kind !== "unknown" &&
             this.anchor.epoch === this.placementEpoch &&
@@ -1542,6 +1740,7 @@ export class TuiBase extends Container {
         return result;
     }
     static { this.SEGMENT_RESET = "\x1b[0m\x1b]8;;\x07"; }
+    static { this.NORMALIZE_MEMO_MIN = 4096; }
     /**
      * Every frame write is bracketed by synchronized output (DECSET 2026) and
      * disables autowrap (DECAWM, DECRST 7) while rows are painted. Differential
@@ -1559,6 +1758,19 @@ export class TuiBase extends Container {
         this.previousLines = lines;
         this.previousRawLines = rawLines;
     }
+    /** Image presence of the committed frame, measured once per frame array instead of once per check. */
+    previousLinesHaveImage() {
+        const lines = this.previousLines;
+        if (this.previousImageScan?.lines !== lines) {
+            const hint = this.normalizedImageHint?.lines === lines ? this.normalizedImageHint.hasImage : undefined;
+            this.previousImageScan = { lines, hasImage: hint ?? lines.some(isImageLine) };
+        }
+        return this.previousImageScan.hasImage;
+    }
+    /** Record image presence for a produced array; `undefined` leaves it to a scan when it is committed. */
+    hintNormalizedImages(lines, hasImage) {
+        this.normalizedImageHint = hasImage === undefined ? undefined : { lines, hasImage };
+    }
     normalizeLine(line) {
         if (isImageLine(line)) {
             return { line, normalized: false };
@@ -1568,6 +1780,16 @@ export class TuiBase extends Container {
             return { line: cached, normalized: false };
         }
         const normalized = normalizeTerminalOutput(line) + TUI.SEGMENT_RESET;
+        // The windowed path only ever adds: a long run of distinct lines (spinners, streamed text)
+        // grew the memo without bound. Past a bound the oldest half goes; full passes rebuild it.
+        if (this.normalizeMemo.size >= Math.max(TUI.NORMALIZE_MEMO_MIN, this.previousRawLines.length * 2)) {
+            let drop = this.normalizeMemo.size >> 1;
+            for (const key of this.normalizeMemo.keys()) {
+                if (drop-- <= 0)
+                    break;
+                this.normalizeMemo.delete(key);
+            }
+        }
         this.normalizeMemo.set(line, normalized);
         return { line: normalized, normalized: true };
     }
@@ -1579,9 +1801,11 @@ export class TuiBase extends Container {
         const nextMemo = new Map();
         const normalizedLines = [];
         let normalizedCount = 0;
+        let hasImage = false;
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
             if (isImageLine(line)) {
+                hasImage = true;
                 normalizedLines.push(line);
                 continue;
             }
@@ -1594,6 +1818,7 @@ export class TuiBase extends Container {
             normalizedLines.push(normalized);
         }
         this.normalizeMemo = nextMemo;
+        this.hintNormalizedImages(normalizedLines, hasImage);
         recordViewportRenderStats(normalizedCount, mode);
         return {
             lines: normalizedLines,
@@ -1606,10 +1831,12 @@ export class TuiBase extends Container {
         if (!viewportRenderEnabled() ||
             !stableDimensions ||
             this.previousLines.length === 0 ||
-            this.previousLines.length !== rawLines.length ||
-            this.previousRawLines.length !== rawLines.length) {
+            this.previousRawLines.length !== this.previousLines.length) {
             return this.applyLineResetResult(rawLines);
         }
+        if (this.previousRawLines.length !== rawLines.length) {
+            return this.applyResizedLineResets(rawLines);
+        }
         const windowStart = Math.max(0, viewportTop - VIEWPORT_RENDER_OVERSCAN);
         const windowEnd = Math.min(rawLines.length, viewportTop + height + VIEWPORT_RENDER_OVERSCAN);
         let firstRawChanged = -1;
@@ -1624,20 +1851,27 @@ export class TuiBase extends Container {
                 return this.applyLineResetResult(rawLines, "escaped");
             }
         }
+        const previousHadImage = this.previousLinesHaveImage();
         const lines = this.previousLines.slice();
         let normalizedCount = 0;
+        let changedImage = false;
         if (firstRawChanged !== -1) {
             for (let i = windowStart; i < windowEnd; i++) {
                 if (rawLines[i] === this.previousRawLines[i]) {
                     continue;
                 }
-                const normalized = this.normalizeLine(rawLines[i] ?? "");
+                const raw = rawLines[i] ?? "";
+                if (isImageLine(raw))
+                    changedImage = true;
+                const normalized = this.normalizeLine(raw);
                 lines[i] = normalized.line;
                 if (normalized.normalized) {
                     normalizedCount += 1;
                 }
             }
         }
+        // A frame that had an image may have replaced it; only an image-free frame can be updated in place.
+        this.hintNormalizedImages(lines, previousHadImage ? undefined : changedImage);
         recordViewportRenderStats(normalizedCount, "bounded");
         return {
             lines,
@@ -1646,6 +1880,46 @@ export class TuiBase extends Container {
             bounded: true,
         };
     }
+    /**
+     * A frame whose line count changed (an append, a growing editor, a removed row) keeps every
+     * leading line that is unchanged since the last frame. Normalization is a pure function of the
+     * raw line, so the previous normalized prefix is reused and only the changed tail is normalized;
+     * the diff then starts where the raw lines first differ.
+     */
+    applyResizedLineResets(rawLines) {
+        const previousRaw = this.previousRawLines;
+        const sharedLength = Math.min(rawLines.length, previousRaw.length);
+        let firstRawChanged = 0;
+        while (firstRawChanged < sharedLength && rawLines[firstRawChanged] === previousRaw[firstRawChanged]) {
+            firstRawChanged++;
+        }
+        const previousHadImage = this.previousLinesHaveImage();
+        const lines = this.previousLines.slice(0, firstRawChanged);
+        let normalizedCount = 0;
+        let tailImage = false;
+        for (let i = firstRawChanged; i < rawLines.length; i++) {
+            const line = rawLines[i] ?? "";
+            if (isImageLine(line)) {
+                tailImage = true;
+                lines.push(line);
+                continue;
+            }
+            let normalized = this.normalizeMemo.get(line);
+            if (normalized === undefined) {
+                normalized = normalizeTerminalOutput(line) + TUI.SEGMENT_RESET;
+                normalizedCount += 1;
+            }
+            lines.push(normalized);
+        }
+        this.hintNormalizedImages(lines, previousHadImage ? undefined : tailImage);
+        recordViewportRenderStats(normalizedCount, "bounded");
+        return {
+            lines,
+            firstRawChanged,
+            compareEndExclusive: Math.max(rawLines.length, this.previousLines.length),
+            bounded: true,
+        };
+    }
     collectKittyImageIds(lines) {
         recordKittyImageScanStats(lines.length);
         const ids = new Set();
@@ -1960,8 +2234,22 @@ export class TuiBase extends Container {
             const targetScreenRow = targetRow - viewportTop;
             return targetScreenRow - currentScreenRow;
         };
-        // Render all components to get new lines
-        let newLines = this.render(width);
+        // Render all components to get new lines. The main screen tells containers which rows of the
+        // last frame are in native scrollback, so live content there can stay as the terminal shows it.
+        renderFrame.scrollbackRows =
+            this.mode === "regular" && !widthChanged && !heightChanged && this.previousLines.length > 0
+                ? prevViewportTop
+                : 0;
+        renderFrame.mode = this.mode;
+        renderFrame.rows = height;
+        let newLines;
+        try {
+            newLines = renderAtFrameRow(this, width, 0);
+        }
+        finally {
+            renderFrame.scrollbackRows = 0;
+            renderFrame.mode = undefined;
+        }
         // Composite overlays into the rendered lines (before differential compare)
         if (this.overlayStack.length > 0) {
             newLines = this.compositeOverlays(newLines, width, height);

package/dist/utils.d.ts

@@ -54,6 +54,12 @@ export declare function getActiveBackgroundAnsi(text: string): string;
  * @param width - Maximum visible width per line
  * @returns Array of wrapped lines (NOT padded to width)
  */
+/**
+ * Flatten cached lines. V8 keeps a string built by concatenation as a tree of its parts until something reads it
+ * whole, and a cached line kept as such a tree retains several times its own size. Converting a string to a number
+ * reads it whole, so V8 flattens it in place; the strings' values do not change.
+ */
+export declare function flattenLines(lines: readonly string[]): void;
 export declare function wrapTextWithAnsi(text: string, width: number): string[];
 export declare const PUNCTUATION_REGEX: RegExp;
 /**

package/dist/utils.js

@@ -872,6 +872,15 @@ function splitIntoTokensWithAnsi(text) {
  * @param width - Maximum visible width per line
  * @returns Array of wrapped lines (NOT padded to width)
  */
+/**
+ * Flatten cached lines. V8 keeps a string built by concatenation as a tree of its parts until something reads it
+ * whole, and a cached line kept as such a tree retains several times its own size. Converting a string to a number
+ * reads it whole, so V8 flattens it in place; the strings' values do not change.
+ */
+export function flattenLines(lines) {
+    for (const line of lines)
+        Number(line);
+}
 export function wrapTextWithAnsi(text, width) {
     if (!text) {
         return [""];
@@ -1260,8 +1269,11 @@ export function sliceWithWidth(line, startCol, length, strict = false) {
     while (i < line.length) {
         const ansi = extractAnsiCode(line, i);
         if (ansi) {
-            if (currentCol >= startCol && currentCol < endCol)
-                result += ansi.code;
+            if (currentCol >= startCol && currentCol < endCol) {
+                // Keep original order: codes from before the range must precede codes at the boundary
+                result += pendingAnsi + ansi.code;
+                pendingAnsi = "";
+            }
             else if (currentCol < startCol)
                 pendingAnsi += ansi.code;
             i += ansi.length;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi-tui",
-	"version": "2026.10.1",
+	"version": "2026.10.3",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",