@prometheus-ai/tui 0.5.3 → 0.5.8

package/src/tui.ts

@@ -1,29 +1,30 @@
 /**
  * Minimal TUI implementation with differential rendering.
  *
- * Before changing the render planner, native-scrollback bookkeeping, capability
- * detection, or width math, read `docs/tui-core-renderer.md`: it documents the
- * failure modes (yank / corruption / flash / width crashes) and the invariants
- * this engine must not violate. The short version: the renderer cannot observe
- * the terminal's scroll position on most hosts, so ED3 (`CSI 3 J`) is confined
- * to the destructive `clearScrollback` path, an unobservable viewport probe is
- * never trusted for passive streaming, and the hot path clamps over-wide lines
- * instead of throwing.
+ * Append-only render contract: rows committed to native scrollback are
+ * immutable. All mutation is confined to the visible window; rows enter
+ * history exactly once, in order, when the component-reported commit boundary
+ * (`NativeScrollbackLiveRegion`) says they are final. ED3 (`CSI 3 J`) is
+ * emitted only for gesture-driven replays (session replace, resize,
+ * resetDisplay) where snapping the viewport is acceptable. The engine never
+ * probes or guesses the terminal's scroll position, and the hot path clamps
+ * over-wide lines instead of throwing. See `docs/tui-core-renderer.md`.
  */
 import * as fs from "node:fs";
-import * as path from "node:path";
 import { performance } from "node:perf_hooks";
 import { $flag, getDebugLogPath } from "@prometheus-ai/utils";
 import { DEFAULT_MAX_INLINE_IMAGES, ImageBudget } from "./components/image";
 import { planDeccaraFills } from "./deccara";
 import { isKeyRelease, matchesKey } from "./keys";
-import type { Terminal } from "./terminal";
+import { LoopWatchdog } from "./loop-watchdog";
+import { isConPTYHosted, setAltScreenActive, type Terminal } from "./terminal";
 import {
 	encodeKittyDeleteImage,
 	ImageProtocol,
 	setCellDimensions,
 	setTerminalImageProtocol,
 	shouldEnableSynchronizedOutputByDefault,
+	synchronizedOutputUserOverride,
 	TERMINAL,
 } from "./terminal-capabilities";
 import {
@@ -38,12 +39,20 @@ import {
 
 const SEGMENT_RESET = "\x1b[0m";
 /**
- * Per-line terminator written at the end of every non-image line. Closes both
+ * Per-line terminator written after every non-image content row. It closes both
  * SGR state and any in-flight OSC 8 hyperlink so styles/links cannot bleed
- * across lines in scrollback. Applied by {@link TUI.#applyLineResets} before
- * diffing so `#previousLines` mirrors what was actually written.
+ * across lines in scrollback. Kept out of the diff/width cache because reset
+ * bytes are deterministic write framing, not content.
  */
 const LINE_TERMINATOR = "\x1b[0m\x1b]8;;\x07";
+const ERASE_LINE = "\x1b[2K";
+const ERASE_TO_END_OF_LINE = "\x1b[K";
+// Keep the common short-row path out of native width/truncation. Longer rows
+// are fit by visible cells, not source code units, so zero-width-heavy prefixes
+// cannot hide visible suffix text that still belongs in the viewport.
+const LINE_FIT_MIN_SOURCE_CODE_UNITS = 4096;
+const LINE_FIT_MAX_SOURCE_CODE_UNITS = 65536;
+const LINE_FIT_SOURCE_WIDTH_MULTIPLIER = 64;
 // Hide the hardware cursor before each paint/move write. Ghostty-style bar
 // cursors can otherwise leave visual afterimages while the TUI repaints the
 // row under a visible cursor. Paint writes also disable terminal autowrap:
@@ -65,9 +74,19 @@ const CURSOR_BEGIN = `${HIDE_CURSOR}${SYNC_OUTPUT_BEGIN}`;
 const CURSOR_BEGIN_NO_SYNC = HIDE_CURSOR;
 const CURSOR_END = SYNC_OUTPUT_END;
 const CURSOR_END_NO_SYNC = "";
+// Mouse reporting, enabled only for the lifetime of a fullscreen overlay so the
+// rest of the app keeps the terminal's native text selection. 1000h = button
+// click tracking, 1003h = any-motion tracking so overlays can light up hover
+// targets (the pointer moving with no button held), 1006h = SGR extended
+// coordinates so columns/rows past 223 are reported.
+const MOUSE_TRACKING_ON = "\x1b[?1000h\x1b[?1003h\x1b[?1006h";
+const MOUSE_TRACKING_OFF = "\x1b[?1006l\x1b[?1003l\x1b[?1000l";
+const ALT_SCREEN_ENTER = "\x1b[?1049h";
+const ALT_SCREEN_EXIT = "\x1b[?1049l";
 
 type InputListenerResult = { consume?: boolean; data?: string } | undefined;
 type InputListener = (data: string) => InputListenerResult;
+type StartListener = () => void;
 
 export interface RenderTimer {
 	cancel(): void;
@@ -83,6 +102,11 @@ export interface TUIOptions {
 	renderScheduler?: RenderScheduler;
 }
 
+export interface TUIStartOptions {
+	/** Clear saved native scrollback before the first paint. */
+	clearScrollback?: boolean;
+}
+
 const DEFAULT_RENDER_SCHEDULER: RenderScheduler = {
 	now: () => performance.now(),
 	scheduleImmediate: callback => {
@@ -100,14 +124,26 @@ const DEFAULT_RENDER_SCHEDULER: RenderScheduler = {
 
 /**
  * Component interface - all components must implement this
+ *
+ * Render contract: the returned array (and its rows) belongs to the component.
+ * Callers MUST NOT mutate it — components are allowed to return a cached array
+ * and will return the exact same reference for as long as their rendered
+ * content is unchanged. Conversely, a component MUST return a fresh array
+ * reference whenever its content changed; reference equality across two
+ * render() calls is the engine's proof that the rows are byte-identical
+ * (containers memoize their concatenation on it, and the TUI derives the
+ * frame's stable prefix from it). A component that mutates a previously
+ * returned array in place must implement {@link RenderStablePrefix} to declare
+ * which leading rows survived.
  */
 export interface Component {
 	/**
-	 * Render the component to lines for the given viewport width
-	 * @param width - Current viewport width
-	 * @returns Array of strings, each representing a line
+	 * Render the component to an array of physical rows at the given width.
+	 * The result is component-owned and `readonly` to the caller; an unchanged
+	 * component may (and should) return the same array reference it returned
+	 * last time.
 	 */
-	render(width: number): string[];
+	render(width: number): readonly string[];
 
 	/**
 	 * Optional handler for keyboard input when component has focus
@@ -121,33 +157,68 @@ export interface Component {
 	wantsKeyRelease?: boolean;
 
 	/**
-	 * Invalidate any cached rendering state.
+	 * Optional hook to invalidate any cached rendering state.
 	 * Called when theme changes or when component needs to re-render from scratch.
 	 */
-	invalidate(): void;
+	invalidate?(): void;
+
+	/**
+	 * Optional teardown. Called when the component is permanently removed from
+	 * the live tree (e.g. a transcript reset). Release timers, intervals, and
+	 * subscriptions here. Must be idempotent. Containers propagate dispose to
+	 * their children; leaf components without resources may omit it.
+	 */
+	dispose?(): void;
 }
 
 /**
- * Optional component seam for native-scrollback pinning. A component that
- * renders a stable prefix followed by a live/transient suffix reports the local
- * line index where that suffix begins after each render. TUI treats that suffix
- * — and every root child rendered below it — as not yet safe to commit to native
- * scrollback on ED3-risk terminals whose viewport position is unobservable.
+ * Component seam for append-only native-scrollback commits. A component that
+ * renders a finalized prefix followed by a live/mutating suffix reports the
+ * local line index where that suffix begins after each render. The engine
+ * commits rows to native scrollback only up to that boundary; everything
+ * below repaints in place inside the visible window and never enters history
+ * until it finalizes.
  *
  * `getNativeScrollbackCommitSafeEnd` optionally reports a *deeper* boundary
- * inside that live suffix: the line index up to which the live region is
- * append-only (its earlier rows never re-layout, only new rows append at the
- * bottom — a streaming assistant message). Rows in `[liveRegionStart,
- * commitSafeEnd)` that scroll above the viewport are safe to commit to native
- * scrollback even though they are technically live, because they will never
- * change. Without this, a single live block that alone overflows the viewport
- * loses its scrolled-off head (committed nowhere, repainted nowhere). Volatile
- * live blocks (tool previews that collapse) omit it, so their mutable rows stay
- * deferred. Defaults to `liveRegionStart` when absent.
+ * inside the live suffix: the line index up to which the live region is
+ * append-only (earlier rows never re-layout — a streaming assistant message).
+ * Rows in `[liveRegionStart, commitSafeEnd)` may commit even though they are
+ * technically live, because they will never change. Without it, a single live
+ * block that alone overflows the window would hold its scrolled-off head out
+ * of history until it finalizes. Volatile live blocks (tool previews that
+ * collapse) omit it. Defaults to `liveRegionStart` when absent; a root that
+ * reports no seam at all commits everything that scrolls (shell semantics).
+ * `getNativeScrollbackSnapshotSafeEnd` optionally reports a still deeper
+ * boundary: the line index up to which the live region is *durable* — its rows
+ * may still change bytes later (a streaming markdown table re-aligning its
+ * columns every row), but their CURRENT snapshot is permanent content, so
+ * dropping them when they scroll above the window is forbidden. Unlike
+ * `commitSafeEnd` (byte-stable: offered rows are asserted never to re-layout and
+ * stay under the committed-prefix audit), rows committed under the snapshot end
+ * are audit-EXEMPT once they pass the window top — the engine appends their
+ * scroll-off snapshot and never recommits them, so later layout drift becomes a
+ * frozen stale row in history (duplication never loss) instead of either a
+ * dropped row or an audit re-anchor spray. Provisional live blocks (collapsing
+ * tool/edit previews whose head is a throwaway tail window) omit it. Defaults to
+ * `commitSafeEnd ?? liveRegionStart` when absent.
+ *
+ * When several root children report a seam in the same frame, the topmost
+ * one (and its commit-safe / snapshot-safe extension) defines the boundary:
+ * commits are prefix-only, so everything below the first seam is already
+ * excluded.
  */
 export interface NativeScrollbackLiveRegion {
 	getNativeScrollbackLiveRegionStart(): number | undefined;
 	getNativeScrollbackCommitSafeEnd?(): number | undefined;
+	getNativeScrollbackSnapshotSafeEnd?(): number | undefined;
+}
+
+export interface NativeScrollbackCommittedRows {
+	setNativeScrollbackCommittedRows(rows: number): void;
+}
+
+function setNativeScrollbackCommittedRows(component: Component, rows: number): void {
+	(component as Component & Partial<NativeScrollbackCommittedRows>).setNativeScrollbackCommittedRows?.(rows);
 }
 
 function getNativeScrollbackLiveRegionStart(component: Component): number | undefined {
@@ -158,6 +229,68 @@ function getNativeScrollbackCommitSafeEnd(component: Component): number | undefi
 	return (component as Component & Partial<NativeScrollbackLiveRegion>).getNativeScrollbackCommitSafeEnd?.();
 }
 
+function getNativeScrollbackSnapshotSafeEnd(component: Component): number | undefined {
+	return (component as Component & Partial<NativeScrollbackLiveRegion>).getNativeScrollbackSnapshotSafeEnd?.();
+}
+
+/**
+ * Opt-in stability report for components that mutate their returned render
+ * array in place across frames (instead of returning a fresh array per
+ * change). The engine reads it right after the component's `render()` returns:
+ * the report counts the leading rows of the just-returned array that are
+ * byte-identical to the array state the reader last observed. The engine uses
+ * it to reuse the composed frame's prefix — skipping marker extraction, line
+ * preparation, and the committed-prefix audit for those rows.
+ *
+ * Contract:
+ * - Reading CONSUMES the report: it re-bases the baseline to the current
+ *   array state. The accumulated count therefore covers every render since
+ *   the previous read, so out-of-band `render()` calls between engine frames
+ *   (an exporter walking the tree) can only lower the report, never inflate
+ *   it past what the engine actually has.
+ * - An implementer that cannot prove stability for a frame must lower the
+ *   accumulated count to 0 for that render.
+ * - Rows at or beyond the report may have been mutated in place; rows before
+ *   it must be the identical string values at the identical indices.
+ */
+export interface RenderStablePrefix {
+	getRenderStablePrefixRows(): number;
+}
+
+function getRenderStablePrefixRows(component: Component): number | undefined {
+	return (component as Component & Partial<RenderStablePrefix>).getRenderStablePrefixRows?.();
+}
+
+/**
+ * Opt-in fast path for composing only the visible tail of a tall component
+ * during a terminal resize. A drag emits a SIGWINCH burst, and the width
+ * changes on every event: a full compose re-lays-out (and, for markdown,
+ * re-lexes) the entire transcript per event — O(history) work that is
+ * discarded the instant the next event arrives. While the resize is in flight
+ * the engine paints only the viewport, so it asks each tall root child for at
+ * most `maxRows` rows from the bottom of its render at `width` and skips
+ * composing everything above the fold. The authoritative full paint replays
+ * once the drag settles (see {@link TUI} resize handling).
+ *
+ * Contract:
+ * - Returns the BOTTOM rows of the component's full render at `width`, in
+ *   top-to-bottom order, capped at `maxRows` (fewer when the component is
+ *   shorter). The rows MUST be byte-identical to the corresponding tail of
+ *   what `render(width)` would have returned, modulo a one-row separator at
+ *   the very top edge (a transient frame the settle paint overwrites).
+ * - MUST NOT mutate any persistent full-compose state: the next `render()`
+ *   (the settle paint) has to reconcile exactly as if the tail render never
+ *   happened. Warming pure per-width render caches is fine and desirable.
+ */
+export interface ViewportTailProvider {
+	renderViewportTail(width: number, maxRows: number): readonly string[];
+}
+
+function asViewportTailProvider(component: Component): ViewportTailProvider | undefined {
+	const candidate = component as Component & Partial<ViewportTailProvider>;
+	return typeof candidate.renderViewportTail === "function" ? (candidate as ViewportTailProvider) : undefined;
+}
+
 /**
  * Interface for components that can receive focus and display a cursor.
  * When focused, the component should emit CURSOR_MARKER at the cursor position
@@ -180,23 +313,6 @@ export interface Focusable {
 export interface RenderRequestOptions {
 	/** Clear terminal scrollback for intentional transcript replacement. */
 	clearScrollback?: boolean;
-	/**
-	 * Bypass the unknown-Windows-viewport deferral for this render so the
-	 * caller's intentional live UI mutation reaches the terminal even when
-	 * `Terminal#isNativeViewportAtBottom()` cannot answer.
-	 *
-	 * Use only for renders driven by direct user interaction (autocomplete
-	 * updates, IME, etc.). Any background/offscreen transcript change that
-	 * coalesces into the same frame WILL also bypass the deferral and reach
-	 * native scrollback — that is the trade-off, and the reason ordinary
-	 * `requestRender()` calls must continue to omit this flag.
-	 */
-	allowUnknownViewportMutation?: boolean;
-}
-
-/** Options for deferred native scrollback rebuild checkpoints. Reserved for API stability. */
-export interface NativeScrollbackRefreshOptions {
-	allowUnknownViewport?: boolean;
 }
 /** Type guard to check if a component implements Focusable */
 export function isFocusable(component: Component | null): component is Component & Focusable {
@@ -254,7 +370,13 @@ function parseSizeValue(value: SizeValue | undefined, referenceSize: number): nu
 
 /** Detect terminal multiplexers where scrollback clearing and height-change redraws are hostile. */
 function isMultiplexerSession(): boolean {
-	return Boolean(Bun.env.TMUX || Bun.env.STY || Bun.env.ZELLIJ);
+	// TMUX/STY/ZELLIJ are the authoritative signals, but they can be stripped while
+	// TERM survives (`sudo` without -E, `su`, env-sanitizing launchers/ssh). Fall back to
+	// the TERM prefix like every sibling multiplexer check (terminal-capabilities.ts) so a
+	// resize never emits ED3 into a tmux/screen pane and wipes its scrollback history.
+	if (Bun.env.TMUX || Bun.env.STY || Bun.env.ZELLIJ) return true;
+	const term = Bun.env.TERM?.toLowerCase() ?? "";
+	return term.startsWith("tmux") || term.startsWith("screen");
 }
 
 /**
@@ -295,6 +417,17 @@ export interface OverlayOptions {
 	 * Called each render cycle with current terminal dimensions.
 	 */
 	visible?: (termWidth: number, termHeight: number) => boolean;
+
+	// === Fullscreen ===
+	/**
+	 * Borrow the terminal's alternate screen buffer for this overlay's lifetime
+	 * (vim/less idiom). While the topmost visible overlay sets this, the engine
+	 * paints only the modal on the alt screen and emits no ED3 / scrollback
+	 * bytes, so the transcript on the normal screen stays untouched and is not
+	 * scrollable behind the modal. Defaults off — all other overlays are
+	 * unchanged and still draw over the transcript on the normal screen.
+	 */
+	fullscreen?: boolean;
 }
 
 /**
@@ -315,90 +448,235 @@ export interface OverlayHandle {
 export class Container implements Component {
 	children: Component[] = [];
 
+	// Memoized concatenation of the children's latest renders. Children are
+	// still rendered every frame (renders carry side effects: image placement
+	// registration, seam/stability reports); the memo only skips rebuilding
+	// the concatenated array when every child returned the exact same array
+	// reference at the same width — which, per the Component render contract,
+	// proves the rows are byte-identical. Cleared on any child-list change and
+	// on invalidate().
+	#memoLines: string[] | undefined;
+	#memoChildLines: (readonly string[])[] = [];
+	#memoWidth = -1;
+
 	addChild(component: Component): void {
 		this.children.push(component);
+		this.#memoLines = undefined;
 	}
 
 	removeChild(component: Component): void {
 		const index = this.children.indexOf(component);
 		if (index !== -1) {
 			this.children.splice(index, 1);
+			this.#memoLines = undefined;
 		}
 	}
 
 	clear(): void {
 		this.children = [];
+		this.#memoLines = undefined;
 	}
 
 	invalidate(): void {
+		this.#memoLines = undefined;
 		for (const child of this.children) {
 			child.invalidate?.();
 		}
 	}
 
-	render(width: number): string[] {
+	/**
+	 * Propagate teardown to children. Call when the container's children are
+	 * being permanently discarded (not when they are detached for reuse — use
+	 * {@link clear} for that). Idempotent per child via each child's own dispose.
+	 */
+	dispose(): void {
+		for (const child of this.children) {
+			child.dispose?.();
+		}
+	}
+
+	render(width: number): readonly string[] {
 		width = Math.max(1, width);
+		const children = this.children;
+		const count = children.length;
+		let refs = this.#memoChildLines;
+		let unchanged = this.#memoLines !== undefined && this.#memoWidth === width && refs.length === count;
+		if (refs.length !== count) {
+			refs = new Array(count);
+			this.#memoChildLines = refs;
+		}
+		for (let i = 0; i < count; i++) {
+			const childLines = children[i]!.render(width);
+			if (refs[i] !== childLines) {
+				unchanged = false;
+				refs[i] = childLines;
+			}
+		}
+		this.#memoWidth = width;
+		if (unchanged) return this.#memoLines!;
 		const lines: string[] = [];
-		for (const child of this.children) {
-			lines.push(...child.render(width));
+		for (let i = 0; i < count; i++) {
+			const childLines = refs[i]!;
+			for (let j = 0; j < childLines.length; j++) lines.push(childLines[j]!);
 		}
+		this.#memoLines = lines;
 		return lines;
 	}
 }
 
 /**
- * Render intent. `#planRender` decides which one a frame is, and the
- * corresponding `#emit*` method owns the bytes written and the state update.
+ * Render intent. `#doRender` classifies each frame, and the matching `#emit*`
+ * method owns the bytes written and the state update.
  *
- * - `noop`: no content change, only cursor may move.
- * - `initial`: first paint after `start()` — clear viewport, emit transcript.
- * - `sessionReplace`: caller asked for `{ clearScrollback: true }` on a forced
- *   render — clear viewport, clear scrollback (outside multiplexers).
- * - `historyRebuild`: a geometry change (terminal resize) left native history
- *   wrapped at the old size — clear viewport and scrollback so it rewraps at the
- *   new geometry. Also flushes deferred content-only rewrites.
- * - `liveRegionPinned`: ED3-risk/unknown foreground stream with a reported live
- *   suffix — optionally append newly sealed rows, then repaint the live/mutable
- *   tail without letting transient rows enter native history.
- * - `viewportRepaint`: rewrite the visible viewport in place. If `appendFrom`
- *   is set, emit those tail rows as scrollback growth first so streaming
- *   output reaches terminal history before the corrected viewport is drawn.
- * - `deferredShrink`: pure content shrink would re-expose rows already in
- *   native history. Keep row indices stable with blank tail padding, repaint
- *   only the viewport, and defer the real shorter replay to a checkpoint.
- * - `deferredTailRepaint`: a deferred history mutation also changed the active
- *   grid's bottom row; repaint only that row relative to the tracked hardware
- *   cursor so a bottom-anchored spinner can advance without rewriting rows that
- *   a slightly-scrolled reader can still see.
- * - `deferredMutation`: a row-inserting edit would reindex native scrollback
- *   while the user is scrolled. Defer all bytes until a safe rebuild checkpoint.
- * - `shrink`: trailing rows were dropped — clear extras inline.
- * - `diff`: differential repaint of visible rows / append new rows below.
+ * - `fullPaint`: gesture-driven replay — initial paint, session replacement,
+ *   resize, resetDisplay. Clears the viewport and (for destructive replaces,
+ *   outside multiplexers) native scrollback via ED3, then writes the
+ *   committed prefix and the visible window. The only ED3 callsite in the
+ *   engine.
+ * - `update`: ordinary frame. Commits the newly settled chunk at the
+ *   scrollback seam (if any) and repaints the window with relative moves.
  */
 type RenderIntent =
-	| { kind: "noop" }
-	| { kind: "initial" }
-	| { kind: "sessionReplace" }
-	| { kind: "historyRebuild" }
-	| { kind: "overlayRebuild" }
-	| { kind: "liveRegionPinned"; appendFrom: number; appendTo: number; renderViewportTop: number }
-	| { kind: "viewportRepaint"; appendFrom?: number }
-	| { kind: "deferredShrink"; paddedLength: number }
-	| { kind: "deferredTailRepaint"; row: number; line: string }
-	| { kind: "deferredMutation" }
-	| { kind: "shrink" }
-	| { kind: "diff"; firstChanged: number; lastChanged: number; appendedLines: boolean };
+	| { kind: "fullPaint"; clearScrollback: boolean }
+	| { kind: "update"; chunkTo: number; windowTop: number };
+
+interface HardwareCursorState {
+	row: number;
+	col: number;
+	visible: boolean;
+}
+
+interface HardwareCursorUpdate {
+	toRow: number;
+	state: HardwareCursorState | null;
+	visible?: boolean;
+}
+
+interface CursorControlResult extends HardwareCursorUpdate {
+	seq: string;
+	toCol: number;
+	visible: boolean;
+}
+
+/**
+ * One root child's contribution to the composed frame: the array reference its
+ * render() returned, the frame row it starts at, the row count recorded at
+ * compose time (in-place mutators keep the reference but may change length),
+ * and the child-local seam reports captured at render time — replayed verbatim
+ * when a component-scoped frame reuses this segment without re-rendering.
+ */
+interface FrameSegment {
+	component: Component;
+	lines: readonly string[];
+	start: number;
+	rowCount: number;
+	liveLocalStart?: number;
+	commitLocalEnd?: number;
+	snapshotLocalEnd?: number;
+}
+
+/** Depth-first identity search through `Container`-shaped children. */
+function subtreeContains(root: Component, target: Component): boolean {
+	if (root === target) return true;
+	const children = (root as Partial<Container>).children;
+	if (!Array.isArray(children)) return false;
+	for (let i = 0; i < children.length; i++) {
+		if (subtreeContains(children[i]!, target)) return true;
+	}
+	return false;
+}
+
+interface PreparedLine {
+	raw: string;
+	width: number;
+	line: string;
+}
+
+const SGR_SEQUENCE = /\x1b\[[0-9;:]*m/g;
+
+/** Compare two rows ignoring SGR styling (theme restyles keep alignment). */
+function rowsEquivalent(a: string, b: string): boolean {
+	if (a === b) return true;
+	return a.replace(SGR_SEQUENCE, "") === b.replace(SGR_SEQUENCE, "");
+}
+
+function isBlankRow(row: string): boolean {
+	if (row.length === 0) return true;
+	return row.replace(SGR_SEQUENCE, "").trim().length === 0;
+}
+
+// Tail-alignment sampling bounds: look back through up to LOOKBACK rows of
+// the committed prefix to collect SAMPLES non-blank comparisons.
+const RESYNC_TAIL_LOOKBACK = 24;
+const RESYNC_TAIL_SAMPLES = 8;
+
+/**
+ * Decide whether `frame` still aligns with the committed prefix, and where to
+ * re-anchor the commit index when it does not. Returns the resync row index,
+ * or -1 when no resync is needed.
+ *
+ * The detector exploits the asymmetry between the two mutation classes: an
+ * in-place edit or restyle of committed rows disturbs only the touched rows
+ * (alignment below them is intact — the stale copy in history is the
+ * long-accepted artifact), while any insertion or deletion shifts EVERY row
+ * below it, including the rows just above the commit boundary. So the prefix
+ * *tail* is sampled (up to 8 non-blank rows within the last 24, compared
+ * SGR-stripped so theme changes stay quiet, tolerating one mismatch for a
+ * legitimate single-row edit): aligned ⇒ no resync; misaligned ⇒ resync at
+ * the first non-equivalent row, recommitting from there — duplication, never
+ * loss. Highly repetitive tails (identical filler rows) can mask a shift, in
+ * which case the skipped rows are content-identical to the committed ones —
+ * observationally harmless. Exported for the render-stress harness, whose
+ * shadow commit ledger must mirror the engine's law exactly.
+ */
+export function findCommittedPrefixResync(
+	frame: readonly string[],
+	prefix: readonly string[],
+	auditLimit: number = prefix.length,
+): number {
+	// Audit only the byte-stable leading prefix [0, auditLimit); rows committed
+	// under a durable snapshot end (beyond auditLimit) may drift legitimately and
+	// are exempt, so their drift never triggers a re-anchor.
+	const committed = Math.min(prefix.length, Math.max(0, Math.trunc(auditLimit)));
+	if (committed === 0) return -1;
+	if (frame.length >= committed) {
+		let samples = 0;
+		let mismatches = 0;
+		const lookback = Math.min(RESYNC_TAIL_LOOKBACK, committed);
+		for (let j = 1; j <= lookback && samples < RESYNC_TAIL_SAMPLES; j++) {
+			const row = frame[committed - j]!;
+			const old = prefix[committed - j]!;
+			if (row === old) {
+				if (!isBlankRow(row)) samples++;
+				continue;
+			}
+			if (isBlankRow(row) && isBlankRow(old)) continue;
+			samples++;
+			if (!rowsEquivalent(row, old)) mismatches++;
+		}
+		// No signal (all-blank tail) or at most one edited row: aligned.
+		if (samples === 0 || mismatches <= 1) return -1;
+	}
+	// Misaligned (or the frame no longer covers the prefix): re-anchor at the
+	// first row whose content actually changed.
+	const limit = Math.min(committed, frame.length);
+	for (let i = 0; i < limit; i++) {
+		if (!rowsEquivalent(frame[i]!, prefix[i]!)) return i;
+	}
+	return limit < committed ? limit : -1;
+}
 
 /**
  * TUI - Main class for managing terminal UI with differential rendering
  */
 export class TUI extends Container {
 	terminal: Terminal;
-	#previousLines: string[] = [];
+	#previousFrameLength = 0;
 	#previousWidth = 0;
 	#previousHeight = 0;
 	#focusedComponent: Component | null = null;
 	#inputListeners = new Set<InputListener>();
+	#startListeners = new Set<StartListener>();
 
 	/** Global callback for debug key (Shift+Ctrl+D). Called before input is forwarded to focused component. */
 	onDebug?: () => void;
@@ -406,60 +684,110 @@ export class TUI extends Container {
 	#renderTimer: RenderTimer | undefined;
 	#renderScheduler: RenderScheduler;
 	#lastRenderAt = 0;
-	static readonly #MIN_RENDER_INTERVAL_MS = 16;
-	#cursorRow = 0; // Logical cursor row (end of rendered content)
+	static readonly #MIN_RENDER_INTERVAL_MS = 1000 / 30;
+	// Pane-reflow settle window for tmux/screen/zellij. The host process gets
+	// SIGWINCH (and `process.stdout` already reports the new geometry) before
+	// the multiplexer finishes repainting the pane at the new size, and
+	// drag-resize/pane-close animations fire several events in flight. A forced
+	// render on each SIGWINCH races those mid-reflow paints — the multiplexer's
+	// catch-up paint then partially overwrites the TUI output, which the user
+	// sees as a viewport flash or blank screen before the next throttled frame
+	// arrives (issue #2088). Coalescing every SIGWINCH inside this window into
+	// a single forced render lets the multiplexer settle first.
+	static readonly #MULTIPLEXER_RESIZE_DEBOUNCE_MS = 50;
+	// Resize viewport fast path (non-multiplexer). A drag emits a SIGWINCH burst,
+	// and outside a multiplexer the host gets each new geometry atomically. The
+	// authoritative resize paint erases and replays the entire transcript so it
+	// rewraps at the new width — O(history) compose (markdown re-lexes every
+	// block, the per-width cache missing on every distinct drag width) plus an
+	// O(history) write that pushes all of it back through native scrollback. At
+	// drag rates that whole-history pass is recomputed dozens of times a second
+	// and discarded the instant the next event lands. While the drag is in
+	// flight the engine instead composes and paints ONLY the viewport (see
+	// `#renderResizeViewport`): a state-isolated, throwaway frame that never
+	// touches the commit ledger. The authoritative full replay fires once, after
+	// the drag has been quiet for this long. Multiplexer sessions keep their own
+	// debounce (`#armMultiplexerResizeTimer`, see #2088) and never take this path.
+	static readonly #RESIZE_VIEWPORT_SETTLE_MS = 120;
+	// Ghostty can drop Kitty graphics commands sent during its first post-startup
+	// settle window, leaving only Unicode placeholder cells. Hold the first image
+	// paint until that window has passed; later images render normally.
+	static readonly #GHOSTTY_INITIAL_IMAGE_DELAY_MS = 100;
+	// Post-paint settle window for ConPTY hosts. The `sessionReplace` /
+	// `historyRebuild` / `overlayRebuild` intents drive `#emitFullPaint` over
+	// a transcript that overflows the viewport, scroll-pushing everything past
+	// the last `height` rows into native scrollback. Windows Terminal's
+	// viewport-follow logic gets lossy during that burst: spinner/blink-driven
+	// `requestRender(false)` calls firing inside the window each produce another
+	// diff write, and the WT host processes them faster than its viewport
+	// tracker can keep up — the visible tail ends up parked a few rows above
+	// the actual last row until any focus event (Alt+Tab) forces a host repaint.
+	// Coalescing every non-forced render inside this window into a single
+	// trailing render lets the host fully settle the big paint before any
+	// follow-up writes touch the buffer. The first-ever `initial` paint is
+	// deliberately exempt: nothing has been on screen yet, so no drift can
+	// have accumulated, and tests that start the TUI over an over-tall
+	// component depend on the next paint firing without delay. Only armed on
+	// ConPTY hosts (`isConPTYHosted()`); other terminals do not exhibit the
+	// drift and would just see an unnecessary post-paint latency. See #2095.
+	static readonly #CONPTY_POST_FULL_PAINT_SETTLE_MS = 150;
+	#postFullPaintSettleUntilMs = 0;
+	#postFullPaintSettleTimer: RenderTimer | undefined;
 	#hardwareCursorRow = 0; // Actual terminal cursor row (may differ due to IME positioning)
-	#viewportTopRow = 0; // Content row currently mapped to screen row 0
+	#hardwareCursorState: HardwareCursorState | null = null;
+	#hardwareCursorVisibilityKnown = false;
+	#hardwareCursorVisible = false;
 	#sixelProbePendingDa = false;
 	#sixelProbePendingGraphics = false;
 	#sixelProbeBuffer = "";
 	#sixelProbeTimeout?: NodeJS.Timeout;
 	#sixelProbeUnsubscribe?: () => void;
 	#showHardwareCursor = $flag("PROMETHEUS_HARDWARE_CURSOR");
-	#clearOnShrink = $flag("PROMETHEUS_CLEAR_ON_SHRINK"); // Clear empty rows when content shrinks (default: off)
 	#synchronizedOutputEnabled = shouldEnableSynchronizedOutputByDefault();
 	#paintBeginSequence = this.#synchronizedOutputEnabled ? PAINT_BEGIN : PAINT_BEGIN_NO_SYNC;
 	#paintEndSequence = this.#synchronizedOutputEnabled ? PAINT_END : PAINT_END_NO_SYNC;
 	#cursorBeginSequence = this.#synchronizedOutputEnabled ? CURSOR_BEGIN : CURSOR_BEGIN_NO_SYNC;
 	#cursorEndSequence = this.#synchronizedOutputEnabled ? CURSOR_END : CURSOR_END_NO_SYNC;
-	#maxLinesRendered = 0; // Line count from last render, used for viewport calculation
-	// Highest count of content rows currently sitting in terminal scrollback
-	// above the visible viewport. Used to detect shrink-across-viewport-boundary
-	// frames where the new transcript would re-expose rows the terminal has
-	// already committed to history — without intervention the rows visibly
-	// duplicate once the user scrolls back.
-	#scrollbackHighWater = 0;
-	// Set after a clear+full replay so the next insert-above-suffix frame does
-	// not scroll replayed live chrome (status/editor) into fresh history.
-	#suppressNextSuffixScroll = false;
+	// Rows of the current frame physically committed to the terminal tape
+	// (native scrollback or scrolled past the window top). Immutable by
+	// contract: the engine never rewrites them, and components keep mutable
+	// rows below the `NativeScrollbackLiveRegion` boundary so they never get
+	// here while they can still change.
+	#committedRows = 0;
+	// Raw rows mirroring [0, #committedRows) — the engine's claim of what it
+	// committed, audited each ordinary frame against the current render to
+	// detect components re-laying-out committed content (see
+	// #auditCommittedPrefix). Holds references to component-cached strings, so
+	// the audit is a pointer walk in the common case.
+	#committedPrefix: string[] = [];
+	// Length of the leading committed prefix [0, #committedPrefixAuditRows) that
+	// is BYTE-STABLE and therefore audited. Rows [auditRows, committedRows) were
+	// committed under a component's snapshot-safe (durable, non-byte-stable) end:
+	// their scroll-off snapshot is permanent so dropping them is forbidden, but
+	// they may drift afterward (a streaming table widening), so re-auditing them
+	// would re-anchor on every drift and spray duplicate snapshots. Once a
+	// snapshot row commits (auditRows < committedRows) the cap is permanent until
+	// a wholesale re-slice (full paint / shrink / geometry) re-bases it.
+	#committedPrefixAuditRows = 0;
+	// Frame row currently mapped to screen row 0. Monotonic between full
+	// paints: a shrink never re-exposes scrolled-off rows (they cannot be
+	// un-scrolled without rewriting history); live rows repaint at fixed
+	// positions with blank rows below the shrunken tail.
+	#windowTopRow = 0;
+	// Exactly what is painted on the screen rows (post-composite, prepared).
+	#previousWindow: string[] = [];
 	#nativeScrollbackLiveRegionStart: number | undefined;
 	#nativeScrollbackCommitSafeEnd: number | undefined;
-	#nativeScrollbackDirty = false;
-	#deferredTailLine: string | undefined;
-	// Highest `#maxLinesRendered` reached during a foreground tool turn while
-	// intermediate frames were prevented from committing to terminal scrollback.
-	// Used after the tool finishes to push the settled content into scrollback
-	// via a non-destructive full paint (no ED 3). Reset to 0 once rows are
-	// committed (via any `#emitFullPaint`, `#emitDiff`, or `#emitAppendTail`
-	// path).
-	#streamingHighWater = 0;
-	// Tracks whether the previous frame was inside a foreground tool streaming
-	// turn. Used to reset `#streamingHighWater` on fresh streaming starts.
-	#previousStreamingActive = false;
+	#nativeScrollbackSnapshotSafeEnd: number | undefined;
 	#fullRedrawCount = 0;
 	// Caps how many inline images render as live graphics; older ones fall back
 	// to text via a purge + full redraw. Cap is configured by the host app.
 	#imageBudget = new ImageBudget(DEFAULT_MAX_INLINE_IMAGES, () => this.requestRender());
+	#ghosttyInitialImageDelayDone = false;
+	#ghosttyInitialImageDelayTimer: RenderTimer | undefined;
+	#ghosttyImageReadyAtMs = 0;
 	#clearScrollbackOnNextRender = false;
 	#forceViewportRepaintOnNextRender = false;
-	#allowUnknownViewportMutationOnNextRender = false;
-	#eagerNativeScrollbackRebuild = false;
-	// Set when eager mode is switched off; applied after the next frame is
-	// classified so teardown frames from the same event batch still render
-	// eagerly (see setEagerNativeScrollbackRebuild).
-	#eagerNativeScrollbackRebuildDisablePending = false;
-	#previousVisibleOverlayComponents: Component[] = [];
-	#visibleOverlayComponentsThisRender: Component[] = [];
 	#hasEverRendered = false;
 	// Set by the terminal resize callback; consumed by the next render. A resize
 	// event invalidates the committed screen even when the dimensions net out
@@ -468,7 +796,91 @@ export class TUI extends Container {
 	// between the viewport and scrollback, so the previous frame no longer
 	// describes the screen. Tracking only the dimension delta misses this.
 	#resizeEventPending = false;
+	// Active multiplexer SIGWINCH debounce. Reset on each event so the timer
+	// only fires once the pane stops resizing. Forced renders (resetDisplay,
+	// finishSixelProbe, …) issued during the settle window route through the
+	// same timer; their `clearScrollback` intent is OR'd into the deferred
+	// flag below so the settled paint still honours every caller's request.
+	#multiplexerResizeTimer: RenderTimer | undefined;
+	#deferredForcedClearScrollback = false;
+	// True from the first SIGWINCH of a non-multiplexer drag until the settle
+	// timer fires. While set, every `#doRender` short-circuits to the viewport
+	// fast path (`#renderResizeViewport`) instead of an authoritative full
+	// paint, and no commit/window/diff state is advanced.
+	#resizeViewportActive = false;
+	// Set only by the resize callback's cheap-paint request. A concurrent
+	// caller-forced render (tool finalization, reset, image reconciliation) must
+	// not be downgraded to the throwaway viewport path just because a resize
+	// settle window is active.
+	#resizeViewportPaintPending = false;
+	// Quiet-window timer that ends the drag: its callback clears the flag and
+	// drives the one authoritative full paint. Reset on every resize event so it
+	// only fires once the drag stops. Cancelled on stop().
+	#resizeViewportSettleTimer: RenderTimer | undefined;
+	// Count of transient viewport-only resize paints emitted. Distinct from
+	// `#fullRedrawCount`: these never enter native scrollback and exist only for
+	// the lifetime of the drag. Exposed for tests/diagnostics.
+	#resizeViewportPaintCount = 0;
+	// During a live resize drag the terminal's normal buffer may reflow full-width
+	// rows before our repaint lands. Borrow the alternate screen for throwaway
+	// resize frames so width changes truncate the transient viewport instead of
+	// pushing wrapped fragments into native scrollback.
+	#resizeAltActive = false;
 	#stopped = false;
+	// Always-on event-loop lag probe. The high default threshold keeps it quiet;
+	// it only logs `ui.loop-blocked` (with the current loop phase) when a frame
+	// budget is genuinely starved. Armed in start(), disarmed in stop().
+	#watchdog: LoopWatchdog;
+
+	// Transient alternate-screen state for a fullscreen overlay. While active, the
+	// engine paints only the modal on the alt buffer and leaves every
+	// normal-screen accounting field (#previousFrameLength, #viewportTopRow, …)
+	// untouched, so exiting reconciles cleanly against the terminal-restored
+	// normal screen. #altPreviousLines is the last alt frame, for repaint-skip.
+	#altActive = false;
+	#altPreviousLines: string[] = [];
+	#altEnterWidth = 0;
+	#altEnterHeight = 0;
+
+	// Persistent composed frame. The render override splices only rows at/after
+	// the stable prefix each frame; cursor markers are stripped at ingestion so
+	// the frame never carries them. Returned to render() callers — treated as
+	// immutable by them per the Component render contract.
+	#composedFrame: string[] = [];
+	// Per-root-child segment ledger backing the stable-prefix computation.
+	#frameSegments: FrameSegment[] = [];
+	#composeWidth = -1;
+	// Cursor markers stripped at ingestion, ascending by frame row.
+	#frameCursorMarkers: { row: number; col: number }[] = [];
+	// Leading rows of #composedFrame byte-identical to the previous compose.
+	#renderStablePrefixRows = 0;
+
+	// Component-scoped render accumulation. Targets are the components handed
+	// to requestComponentRender() since the last frame; the flag stays true
+	// only while EVERY pending request is component-scoped. Both are consumed
+	// once per frame by #doRender.
+	#componentRenderTargets = new Set<Component>();
+	#pendingRenderComponentsOnly = false;
+	// Root children that must re-render during the current compose; null for a
+	// full compose. Non-null only for the duration of a component-scoped
+	// render() call inside #doRender (the scratch set below, reused per frame).
+	#partialComposeRoots: Set<Component> | null = null;
+	#partialComposeRootsScratch = new Set<Component>();
+	// Target component -> containing root child, so animation-rate requests do
+	// not re-walk a huge transcript subtree every frame.
+	#componentRootCache = new WeakMap<Component, Component>();
+
+	// Persistent prepared frame, row-aligned with #composedFrame. Entries store
+	// normalized, width-fitted content rows without the per-line terminal
+	// terminator; terminators are appended only at write time so width checks
+	// stay on content, not reset bytes. #preparedValidRows counts the leading
+	// rows known prepared against the CURRENT composed frame: a compose lowers
+	// it to the stable prefix, a completed prepare raises it to the frame
+	// length, and an abandoned frame (ghostty image defer) leaves it lowered so
+	// the next prepare revalidates the splice.
+	#preparedFrame: string[] = [];
+	#preparedMeta: PreparedLine[] = [];
+	#preparedValidRows = 0;
 
 	// Overlay stack for modal components rendered on top of base content
 	overlayStack: {
@@ -483,33 +895,178 @@ export class TUI extends Container {
 		this.terminal = terminal;
 		this.#renderScheduler = options?.renderScheduler ?? DEFAULT_RENDER_SCHEDULER;
 		this.#showHardwareCursor = showHardwareCursor === undefined ? this.#showHardwareCursor : showHardwareCursor;
+		this.#watchdog = new LoopWatchdog();
 	}
 
-	override render(width: number): string[] {
+	override render(width: number): readonly string[] {
 		width = Math.max(1, width);
 		this.#nativeScrollbackLiveRegionStart = undefined;
 		this.#nativeScrollbackCommitSafeEnd = undefined;
-		const lines: string[] = [];
-		for (const child of this.children) {
-			const offset = lines.length;
-			const childLines = child.render(width);
-			const liveRegionStart = getNativeScrollbackLiveRegionStart(child);
-			if (liveRegionStart !== undefined) {
-				const boundedStart = Number.isFinite(liveRegionStart)
-					? Math.max(0, Math.min(childLines.length, Math.trunc(liveRegionStart)))
-					: childLines.length;
-				this.#nativeScrollbackLiveRegionStart = offset + boundedStart;
-				const commitSafeEnd = getNativeScrollbackCommitSafeEnd(child);
-				if (commitSafeEnd !== undefined) {
-					const boundedEnd = Number.isFinite(commitSafeEnd)
-						? Math.max(boundedStart, Math.min(childLines.length, Math.trunc(commitSafeEnd)))
+		this.#nativeScrollbackSnapshotSafeEnd = undefined;
+		const children = this.children;
+		const previousSegments = this.#frameSegments;
+		const segments: FrameSegment[] = new Array(children.length);
+		// A width change re-renders every child; nothing carries over.
+		let chainStable = this.#composeWidth === width;
+		this.#composeWidth = width;
+		let offset = 0;
+		let stableRows = 0;
+		const partialRoots = this.#partialComposeRoots;
+		for (let index = 0; index < children.length; index++) {
+			const child = children[index]!;
+			const previous = previousSegments[index];
+			// Component-scoped frame: a root child outside every requested
+			// subtree provably did not change (content mutations route through
+			// a render request, which would have made this frame a full one) —
+			// reuse its previous rows and seam report without calling render().
+			const reuse =
+				partialRoots !== null && previous !== undefined && previous.component === child && !partialRoots.has(child);
+			let childLines: readonly string[];
+			let liveLocalStart: number | undefined;
+			let commitLocalEnd: number | undefined;
+			let snapshotLocalEnd: number | undefined;
+			let reported: number | undefined;
+			if (reuse) {
+				childLines = previous.lines;
+				liveLocalStart = previous.liveLocalStart;
+				commitLocalEnd = previous.commitLocalEnd;
+				snapshotLocalEnd = previous.snapshotLocalEnd;
+			} else {
+				// Feed the engine's committed-row claim (from the previous frame's
+				// emit) before rendering so the child can skip re-deriving blocks
+				// that already live in immutable native scrollback. Reused segments
+				// skip this: they never call render(), so the signal is moot.
+				setNativeScrollbackCommittedRows(child, Math.max(0, this.#committedRows - offset));
+				childLines = child.render(width);
+				const liveRegionStart = getNativeScrollbackLiveRegionStart(child);
+				if (liveRegionStart !== undefined) {
+					liveLocalStart = Number.isFinite(liveRegionStart)
+						? Math.max(0, Math.min(childLines.length, Math.trunc(liveRegionStart)))
 						: childLines.length;
-					this.#nativeScrollbackCommitSafeEnd = offset + boundedEnd;
+					const commitSafeEnd = getNativeScrollbackCommitSafeEnd(child);
+					if (commitSafeEnd !== undefined) {
+						commitLocalEnd = Number.isFinite(commitSafeEnd)
+							? Math.max(liveLocalStart, Math.min(childLines.length, Math.trunc(commitSafeEnd)))
+							: childLines.length;
+					}
+					// Durable snapshot end: clamped at/above the byte-stable end (or
+					// the live-region start when none) so a child can never report a
+					// shallower durable boundary than its byte-stable one.
+					const snapshotSafeEnd = getNativeScrollbackSnapshotSafeEnd(child);
+					if (snapshotSafeEnd !== undefined) {
+						const snapshotFloor = commitLocalEnd ?? liveLocalStart;
+						snapshotLocalEnd = Number.isFinite(snapshotSafeEnd)
+							? Math.max(snapshotFloor, Math.min(childLines.length, Math.trunc(snapshotSafeEnd)))
+							: childLines.length;
+					}
+				}
+				// Consume the stability report unconditionally for implementers:
+				// reading re-bases the component's baseline to the state this
+				// compose is about to ingest (used or not, the current rows are
+				// what ends up in the composed frame). Reused segments are
+				// deliberately NOT read — their baseline must stay anchored to
+				// the last render the engine actually observed.
+				reported = getRenderStablePrefixRows(child);
+			}
+			// Topmost seam wins. Commits are prefix-only: the first child that
+			// reports a live region (plus its own commit-safe extension) already
+			// bounds everything below it, so a lower sibling's seam (e.g. a
+			// status loader under a streaming transcript) must never overwrite
+			// it — moving the boundary down would commit the earlier child's
+			// still-mutable rows as stale history.
+			if (liveLocalStart !== undefined && this.#nativeScrollbackLiveRegionStart === undefined) {
+				this.#nativeScrollbackLiveRegionStart = offset + liveLocalStart;
+				if (commitLocalEnd !== undefined) {
+					this.#nativeScrollbackCommitSafeEnd = offset + commitLocalEnd;
+				}
+				if (snapshotLocalEnd !== undefined) {
+					this.#nativeScrollbackSnapshotSafeEnd = offset + snapshotLocalEnd;
+				}
+			}
+			if (chainStable) {
+				if (previous !== undefined && previous.component === child && previous.start === offset) {
+					let stableCount = 0;
+					if (reported !== undefined) {
+						// In-place mutator: its report overrides reference equality.
+						// Rows beyond the previous row count cannot be "unchanged".
+						stableCount = Number.isFinite(reported)
+							? Math.max(0, Math.min(childLines.length, previous.rowCount, Math.trunc(reported)))
+							: 0;
+					} else if (previous.lines === childLines) {
+						stableCount = childLines.length;
+					}
+					stableRows += stableCount;
+					// The chain survives only a fully stable segment: identical rows
+					// AND identical row count (a grown/shrunk segment shifts every
+					// row below it).
+					if (stableCount < childLines.length || previous.rowCount !== childLines.length) chainStable = false;
+				} else {
+					chainStable = false;
 				}
 			}
-			lines.push(...childLines);
+			segments[index] = {
+				component: child,
+				lines: childLines,
+				start: offset,
+				rowCount: childLines.length,
+				liveLocalStart,
+				commitLocalEnd,
+				snapshotLocalEnd,
+			};
+			offset += childLines.length;
+		}
+		this.#frameSegments = segments;
+
+		const frame = this.#composedFrame;
+		// Defensive clamp: stable rows can never exceed what the previous
+		// compose actually materialized (only reachable if a child render threw
+		// mid-compose on the previous frame).
+		if (stableRows > frame.length) stableRows = frame.length;
+		if (stableRows !== offset || frame.length !== offset) {
+			// Re-ingest every row at/after the stable prefix: truncate, strip
+			// cursor markers, record their positions.
+			frame.length = stableRows;
+			this.#pruneFrameCursorMarkers(stableRows);
+			for (const segment of segments) {
+				const lines = segment.lines;
+				const from = segment.start >= stableRows ? 0 : stableRows - segment.start;
+				for (let i = from; i < lines.length; i++) this.#ingestFrameRow(lines[i]!);
+			}
 		}
-		return lines;
+		this.#renderStablePrefixRows = stableRows;
+		this.#preparedValidRows = Math.min(this.#preparedValidRows, stableRows);
+		return frame;
+	}
+
+	/** Drop cached cursor markers at/after `fromRow` (those rows re-ingest). */
+	#pruneFrameCursorMarkers(fromRow: number): void {
+		const markers = this.#frameCursorMarkers;
+		let keep = markers.length;
+		while (keep > 0 && markers[keep - 1]!.row >= fromRow) keep--;
+		markers.length = keep;
+	}
+
+	/**
+	 * Append one row to the composed frame, stripping CURSOR_MARKER occurrences
+	 * (internal sentinels that must never reach the terminal, the committed
+	 * prefix, or the resync audit) and recording the first marker's position.
+	 */
+	#ingestFrameRow(line: string): void {
+		let markerIndex = line.indexOf(CURSOR_MARKER);
+		if (markerIndex === -1) {
+			this.#composedFrame.push(line);
+			return;
+		}
+		this.#frameCursorMarkers.push({
+			row: this.#composedFrame.length,
+			col: visibleWidth(line.slice(0, markerIndex)),
+		});
+		let stripped = line;
+		while (markerIndex !== -1) {
+			stripped = stripped.slice(0, markerIndex) + stripped.slice(markerIndex + CURSOR_MARKER.length);
+			markerIndex = stripped.indexOf(CURSOR_MARKER, markerIndex);
+		}
+		this.#composedFrame.push(stripped);
 	}
 
 	#syncTerminalCursorMode(component: Component | null): void {
@@ -522,6 +1079,20 @@ export class TUI extends Container {
 		return this.#fullRedrawCount;
 	}
 
+	/**
+	 * Transient viewport-only paints emitted by the non-multiplexer resize fast
+	 * path. These never touch native scrollback or the commit ledger, so they
+	 * are counted apart from {@link fullRedraws}.
+	 */
+	get resizeViewportPaints(): number {
+		return this.#resizeViewportPaintCount;
+	}
+
+	/** Whether a non-multiplexer resize drag is currently in flight. */
+	get resizeViewportActive(): boolean {
+		return this.#resizeViewportActive;
+	}
+
 	/** Shared budget that caps how many inline images render as live graphics. */
 	get imageBudget(): ImageBudget {
 		return this.#imageBudget;
@@ -546,78 +1117,31 @@ export class TUI extends Container {
 		this.#syncTerminalCursorMode(this.#focusedComponent);
 		if (!enabled) {
 			this.terminal.hideCursor();
+			this.#recordHardwareCursorHidden();
 		}
 		this.requestRender();
 	}
 
-	getClearOnShrink(): boolean {
-		return this.#clearOnShrink;
-	}
-
-	/**
-	 * Set whether to trigger full re-render when content shrinks.
-	 * When true (default), empty rows are cleared when content shrinks.
-	 * When false, empty rows remain (reduces redraws on slower terminals).
-	 */
-	setClearOnShrink(enabled: boolean): void {
-		this.#clearOnShrink = enabled;
-	}
-
 	/**
 	 * Whether DEC 2026 synchronized-output wrappers are currently emitted around
-	 * paints. Starts from conservative terminal/env detection and is force-disabled
-	 * at runtime if the terminal reports mode 2026 unsupported via DECRQM.
+	 * paints. Starts from conservative terminal/env detection and is reconciled at
+	 * runtime against the terminal's DECRQM mode-2026 report — enabled on a
+	 * positive report, disabled on a negative one.
 	 */
 	get synchronizedOutput(): boolean {
 		return this.#synchronizedOutputEnabled;
 	}
-
-	/**
-	 * When enabled, live render frames rebuild native scrollback on offscreen and
-	 * structural changes even when the viewport position is unobservable (POSIX,
-	 * where `isNativeViewportAtBottom()` is `undefined`), instead of deferring to a
-	 * non-destructive repaint. This trades the anti-yank guarantee for a clean,
-	 * duplicate-free history and is meant for windows where output above the fold
-	 * is actively re-rendering — e.g. a tool whose result is still streaming and
-	 * re-laying-out rows that have already scrolled into history. A terminal that
-	 * reports a *known*-scrolled viewport still defers, as does native Windows
-	 * (the viewport is never observable there and ConPTY hosts erase host
-	 * scrollback on ED3 — #1635/#1746); only the unknown POSIX case is forced to
-	 * rebuild. POSIX hosts known to disturb scrolled readers on xterm ED3
-	 * (`CSI 3 J`, erase saved lines) also defer the eager opt-in; checkpoint
-	 * rebuilds are unaffected.
-	 *
-	 * Disabling stays active through one already-requested frame: the event batch
-	 * that ends a foreground stream both removes its UI rows (loader/status
-	 * teardown — a shrink) and clears this flag before the throttled render timer
-	 * fires. If the flag dropped immediately, that teardown frame would hit the
-	 * ED3-risk idle deferral and freeze on screen (stale spinner) until the next
-	 * keystroke. When no render is pending, disable immediately so a later
-	 * unrelated content mutation does not inherit foreground-stream privileges.
-	 */
-	setEagerNativeScrollbackRebuild(enabled: boolean): void {
-		if (enabled) {
-			this.#eagerNativeScrollbackRebuild = true;
-			this.#eagerNativeScrollbackRebuildDisablePending = false;
-			return;
-		}
-		if (!this.#eagerNativeScrollbackRebuild) return;
-		if (this.#renderRequested || this.#renderTimer !== undefined) {
-			this.#eagerNativeScrollbackRebuildDisablePending = true;
-			return;
-		}
-		if (this.#hasEagerEraseScrollbackRisk()) {
-			this.#streamingHighWater = 0;
-			this.#markNativeScrollbackDirty();
-		}
-		this.#eagerNativeScrollbackRebuild = false;
-		this.#eagerNativeScrollbackRebuildDisablePending = false;
+	#deccaraFillsEnabled(): boolean {
+		// DECCARA fill rectangles arrive after shortened row text; synchronized
+		// output hides that intermediate default-background state from users.
+		return TERMINAL.deccara && this.#synchronizedOutputEnabled;
 	}
 
 	setFocus(component: Component | null): void {
+		const previousFocusedComponent = this.#focusedComponent;
 		// Clear focused flag on old component
-		if (isFocusable(this.#focusedComponent)) {
-			this.#focusedComponent.focused = false;
+		if (isFocusable(previousFocusedComponent)) {
+			previousFocusedComponent.focused = false;
 		}
 
 		this.#focusedComponent = component;
@@ -630,6 +1154,11 @@ export class TUI extends Container {
 		}
 	}
 
+	/** Component currently receiving keyboard input, if any. */
+	getFocused(): Component | null {
+		return this.#focusedComponent;
+	}
+
 	/**
 	 * Show an overlay component with configurable positioning and sizing.
 	 * Returns a handle to control the overlay's visibility.
@@ -642,6 +1171,7 @@ export class TUI extends Container {
 			this.setFocus(component);
 		}
 		this.terminal.hideCursor();
+		this.#recordHardwareCursorHidden();
 		this.requestRender();
 
 		// Return handle for controlling this overlay
@@ -655,7 +1185,10 @@ export class TUI extends Container {
 						const topVisible = this.#getTopmostVisibleOverlay();
 						this.setFocus(topVisible?.component ?? entry.preFocus);
 					}
-					if (this.overlayStack.length === 0) this.terminal.hideCursor();
+					if (this.overlayStack.length === 0) {
+						this.terminal.hideCursor();
+						this.#recordHardwareCursorHidden();
+					}
 					this.requestRender();
 				}
 			},
@@ -688,7 +1221,10 @@ export class TUI extends Container {
 		// Find topmost visible overlay, or fall back to preFocus
 		const topVisible = this.#getTopmostVisibleOverlay();
 		this.setFocus(topVisible?.component ?? overlay.preFocus);
-		if (this.overlayStack.length === 0) this.terminal.hideCursor();
+		if (this.overlayStack.length === 0) {
+			this.terminal.hideCursor();
+			this.#recordHardwareCursorHidden();
+		}
 		this.requestRender();
 	}
 
@@ -716,41 +1252,77 @@ export class TUI extends Container {
 		return undefined;
 	}
 
-	#overlayVisibilityReduced(visibleComponents: readonly Component[]): boolean {
-		if (this.#previousVisibleOverlayComponents.length === 0) return false;
-		for (const component of this.#previousVisibleOverlayComponents) {
-			if (!visibleComponents.includes(component)) return true;
-		}
-		return false;
-	}
-
 	override invalidate(): void {
 		super.invalidate();
 		for (const overlay of this.overlayStack) overlay.component.invalidate?.();
 	}
 
-	start(): void {
+	start(options?: TUIStartOptions): void {
 		this.#stopped = false;
-		// Disable synchronized output if the terminal reports DEC 2026 unsupported
-		// via DECRQM. PROMETHEUS_NO_SYNC_OUTPUT already forces it off at construction, so
-		// only react when the user has not already opted out. Future paints drop
-		// the begin/end markers; the autowrap guards stay (see #1765).
+		this.#watchdog.start();
+		this.#ghosttyInitialImageDelayDone = false;
+		this.#ghosttyImageReadyAtMs = this.#renderScheduler.now() + TUI.#GHOSTTY_INITIAL_IMAGE_DELAY_MS;
+		// A DECRQM report for mode 2026 is authoritative: enable synchronized
+		// output when the terminal reports support (upgrading conservatively
+		// defaulted-off hosts like zellij/tmux-master/foot) and disable it when
+		// the terminal reports it unsupported. An explicit user opt-out/force
+		// (resolved at construction) still wins, so skip the probe in that case.
 		this.terminal.onPrivateModeReport?.((mode, supported) => {
-			if (mode === 2026 && !supported && !$flag("PROMETHEUS_NO_SYNC_OUTPUT")) {
-				this.#setSynchronizedOutput(false);
-			}
+			if (mode !== 2026) return;
+			if (synchronizedOutputUserOverride() !== null) return;
+			this.#setSynchronizedOutput(supported);
 		});
 		this.terminal.start(
 			data => this.#handleInput(data),
 			() => {
+				// Real terminals deliver SIGWINCH (and the equivalent ConPTY
+				// notification) atomically with the new `process.stdout` geometry, so
+				// a forced render must fire immediately: it clears and replays at the
+				// fresh size before the terminal's reflow settles into a state a
+				// throttled frame would race. Multiplexer panes (tmux/screen/zellij)
+				// do not give that guarantee. The host receives SIGWINCH while the
+				// multiplexer is still mid-reflow — it has not finished repainting
+				// the pane buffer at the new size — and a drag-resize or pane-close
+				// animation fires several events in flight. Forcing a render on each
+				// event races those mid-reflow paints: the multiplexer's catch-up
+				// paint then partially overwrites the TUI output, which the user sees
+				// as a viewport flash or blank screen before the next throttled
+				// frame arrives (issue #2088). `#armMultiplexerResizeTimer` coalesces
+				// SIGWINCHes (and any forced repaints arriving during the settle
+				// window) into a single render once the pane is quiet —
+				// `#resizeEventPending` is set first so the eventual render still
+				// classifies as a resize.
 				this.#resizeEventPending = true;
-				this.requestRender();
+				if (!isMultiplexerSession()) {
+					// Enter the viewport fast path and (re)arm the settle timer, then
+					// request the cheap viewport-only paint. The authoritative full
+					// replay fires from the settle timer once the drag goes quiet.
+					this.#beginResizeViewport();
+					this.#requestResizeViewportPaint();
+					return;
+				}
+				this.#armMultiplexerResizeTimer(false);
 			},
 		);
+		for (const listener of this.#startListeners) {
+			try {
+				listener();
+			} catch {
+				// Startup listeners are feature hooks; one broken hook must not prevent rendering.
+			}
+		}
 		this.terminal.hideCursor();
+		this.#recordHardwareCursorHidden();
 		this.#querySixelSupport();
 		this.#queryCellSize();
-		this.requestRender(true);
+		this.requestRender(true, { clearScrollback: options?.clearScrollback === true });
+	}
+
+	addStartListener(listener: StartListener): () => void {
+		this.#startListeners.add(listener);
+		return () => {
+			this.#startListeners.delete(listener);
+		};
 	}
 
 	addInputListener(listener: InputListener): () => void {
@@ -901,8 +1473,8 @@ export class TUI extends Container {
 
 	/**
 	 * Toggle synchronized-output (DEC 2026) wrappers on paint/cursor writes and
-	 * recompute the cached begin/end sequences. Honors a DECRQM report that the
-	 * terminal does not support 2026 (#1765 covers the static env opt-out).
+	 * recompute the cached begin/end sequences. Driven by the terminal's DECRQM
+	 * mode-2026 report (#1765 covers the static env opt-out).
 	 */
 	#setSynchronizedOutput(enabled: boolean): void {
 		if (this.#synchronizedOutputEnabled === enabled) return;
@@ -914,6 +1486,18 @@ export class TUI extends Container {
 	}
 
 	stop(): void {
+		// Leave the alt buffer first so the teardown cursor math below runs against
+		// the restored normal screen (which #previousLines still describes).
+		if (this.#resizeAltActive) {
+			this.terminal.write(this.#leaveResizeAltSequence());
+		}
+		if (this.#altActive) {
+			const kittyPop = this.terminal.kittyEnableSequence ? "\x1b[<u" : "";
+			this.terminal.write(`${MOUSE_TRACKING_OFF}${kittyPop}\x1b[?1049l`);
+			setAltScreenActive(false);
+			this.#altActive = false;
+			this.#altPreviousLines = [];
+		}
 		if (TERMINAL.imageProtocol === ImageProtocol.Kitty) {
 			for (const id of this.#imageBudget.takeAllTransmittedIds()) {
 				this.terminal.write(encodeKittyDeleteImage(id));
@@ -921,19 +1505,35 @@ export class TUI extends Container {
 		}
 		this.#clearSixelProbeState();
 		this.#stopped = true;
+		this.#watchdog.stop();
 		if (this.#renderTimer) {
 			this.#renderTimer.cancel();
 			this.#renderTimer = undefined;
 		}
+		if (this.#ghosttyInitialImageDelayTimer) {
+			this.#ghosttyInitialImageDelayTimer.cancel();
+			this.#ghosttyInitialImageDelayTimer = undefined;
+		}
+		if (this.#multiplexerResizeTimer) {
+			this.#multiplexerResizeTimer.cancel();
+			this.#multiplexerResizeTimer = undefined;
+		}
+		if (this.#resizeViewportSettleTimer) {
+			this.#resizeViewportSettleTimer.cancel();
+			this.#resizeViewportSettleTimer = undefined;
+		}
+		this.#resizeViewportActive = false;
+		this.#clearPostFullPaintSettle();
+		this.#deferredForcedClearScrollback = false;
 		// Place the parent shell on the first line after the rendered content. When
 		// that line is still inside the viewport, moving there and writing `\r` is
 		// enough; emitting `\r\n` would create an extra blank row. If the content
 		// already reaches the viewport bottom, scroll exactly once so the prompt
 		// lands directly below the last visible TUI row.
-		if (this.#previousLines.length > 0) {
-			const targetRow = this.#previousLines.length;
-			const viewportBottom = this.#viewportTopRow + this.terminal.rows - 1;
-			const clampedCursorRow = Math.max(this.#viewportTopRow, Math.min(this.#hardwareCursorRow, viewportBottom));
+		if (this.#previousFrameLength > 0) {
+			const targetRow = this.#previousFrameLength;
+			const viewportBottom = this.#windowTopRow + this.terminal.rows - 1;
+			const clampedCursorRow = Math.max(this.#windowTopRow, Math.min(this.#hardwareCursorRow, viewportBottom));
 			const moveTargetRow = Math.min(targetRow, viewportBottom);
 			const lineDiff = moveTargetRow - clampedCursorRow;
 			if (lineDiff > 0) {
@@ -945,44 +1545,37 @@ export class TUI extends Container {
 		}
 
 		this.terminal.showCursor();
+		this.#forgetHardwareCursorState();
 		this.terminal.stop();
 	}
 
-	/**
-	 * Rebuild native terminal scrollback if live rendering deferred a history rewrite.
-	 * Callers should only invoke this at checkpoints where the user is expected to be
-	 * at the terminal bottom, such as after submitting a new prompt.
-	 */
-	refreshNativeScrollbackIfDirty(_options?: NativeScrollbackRefreshOptions): boolean {
-		if (!this.#nativeScrollbackDirty || this.#stopped) return false;
-		// Multiplexer panes preserve their own history and never receive a
-		// destructive clear, so a checkpoint "replay" cannot reconcile anything —
-		// it would only append a duplicate copy of the transcript to pane
-		// history. Drop the dirty flag; there is nothing actionable behind it.
-		if (isMultiplexerSession()) {
-			this.#clearNativeScrollbackDirty();
-			return false;
-		}
-		const nativeViewportAtBottom = this.#readNativeViewportAtBottom();
-		if (!this.#canReplayNativeScrollbackAtCheckpoint(nativeViewportAtBottom)) {
-			return false;
-		}
-		this.#prepareForcedRender(true, false);
-		this.#renderRequested = false;
-		this.#lastRenderAt = this.#renderScheduler.now();
-		this.#doRender();
-		return true;
-	}
-
 	/**
 	 * Force an immediate full replay of the current frame, including native
 	 * scrollback. This is the keyboard-accessible equivalent of the resize reset:
 	 * no queued diff frame or terminal scrollback probe can downgrade it to a
 	 * viewport-only repaint.
+	 *
+	 * Invalidates every component first so the replay reflects current state. A
+	 * geometry-driven reset thaws frozen scrollback snapshots implicitly (the new
+	 * width misses every cached snapshot), but a same-width reset would otherwise
+	 * replay stale snapshots — leaving host-frozen blocks (e.g. a transcript whose
+	 * committed rows are immutable on ED3-risk terminals) showing pre-mutation
+	 * content. Invalidation is the generic signal those containers use to retire
+	 * their snapshots, which is exactly what a user-driven display reset wants.
 	 */
 	resetDisplay(): void {
 		if (this.#stopped) return;
-		this.#prepareForcedRender(!isMultiplexerSession(), true);
+		this.invalidate();
+		// A reset that lands inside a tmux/screen/zellij resize burst would
+		// paint mid-reflow and re-introduce the flash race (issue #2088).
+		// Fold it into the in-flight debounce instead; the settled paint runs
+		// the same `#prepareForcedRender(!isMultiplexerSession())` path via
+		// `requestRender(true)`, so the clear-scrollback intent is preserved.
+		if (this.#multiplexerResizeTimer) {
+			this.#armMultiplexerResizeTimer(!isMultiplexerSession());
+			return;
+		}
+		this.#prepareForcedRender(!isMultiplexerSession());
 		this.#resizeEventPending = true;
 		this.#renderRequested = false;
 		this.#lastRenderAt = this.#renderScheduler.now();
@@ -990,10 +1583,28 @@ export class TUI extends Container {
 	}
 
 	requestRender(force = false, options?: RenderRequestOptions): void {
-		const allowUnknownViewportMutation = options?.allowUnknownViewportMutation === true;
-		this.#allowUnknownViewportMutationOnNextRender ||= allowUnknownViewportMutation;
+		// Any non-component-scoped request makes the pending frame a full one.
+		this.#pendingRenderComponentsOnly = false;
 		if (force) {
-			this.#prepareForcedRender(options?.clearScrollback === true, allowUnknownViewportMutation);
+			this.#resizeViewportPaintPending = false;
+			// Forced repaints landing inside the multiplexer resize debounce
+			// (e.g. `#finishSixelProbe`, image-budget eviction, a programmatic
+			// `requestRender(true)`) would paint into a still-reflowing pane
+			// and reintroduce the flash race. Fold them into the in-flight
+			// debounce while preserving the caller's `clearScrollback` intent
+			// for the settled paint. The timer's own callback clears
+			// `#multiplexerResizeTimer` before re-entering `requestRender(true)`,
+			// so this guard only catches external callers — the deferred render
+			// itself proceeds straight to `#prepareForcedRender`.
+			if (this.#multiplexerResizeTimer) {
+				this.#armMultiplexerResizeTimer(options?.clearScrollback === true);
+				return;
+			}
+			// A forced render preempts the post-full-paint ConPTY settle: it owns
+			// the next paint and is going to redraw the buffer anyway, so the
+			// trailing coalesced render queued by the settle would only race it.
+			this.#clearPostFullPaintSettle();
+			this.#prepareForcedRender(options?.clearScrollback === true);
 			this.#renderRequested = true;
 			this.#renderScheduler.scheduleImmediate(() => {
 				if (this.#stopped || !this.#renderRequested) {
@@ -1005,23 +1616,231 @@ export class TUI extends Container {
 			});
 			return;
 		}
+		this.#requestOrdinaryRender();
+	}
+
+	/**
+	 * Schedule a render on behalf of `component` after a self-contained change
+	 * (spinner frame, blink) that cannot have affected any other component.
+	 *
+	 * When every request since the last frame is component-scoped and the
+	 * frame is otherwise quiet — no resize or geometry change, no overlays, no
+	 * live inline images, no forced repaint, unchanged root child list — the
+	 * next compose re-renders only the root subtrees containing the requesting
+	 * components and reuses the previous frame's rows (and seam reports) for
+	 * every other root child, skipping the full component-tree walk that makes
+	 * long transcripts expensive to repaint at animation rate. Any concurrent
+	 * full request or unsafe condition downgrades the frame to a normal full
+	 * compose, so this is never less correct than `requestRender()` — only
+	 * cheaper.
+	 */
+	requestComponentRender(component: Component): void {
+		if (this.#stopped) return;
+		// Start a component-scoped accumulation only when nothing else is in
+		// flight (a pending throttled request or a deferred ConPTY settle
+		// replay may carry full-render intent that must not be narrowed).
+		if (!this.#renderRequested && this.#postFullPaintSettleTimer === undefined) {
+			this.#pendingRenderComponentsOnly = true;
+		}
+		this.#componentRenderTargets.add(component);
+		this.#requestOrdinaryRender();
+	}
+
+	/** Ordinary (non-forced) scheduling shared by full and component-scoped requests. */
+	#requestOrdinaryRender(): void {
+		// Coalesce non-forced renders inside the post-full-paint ConPTY settle
+		// window into one trailing render. Spinner/blink/streaming components
+		// otherwise fire `requestRender(false)` at 30 Hz while the host is still
+		// catching up with the previous big paint, and each follow-up viewport
+		// repaint nudges Windows Terminal's viewport tracker further off the
+		// last row (see #2095).
+		if (this.#postFullPaintSettleUntilMs > 0) {
+			const now = this.#renderScheduler.now();
+			if (now < this.#postFullPaintSettleUntilMs) {
+				if (this.#postFullPaintSettleTimer === undefined) {
+					this.#postFullPaintSettleTimer = this.#renderScheduler.scheduleRender(() => {
+						this.#postFullPaintSettleTimer = undefined;
+						this.#postFullPaintSettleUntilMs = 0;
+						if (this.#stopped) return;
+						this.#requestOrdinaryRender();
+					}, this.#postFullPaintSettleUntilMs - now);
+				}
+				return;
+			}
+			this.#postFullPaintSettleUntilMs = 0;
+		}
 		if (this.#renderRequested) return;
 		this.#renderRequested = true;
 		this.#renderScheduler.scheduleImmediate(() => this.#scheduleRender());
 	}
 
-	#prepareForcedRender(clearScrollback: boolean, _allowUnknownViewportMutation: boolean): void {
-		const geometryChanged =
-			(this.#previousWidth > 0 && this.#previousWidth !== this.terminal.columns) ||
-			(this.#previousHeight > 0 && this.#previousHeight !== this.terminal.rows);
-		// A geometry replay rewraps clearable native scrollback at the new size.
-		// Inside a multiplexer the pane reflows its own history and a replay only
-		// duplicates it, so never promote forced renders to sessionReplace there.
-		const replayGeometry =
-			geometryChanged &&
-			!isMultiplexerSession() &&
-			this.#canReplayNativeScrollbackAtCheckpoint(this.#readNativeViewportAtBottom());
-		this.#clearScrollbackOnNextRender ||= clearScrollback || replayGeometry;
+	/**
+	 * Decide whether this frame may compose component-scoped, and resolve the
+	 * requested components to the root children that must re-render. Returns
+	 * null — full compose — whenever a global condition could invalidate rows
+	 * the partial compose would reuse, or when a requested component is not
+	 * reachable from the current root child list.
+	 */
+	#resolvePartialComposeRoots(width: number, height: number): Set<Component> | null {
+		if (this.#componentRenderTargets.size === 0) return null;
+		if (!this.#hasEverRendered || this.#resizeEventPending) return null;
+		if (width !== this.#previousWidth || height !== this.#previousHeight || width !== this.#composeWidth) return null;
+		if (this.#clearScrollbackOnNextRender || this.#forceViewportRepaintOnNextRender) return null;
+		if (this.overlayStack.length > 0) return null;
+		// The image budget audits display order across the whole frame; a
+		// partial walk would under-count it. Engage only on image-free frames.
+		if (!this.#imageBudget.quiescent) return null;
+		// The root child list must match the segment ledger exactly — a
+		// structural change shifts offsets under every reused segment.
+		const children = this.children;
+		const segments = this.#frameSegments;
+		if (segments.length !== children.length) return null;
+		for (let i = 0; i < children.length; i++) {
+			if (segments[i]!.component !== children[i]) return null;
+		}
+		const roots = this.#partialComposeRootsScratch;
+		roots.clear();
+		for (const target of this.#componentRenderTargets) {
+			const root = this.#resolveComponentRoot(target);
+			if (root === null) return null;
+			roots.add(root);
+		}
+		return roots;
+	}
+
+	/** Root child whose subtree contains `target`, memoized per component. */
+	#resolveComponentRoot(target: Component): Component | null {
+		const cached = this.#componentRootCache.get(target);
+		if (cached !== undefined && this.children.includes(cached) && subtreeContains(cached, target)) {
+			return cached;
+		}
+		for (const child of this.children) {
+			if (subtreeContains(child, target)) {
+				this.#componentRootCache.set(target, child);
+				return child;
+			}
+		}
+		this.#componentRootCache.delete(target);
+		return null;
+	}
+
+	/**
+	 * Arm or extend the multiplexer-resize debounce so a single forced render
+	 * fires once the pane is quiet. Called by the SIGWINCH callback on every
+	 * resize event, and by `requestRender(true)` / `resetDisplay()` when they
+	 * land inside an in-flight settle window. Each call cancels the prior
+	 * timer, supersedes any queued throttled render (otherwise it would race
+	 * tmux's mid-reflow paint), and OR's the caller's `clearScrollback`
+	 * intent into `#deferredForcedClearScrollback` — the timer's callback
+	 * consumes that flag exactly once when it re-enters `requestRender(true)`.
+	 */
+	#armMultiplexerResizeTimer(clearScrollback: boolean): void {
+		this.#deferredForcedClearScrollback ||= clearScrollback;
+		if (this.#renderTimer) {
+			this.#renderTimer.cancel();
+			this.#renderTimer = undefined;
+		}
+		this.#renderRequested = false;
+		if (this.#multiplexerResizeTimer) {
+			this.#multiplexerResizeTimer.cancel();
+		}
+		this.#multiplexerResizeTimer = this.#renderScheduler.scheduleRender(() => {
+			this.#multiplexerResizeTimer = undefined;
+			if (this.#stopped) {
+				this.#deferredForcedClearScrollback = false;
+				return;
+			}
+			const deferredClearScrollback = this.#deferredForcedClearScrollback;
+			this.#deferredForcedClearScrollback = false;
+			this.requestRender(true, { clearScrollback: deferredClearScrollback });
+		}, TUI.#MULTIPLEXER_RESIZE_DEBOUNCE_MS);
+	}
+
+	/**
+	 * Arm the post-full-paint settle window after an `#emitFullPaint` that
+	 * pushed content into native scrollback on a ConPTY host. Idempotent inside
+	 * the window: a later overflowing paint extends `until` to the later
+	 * deadline so back-to-back big paints do not double-fire the trailing
+	 * coalesced render, and the existing deferred timer is rescheduled to the
+	 * later deadline.
+	 *
+	 * Mid-composition callers (most notably `ImageBudget.endPass()`, which can
+	 * call `requestRender()` from inside the in-flight paint when a new image
+	 * trips the budget) queue their render *before* the settle exists, so they
+	 * fall through the gate and set `#renderRequested` / `#renderTimer` on the
+	 * 30 Hz throttle. Without absorbing those, the throttled follow-up fires
+	 * inside the 150 ms quiet window and reintroduces the cascade the settle
+	 * was meant to stop. Cancel both, then eagerly arm the trailing settle
+	 * timer so the in-flight request still rides one coalesced render at the
+	 * end of the window. See #2095.
+	 */
+	#armPostFullPaintSettle(): void {
+		if (!isConPTYHosted()) return;
+		const until = this.#renderScheduler.now() + TUI.#CONPTY_POST_FULL_PAINT_SETTLE_MS;
+		if (until <= this.#postFullPaintSettleUntilMs) return;
+		this.#postFullPaintSettleUntilMs = until;
+		const hadPendingRender = this.#renderRequested || this.#renderTimer !== undefined;
+		// Reclaim any render that was queued during the in-flight composition:
+		// `#renderRequested` was set before the settle existed and would
+		// otherwise fire on the standard throttle inside the window.
+		this.#renderRequested = false;
+		if (this.#renderTimer) {
+			this.#renderTimer.cancel();
+			this.#renderTimer = undefined;
+		}
+		if (this.#postFullPaintSettleTimer) {
+			this.#postFullPaintSettleTimer.cancel();
+			this.#postFullPaintSettleTimer = undefined;
+		}
+		if (hadPendingRender) {
+			// Replay the absorbed request via the trailing settle timer so the
+			// caller's render still happens — just deferred to the end of the
+			// window. Subsequent `requestRender(false)` calls during the
+			// settle see this timer and fold into it (existing gate at L1263).
+			this.#postFullPaintSettleTimer = this.#renderScheduler.scheduleRender(() => {
+				this.#postFullPaintSettleTimer = undefined;
+				this.#postFullPaintSettleUntilMs = 0;
+				if (this.#stopped) return;
+				this.#requestOrdinaryRender();
+			}, TUI.#CONPTY_POST_FULL_PAINT_SETTLE_MS);
+		}
+	}
+
+	#clearPostFullPaintSettle(): void {
+		if (this.#postFullPaintSettleTimer) {
+			this.#postFullPaintSettleTimer.cancel();
+			this.#postFullPaintSettleTimer = undefined;
+		}
+		this.#postFullPaintSettleUntilMs = 0;
+	}
+
+	#maybeDeferGhosttyInitialImagePaint(): boolean {
+		if (this.#ghosttyInitialImageDelayDone) return false;
+		if (TERMINAL.id !== "ghostty" || TERMINAL.imageProtocol !== ImageProtocol.Kitty) {
+			this.#ghosttyInitialImageDelayDone = true;
+			return false;
+		}
+		if (!this.#imageBudget.hasPendingTransmits()) return false;
+		if (this.#ghosttyInitialImageDelayTimer) return true;
+
+		const delayMs = Math.max(0, this.#ghosttyImageReadyAtMs - this.#renderScheduler.now());
+		if (delayMs === 0) {
+			this.#ghosttyInitialImageDelayDone = true;
+			return false;
+		}
+
+		this.#ghosttyInitialImageDelayTimer = this.#renderScheduler.scheduleRender(() => {
+			this.#ghosttyInitialImageDelayTimer = undefined;
+			this.#ghosttyInitialImageDelayDone = true;
+			if (this.#stopped) return;
+			this.#lastRenderAt = this.#renderScheduler.now();
+			this.#doRender();
+			if (this.#renderRequested) this.#scheduleRender();
+		}, delayMs);
+		return true;
+	}
+	#prepareForcedRender(clearScrollback: boolean): void {
+		this.#clearScrollbackOnNextRender ||= clearScrollback;
 		this.#forceViewportRepaintOnNextRender = true;
 		if (this.#renderTimer) {
 			this.#renderTimer.cancel();
@@ -1033,6 +1852,13 @@ export class TUI extends Container {
 		if (this.#stopped || this.#renderTimer || !this.#renderRequested) {
 			return;
 		}
+		// Defer any new throttled render scheduled inside the multiplexer
+		// resize settle window: it would race tmux's mid-reflow pane repaint.
+		// `#renderRequested` stays set so the eventual forced render — armed
+		// by the SIGWINCH callback — picks up the latest component state.
+		if (this.#multiplexerResizeTimer) {
+			return;
+		}
 		const elapsed = this.#renderScheduler.now() - this.#lastRenderAt;
 		const delay = Math.max(0, TUI.#MIN_RENDER_INTERVAL_MS - elapsed);
 		this.#renderTimer = this.#renderScheduler.scheduleRender(() => {
@@ -1100,7 +1926,7 @@ export class TUI extends Container {
 				return;
 			}
 			this.#focusedComponent.handleInput(data);
-			this.requestRender(false, { allowUnknownViewportMutation: true });
+			this.requestRender();
 		}
 	}
 
@@ -1133,7 +1959,7 @@ export class TUI extends Container {
 		overlayHeight: number,
 		termWidth: number,
 		termHeight: number,
-	): { width: number; row: number; col: number; maxHeight: number | undefined } {
+	): { width: number; row: number; col: number; maxHeight: number } {
 		const opt = options ?? {};
 
 		// Parse margin (clamp to non-negative)
@@ -1160,14 +1986,12 @@ export class TUI extends Container {
 		width = Math.max(1, Math.min(width, availWidth));
 
 		// === Resolve maxHeight ===
-		let maxHeight = parseSizeValue(opt.maxHeight, termHeight);
-		// Clamp to available space
-		if (maxHeight !== undefined) {
-			maxHeight = Math.max(1, Math.min(maxHeight, availHeight));
-		}
+		let maxHeight = parseSizeValue(opt.maxHeight, termHeight) ?? availHeight;
+		maxHeight = Math.max(1, Math.min(maxHeight, availHeight));
 
-		// Effective overlay height (may be clamped by maxHeight)
-		const effectiveHeight = maxHeight !== undefined ? Math.min(overlayHeight, maxHeight) : overlayHeight;
+		// Effective overlay height: maxHeight is always resolved (defaults to
+		// availHeight above), so the overlay is unconditionally clamped to fit.
+		const effectiveHeight = Math.min(overlayHeight, maxHeight);
 
 		// === Resolve position ===
 		let row: number;
@@ -1262,83 +2086,34 @@ export class TUI extends Container {
 		}
 	}
 
-	/** Composite all overlays into content lines (in stack order, later = on top). */
-	#compositeOverlays(lines: string[], termWidth: number, termHeight: number): string[] {
-		if (this.overlayStack.length === 0) return lines;
-		const result = [...lines];
-
-		// Pre-render all visible overlays and calculate positions
-		const rendered: { overlayLines: string[]; row: number; col: number; w: number }[] = [];
-		let minLinesNeeded = result.length;
-
+	/**
+	 * Composite all visible overlays into the window slice (screen
+	 * coordinates, in stack order, later = on top). Overlays never touch the
+	 * frame: composited rows exist only in the painted window, and commits are
+	 * frozen while an overlay is visible, so overlay pixels can never enter
+	 * native scrollback.
+	 */
+	#compositeOverlaysIntoWindow(window: string[], termWidth: number, termHeight: number): string[] {
+		const result = [...window];
 		for (const entry of this.overlayStack) {
-			// Skip invisible overlays (hidden or visible() returns false)
 			if (!this.#isOverlayVisible(entry)) continue;
-
 			const { component, options } = entry;
-
 			// Get layout with height=0 first to determine width and maxHeight
-			// (width and maxHeight don't depend on overlay height)
+			// (width and maxHeight don't depend on overlay height).
 			const { width, maxHeight } = this.#resolveOverlayLayout(options, 0, termWidth, termHeight);
-
-			// Render component at calculated width
 			let overlayLines = component.render(width);
-
-			// Apply maxHeight if specified
-			if (maxHeight !== undefined && overlayLines.length > maxHeight) {
+			if (overlayLines.length > maxHeight) {
 				overlayLines = overlayLines.slice(0, maxHeight);
 			}
-
-			// Get final row/col with actual overlay height
 			const { row, col } = this.#resolveOverlayLayout(options, overlayLines.length, termWidth, termHeight);
-
-			rendered.push({ overlayLines, row, col, w: width });
-			minLinesNeeded = Math.max(minLinesNeeded, row + overlayLines.length);
-		}
-
-		// Ensure result is tall enough for overlay placement.
-		// NOTE: Do not pad to maxLinesRendered.
-		// maxLinesRendered tracks the terminal "working area" (max lines ever rendered) and can be much larger
-		// than the current content. Padding to it can cause the renderer to output hundreds/thousands of blank
-		// lines, effectively scrolling the terminal when an overlay is shown.
-		const workingHeight = Math.max(result.length, minLinesNeeded);
-
-		// Extend result with empty lines if content is too short for overlay placement
-		while (result.length < workingHeight) {
-			result.push("");
-		}
-
-		const viewportStart = Math.max(0, workingHeight - termHeight);
-
-		// Track which lines were modified for final verification
-		const modifiedLines = new Set<number>();
-
-		// Composite each overlay
-		for (const { overlayLines, row, col, w } of rendered) {
 			for (let i = 0; i < overlayLines.length; i++) {
-				const idx = viewportStart + row + i;
-				if (idx >= 0 && idx < result.length) {
-					// Defensive: truncate overlay line to declared width before compositing
-					// (components should already respect width, but this ensures it)
-					const truncatedOverlayLine =
-						visibleWidth(overlayLines[i]) > w ? sliceByColumn(overlayLines[i], 0, w, true) : overlayLines[i];
-					result[idx] = this.#compositeLineAt(result[idx], truncatedOverlayLine, col, w, termWidth);
-					modifiedLines.add(idx);
-				}
-			}
-		}
-
-		// Final verification: ensure no composited line exceeds terminal width
-		// This is a belt-and-suspenders safeguard - compositeLineAt should already
-		// guarantee this, but we verify here to prevent crashes from any edge cases
-		// Only check lines that were actually modified (optimization)
-		for (const idx of modifiedLines) {
-			const lineWidth = visibleWidth(result[idx]);
-			if (lineWidth > termWidth) {
-				result[idx] = sliceByColumn(result[idx], 0, termWidth, true);
+				const idx = row + i;
+				if (idx < 0 || idx >= result.length) continue;
+				const truncatedOverlayLine =
+					visibleWidth(overlayLines[i]) > width ? sliceByColumn(overlayLines[i], 0, width, true) : overlayLines[i];
+				result[idx] = this.#compositeLineAt(result[idx], truncatedOverlayLine, col, width, termWidth);
 			}
 		}
-
 		return result;
 	}
 
@@ -1394,27 +2169,20 @@ export class TUI extends Container {
 	}
 
 	/**
-	 * Find and extract cursor position from rendered lines.
-	 * Searches for CURSOR_MARKER, calculates its position, and strips it from the output.
-	 * Only scans the bottom terminal height lines (visible viewport).
-	 * @param lines - Rendered lines to search
-	 * @param height - Terminal height (visible viewport size)
-	 * @returns Cursor position { row, col } or null if no marker found
+	 * Strip every CURSOR_MARKER from the rendered lines (markers are internal
+	 * sentinels and must never reach the terminal, the committed prefix, or
+	 * the resync audit) and return the positions of the stripped markers,
+	 * bottom-most first. Callers pick the visible one once the window top is
+	 * known.
 	 */
-	#extractCursorPosition(lines: string[], height: number): { row: number; col: number } | null {
-		// Cursor markers are internal sentinels and must never reach the terminal,
-		// even when the focused component is above the visible viewport. Only a
-		// visible marker becomes a hardware cursor target.
-		const viewportTop = Math.max(0, lines.length - height);
-		let cursor: { row: number; col: number } | null = null;
+	#extractCursorMarkers(lines: string[]): { row: number; col: number }[] {
+		const markers: { row: number; col: number }[] = [];
 		for (let row = lines.length - 1; row >= 0; row--) {
 			const line = lines[row];
 			let markerIndex = line.indexOf(CURSOR_MARKER);
 			if (markerIndex === -1) continue;
-			if (cursor === null && row >= viewportTop) {
-				const beforeMarker = line.slice(0, markerIndex);
-				cursor = { row, col: visibleWidth(beforeMarker) };
-			}
+			const beforeMarker = line.slice(0, markerIndex);
+			markers.push({ row, col: visibleWidth(beforeMarker) });
 			let stripped = line;
 			while (markerIndex !== -1) {
 				stripped = stripped.slice(0, markerIndex) + stripped.slice(markerIndex + CURSOR_MARKER.length);
@@ -1422,1521 +2190,1119 @@ export class TUI extends Container {
 			}
 			lines[row] = stripped;
 		}
-		return cursor;
+		return markers;
 	}
 
-	/**
-	 * Append the per-line terminator ({@link LINE_TERMINATOR}) to every
-	 * non-image line and normalize for terminal rendering. Mutates the input
-	 * array in place so downstream diffing/storage sees exactly the bytes
-	 * written to the terminal — without this, the diff cache disagrees with
-	 * emitted output and OSC 8 hyperlink state can leak across lines.
-	 */
-	#applyLineResets(lines: string[]): string[] {
-		for (let i = 0; i < lines.length; i++) {
-			const line = lines[i];
-			if (TERMINAL.isImageLine(line)) continue;
-			const normalized = normalizeTerminalOutput(line);
-			// Only close OSC 8 hyperlinks when the line actually opened one;
-			// emitting `\x1b]8;;\x07` on every line just feeds the terminal's OSC
-			// parser for no reason (measurable cost in xterm.js parse loop).
-			lines[i] = normalized + (normalized.includes("\x1b]8;") ? LINE_TERMINATOR : SEGMENT_RESET);
-		}
-		return lines;
+	#terminalLine(line: string): string {
+		if (TERMINAL.isImageLine(line)) return line;
+		return line + (line.includes("\x1b]8;") ? LINE_TERMINATOR : SEGMENT_RESET);
 	}
 
 	/**
-	 * Render one frame. Composes the frame, classifies the intent, and delegates
-	 * to the matching emitter. Each emitter owns its bytes and ends with
-	 * {@link #commit}, the single state-transition point.
+	 * Render one frame.
+	 *
+	 * Append-only pipeline: compose the frame, derive the commit boundary from
+	 * the component-reported live-region seam, advance the committed-row count
+	 * monotonically, and emit either a gesture-driven full paint or an
+	 * incremental update. Scrollback is `frame[0..committedRows)` at all
+	 * times — no viewport probes, no deferred reconciliation.
 	 */
 	#doRender(): void {
 		if (this.#stopped) return;
 		const width = this.terminal.columns;
 		const height = this.terminal.rows;
 
-		// 1. Compose the frame. Bracket the transcript render so the image budget
-		// observes every inline image in display order (overlays carry none).
-		this.#imageBudget.beginPass();
-		let baseLines = this.render(width);
-		if (this.#imageBudget.endPass()) {
-			// A new image pushed the live-graphics count past the cap: force a full
-			// redraw (so off-screen rows repaint as text) and purge the demoted
-			// images' graphics in #emitFullPaint.
-			this.#clearScrollbackOnNextRender = true;
-		}
-		const visibleOverlayComponents: Component[] = [];
-		if (this.overlayStack.length > 0 || this.#previousVisibleOverlayComponents.length > 0) {
-			for (const entry of this.overlayStack) {
-				if (this.#isOverlayVisible(entry)) visibleOverlayComponents.push(entry.component);
+		// Consume the component-scoped accumulation: it describes the render
+		// requests made up to this frame, whichever path the frame takes.
+		const componentScopedOnly = this.#pendingRenderComponentsOnly;
+		this.#pendingRenderComponentsOnly = false;
+
+		// Fullscreen alt-screen short-circuit. While the topmost visible overlay
+		// requests it, borrow the terminal's alternate buffer and paint only the
+		// modal there; the normal screen and all accounting stay untouched.
+		const wantAlt = this.#wantsAltScreen();
+		if (wantAlt && !this.#altActive) {
+			// Kitty keyboard flags are per-screen: re-push our level on the freshly
+			// entered alternate screen, or Esc/modified keys revert to legacy
+			// encoding inside fullscreen overlays (Ghostty/kitty). See kitty
+			// keyboard-protocol docs: the mode stack is separate per screen.
+			this.terminal.write(`\x1b[?1049h${this.terminal.kittyEnableSequence ?? ""}${MOUSE_TRACKING_ON}`);
+			setAltScreenActive(true);
+			this.terminal.hideCursor();
+			this.#forgetHardwareCursorState();
+			this.#recordHardwareCursorHidden();
+			this.#altActive = true;
+			this.#altPreviousLines = [];
+			this.#altEnterWidth = width;
+			this.#altEnterHeight = height;
+		} else if (!wantAlt && this.#altActive) {
+			const kittyPop = this.terminal.kittyEnableSequence ? "\x1b[<u" : "";
+			this.terminal.write(`${MOUSE_TRACKING_OFF}${kittyPop}\x1b[?1049l`);
+			setAltScreenActive(false);
+			this.#forgetHardwareCursorState();
+			this.#altActive = false;
+			this.#altPreviousLines = [];
+			// A resize while on the alt buffer reflowed the terminal's saved
+			// normal screen; it no longer matches our accounting, so force the
+			// geometry rebuild path instead of a stale diff.
+			if (width !== this.#altEnterWidth || height !== this.#altEnterHeight) {
+				this.#resizeEventPending = true;
 			}
 		}
-		this.#visibleOverlayComponentsThisRender = visibleOverlayComponents;
-		const overlayVisibilityReduced = this.#overlayVisibilityReduced(visibleOverlayComponents);
-		let lines = visibleOverlayComponents.length > 0 ? this.#compositeOverlays(baseLines, width, height) : baseLines;
-		const cursorPos = this.#extractCursorPosition(lines, height);
-		lines = this.#fitLinesToWidth(this.#applyLineResets(lines), width);
-		if (lines !== baseLines) {
-			this.#extractCursorPosition(baseLines, height);
-			baseLines = this.#fitLinesToWidth(this.#applyLineResets(baseLines), width);
+		if (this.#altActive) {
+			this.#componentRenderTargets.clear();
+			this.#renderAltFrame(width, height);
+			return;
 		}
 
-		// 2. Capture transition + pre-render state before any emitter runs.
-		const prevViewportTop = this.#viewportTopRow;
+		// Resize viewport fast path. While a non-multiplexer drag is in flight,
+		// paint only the viewport and skip composing the off-screen history.
+		// Strictly state-isolated: it never consumes #resizeEventPending nor
+		// advances any commit/window/diff field, so the authoritative full paint
+		// the settle timer queues reconciles as if these throwaway frames never
+		// ran. A visible overlay composites over the transcript and needs the
+		// whole window, so fall through to the normal forced paint when one is up
+		// (overlay resizes are not on the drag-cost hot path).
+		if (
+			this.#resizeViewportPaintPending &&
+			this.#resizeViewportActive &&
+			this.#hasEverRendered &&
+			this.#getTopmostVisibleOverlay() === undefined
+		) {
+			this.#resizeViewportPaintPending = false;
+			this.#componentRenderTargets.clear();
+			this.#renderResizeViewport(width, height);
+			return;
+		}
+
+		// 1. Compose the frame. Bracket the render so the image budget observes
+		// every inline image in display order (overlays carry none). A
+		// component-scoped frame skips the budget pass instead — it is gated on
+		// a quiescent budget, and a partial tree walk would under-count display
+		// order — and re-renders only the requested root subtrees, reusing the
+		// previous segment of every other root child.
+		const partialRoots = componentScopedOnly ? this.#resolvePartialComposeRoots(width, height) : null;
+		this.#componentRenderTargets.clear();
+		let rawFrame: readonly string[];
+		if (partialRoots !== null) {
+			this.#partialComposeRoots = partialRoots;
+			try {
+				rawFrame = this.render(width);
+			} finally {
+				this.#partialComposeRoots = null;
+			}
+		} else {
+			this.#imageBudget.beginPass();
+			rawFrame = this.render(width);
+			this.#imageBudget.endPass();
+		}
+		// Ghostty initial-image deferral must run before any render state is
+		// consumed (#resizeEventPending, hardware-cursor state, commit
+		// re-anchoring): the early return abandons this frame and the deferred
+		// render recomposes from scratch, so consuming state here would
+		// misclassify a pending resize as an ordinary diff and corrupt the paint.
+		if (this.#maybeDeferGhosttyInitialImagePaint()) return;
+		// Cursor markers were stripped at compose time (they are internal
+		// sentinels and must never reach the terminal, the committed prefix, or
+		// the audit); the visible marker is chosen after the window top is
+		// known. Ascending by frame row.
+		const cursorMarkers = this.#frameCursorMarkers;
+		const liveRegionStart = this.#nativeScrollbackLiveRegionStart;
+		const commitSafeEnd = this.#nativeScrollbackCommitSafeEnd;
+		const snapshotSafeEnd = this.#nativeScrollbackSnapshotSafeEnd;
+
+		// 2. Transition state captured before any emitter runs.
+		const prevWindowTop = this.#windowTopRow;
 		const prevHardwareCursorRow = this.#hardwareCursorRow;
 		const resizeEventOccurred = this.#resizeEventPending;
 		this.#resizeEventPending = false;
+		if (resizeEventOccurred) this.#forgetHardwareCursorState();
 		const widthChanged = this.#previousWidth > 0 && this.#previousWidth !== width;
-		// A resize event with net-unchanged dimensions still reflowed the terminal
-		// buffer; classify it as a height change so the geometry branches repaint
-		// or rebuild instead of diffing against a screen that no longer exists.
+		// A resize event with net-unchanged dimensions still reflowed the
+		// terminal buffer; classify it as a height change so geometry handling
+		// repaints instead of diffing against a screen that no longer exists.
 		const heightChanged =
 			(this.#previousHeight > 0 && this.#previousHeight !== height) ||
 			(resizeEventOccurred && this.#previousHeight > 0);
-		const eagerEraseScrollbackRisk = this.#hasEagerEraseScrollbackRisk();
-		const eagerRebuildAllowed = this.#eagerNativeScrollbackRebuild && !eagerEraseScrollbackRisk;
-		const explicitViewportMutation = this.#allowUnknownViewportMutationOnNextRender;
-		const allowUnknownViewportMutation = explicitViewportMutation || eagerRebuildAllowed;
-		this.#allowUnknownViewportMutationOnNextRender = false;
-
-		// 3. Classify intent.
-		let intent = this.#planRender(
-			lines,
-			widthChanged,
-			heightChanged,
-			prevViewportTop,
-			height,
-			visibleOverlayComponents.length > 0,
-			overlayVisibilityReduced,
-			allowUnknownViewportMutation,
-			this.#nativeScrollbackLiveRegionStart,
-			this.#nativeScrollbackCommitSafeEnd,
+		const geometryChanged = widthChanged || heightChanged;
+
+		// Committed-prefix audit: rows below the commit index are physically in
+		// terminal history and must never re-layout. When a component violates
+		// that — a budget-demoted image collapsing to its one-line fallback, a
+		// TTSR rewind truncating a block whose sealed prefix already committed —
+		// keeping the old index would silently skip that many rows of
+		// everything below (content loss). Re-anchor at the divergence instead:
+		// the stale copy stays in history and rows recommit from there —
+		// duplication, never loss. Skipped on geometry frames (a rewrap
+		// legitimately reflows every row; the mux branch re-bases the prefix
+		// and non-mux geometry replays from scratch), and skipped when the
+		// composed frame's stable prefix covers every committed row — bytes
+		// that provably did not change since the last (aligned) frame cannot
+		// have diverged.
+		let committedRowsResynced = false;
+		if (
+			this.#hasEverRendered &&
+			!geometryChanged &&
+			!this.#clearScrollbackOnNextRender &&
+			this.#renderStablePrefixRows < this.#committedPrefixAuditRows
+		) {
+			const committedRowsBeforeAudit = this.#committedRows;
+			this.#auditCommittedPrefix(rawFrame);
+			committedRowsResynced = this.#committedRows !== committedRowsBeforeAudit;
+		}
+		// Committed-prefix state this frame's commit math extends from (post-audit).
+		// Drives the byte-stable audit-rows cap recomputed after the emit.
+		const preCommitRows = this.#committedRows;
+		const preCommitAuditRows = this.#committedPrefixAuditRows;
+
+		// 3. Window and commit math (lengths only; content prepared below).
+		const frameLength = rawFrame.length;
+		let hasVisibleOverlay = false;
+		for (const entry of this.overlayStack) {
+			if (this.#isOverlayVisible(entry)) {
+				hasVisibleOverlay = true;
+				break;
+			}
+		}
+		// Two commit boundaries. byteStableBoundary: rows below it are byte-stable
+		// (asserted never to re-layout) and stay under the committed-prefix audit.
+		// durableBoundary: rows below it are durable — their scroll-off snapshot is
+		// permanent (dropping them is forbidden) but may still drift afterward, so
+		// they commit audit-EXEMPT. Both build on the finalized prefix (live-region
+		// start); the whole frame when the root reports no seam (shell semantics:
+		// whatever scrolls is final).
+		const byteStableBoundary = Math.max(0, Math.min(frameLength, commitSafeEnd ?? liveRegionStart ?? frameLength));
+		const durableBoundary = Math.max(
+			byteStableBoundary,
+			Math.min(frameLength, snapshotSafeEnd ?? byteStableBoundary),
 		);
-		// 3b. Defer scrollback commits during foreground streaming, but only on
-		// ED3-risk terminals whose committed scrollback cannot be rewritten without
-		// yanking a scrolled reader. There the eager rebuild is gated off and the
-		// diff emitter would otherwise `\r\n`-scroll every transient frame (spinner
-		// ticks, partial output) into native history. Non-ED3-risk terminals keep
-		// their eager live rebuild, which already commits cleanly. Explicit
-		// reconciles — the prompt-submit checkpoint (`clearScrollbackOnNextRender`),
-		// user-input/IME opt-ins (`explicitViewportMutation`), and overlay visibility
-		// reductions that must scrub transient overlay cells from native history —
-		// are never deferred: the triggering interaction pins the host to the bottom.
-		const streamingWasActive = this.#eagerNativeScrollbackRebuild;
-		if (streamingWasActive && !this.#previousStreamingActive) {
-			this.#streamingHighWater = 0;
-		}
-		this.#previousStreamingActive = streamingWasActive;
-		if (streamingWasActive && eagerEraseScrollbackRisk) {
-			const streamingActive =
-				this.#eagerNativeScrollbackRebuild && !this.#eagerNativeScrollbackRebuildDisablePending;
-			// A terminal resize reflowed native scrollback at the OLD geometry, so the
-			// saved rows are already mis-wrapped garbage. The planned historyRebuild
-			// must stand and erase them (ED 3) — capping to a viewport repaint would
-			// leave the corrupt history on screen. Like the other reconciles, a resize
-			// is an explicit user action that snaps the host to the bottom, so there is
-			// no scrolled reader to yank.
-			const geometryChanged = widthChanged || heightChanged;
-			const explicitReconcile =
-				explicitViewportMutation ||
-				this.#clearScrollbackOnNextRender ||
-				overlayVisibilityReduced ||
-				geometryChanged;
-			// The defer below exists only to avoid `\r\n`-scrolling transient frames
-			// past a reader parked in native scrollback. When the terminal can report
-			// that the viewport is at the tail, there is no scrolled reader to yank,
-			// so the planned intent must stand and commit normally — otherwise a row
-			// that scrolls above the viewport top is dropped (neither pushed to
-			// history nor kept in the capped viewport). Production POSIX ED3-risk
-			// terminals cannot report this and stay `undefined`, so they still defer.
-			const nativeViewportAtBottom = this.#readNativeViewportAtBottom();
-			if (!streamingActive) {
-				// Streaming just ended. Keep native scrollback dirty so the next
-				// checkpoint reconciles the settled transcript; never erase here.
-				this.#streamingHighWater = 0;
-				this.#markNativeScrollbackDirty();
-			} else if (
-				!explicitReconcile &&
-				nativeViewportAtBottom !== true &&
-				!isMultiplexerSession() &&
-				(intent.kind === "sessionReplace" ||
-					intent.kind === "historyRebuild" ||
-					intent.kind === "overlayRebuild" ||
-					(intent.kind === "diff" && intent.appendedLines))
-			) {
-				// Cap the frame to the viewport and keep scrollback dirty: transient
-				// rows never enter history, and the checkpoint reconciles later.
-				// Multiplexers (tmux/screen/zellij) are excluded: their checkpoint
-				// reconcile is a no-op (pane history cannot be erased), so any rows
-				// dropped here are dropped forever. Pane history is append-only
-				// anyway, so a normal diff/append `\r\n` commit is exactly what the
-				// multiplexer needs — and the `liveRegionPinned` planner above
-				// keeps the actively-mutating live tail out of pane history while
-				// committing only the sealed prefix (issue #1974).
-				this.#markNativeScrollbackDirty();
-				this.#streamingHighWater = Math.max(this.#streamingHighWater, lines.length);
-				this.#scrollbackHighWater = 0;
-				lines = lines.slice(-height);
-				intent = { kind: "viewportRepaint" };
-			} else {
-				// Explicit reconcile or a non-committing frame (noop): let the
-				// planned intent stand, but keep tracking the streaming peak.
-				this.#streamingHighWater = Math.max(this.#streamingHighWater, lines.length);
+
+		// 4. Classify. A resize is an explicit user gesture: outside a
+		// multiplexer it erases and replays so history rewraps at the new
+		// geometry (the reader snapped to the bottom just dragged the window);
+		// inside one the pane reflows its own history, so repaint in place.
+		const firstPaint = !this.#hasEverRendered;
+		const replaceRequested = this.#clearScrollbackOnNextRender;
+		const geometryRebuild = geometryChanged && !isMultiplexerSession();
+		const fullPaint = firstPaint || replaceRequested || geometryRebuild;
+		let windowTop: number;
+		let chunkTo: number;
+		let committedPrefixResliced = false;
+		if (fullPaint) {
+			committedPrefixResliced = true;
+			windowTop = Math.max(0, frameLength - height);
+			chunkTo = Math.min(durableBoundary, windowTop);
+		} else if (
+			frameLength <= this.#committedRows ||
+			(committedRowsResynced &&
+				frameLength - this.#committedRows < height &&
+				cursorMarkers.some(marker => marker.row >= this.#committedRows))
+		) {
+			// Either the frame shrank into the committed prefix, or a
+			// committed-prefix resync left a focused cursor tail shorter than the
+			// viewport. The latter happens when a streaming/live block had an
+			// append-only prefix committed, then collapses on abort/finalize:
+			// the audit re-anchors #committedRows at the first divergent row, but
+			// flooring windowTop there would pin the editor near the top and
+			// leave blank rows underneath. Re-show the frame tail instead. The
+			// stale committed copy stays in native history; duplicating a few rows
+			// is preferable to a live editor gap and matches the existing
+			// "duplication, never loss" resync contract.
+			windowTop = Math.max(0, frameLength - height);
+			chunkTo = Math.min(durableBoundary, windowTop);
+			committedPrefixResliced = true;
+			this.#committedRows = chunkTo;
+			this.#committedPrefix = rawFrame.slice(0, chunkTo);
+		} else {
+			// Re-anchor to the frame tail, floored at the committed boundary: a
+			// shrink (or overlay close) pulls the window back down, but never
+			// onto rows already in native history — re-showing those on the
+			// grid would duplicate them for a scrolling reader. On a
+			// multiplexer resize the pane reflowed its own history; committed
+			// rows keep their old wrap there, same as any shell output.
+			windowTop = Math.max(this.#committedRows, frameLength - height, 0);
+			// Overlays freeze commits: composited rows must never enter
+			// history, and the hidden gap backfills via the chunk once the
+			// overlay closes. A multiplexer resize also commits nothing — the
+			// pane keeps its own (old-wrap) history — and re-bases the audit
+			// prefix at the new width so the accepted wrap drift does not read
+			// as a violation on the next ordinary frame.
+			chunkTo =
+				hasVisibleOverlay || geometryChanged
+					? this.#committedRows
+					: Math.max(this.#committedRows, Math.min(durableBoundary, windowTop));
+			if (geometryChanged) {
+				committedPrefixResliced = true;
+				this.#committedPrefix = rawFrame.slice(0, this.#committedRows);
 			}
 		}
-		if (this.#eagerNativeScrollbackRebuildDisablePending) {
-			this.#eagerNativeScrollbackRebuildDisablePending = false;
-			this.#eagerNativeScrollbackRebuild = false;
+
+		// 5. Pick the visible cursor marker (bottom-most at or below the window
+		// top), prepare lines, and build the visible window slice.
+		let cursorPos: { row: number; col: number } | null = null;
+		for (let i = cursorMarkers.length - 1; i >= 0; i--) {
+			const marker = cursorMarkers[i]!;
+			if (marker.row >= windowTop) {
+				cursorPos = marker;
+				break;
+			}
+		}
+		const frame = this.#prepareFrame(rawFrame, width);
+		let window: string[] = new Array(height);
+		for (let r = 0; r < height; r++) window[r] = frame[windowTop + r] ?? "";
+		if (hasVisibleOverlay) {
+			window = this.#compositeOverlaysIntoWindow(window, width, height);
+			const overlayMarkers = this.#extractCursorMarkers(window);
+			if (overlayMarkers.length > 0) {
+				cursorPos = { row: windowTop + overlayMarkers[0]!.row, col: overlayMarkers[0]!.col };
+			}
+			window = this.#prepareLinesArray(window, width);
 		}
-		this.#logRedraw(intent, lines.length, height);
-		// Load any newly-displayed image data into the terminal once, before this
-		// frame's placements (and any emitter) reference it. Data persists across
-		// paints, so subsequent frames re-emit only the tiny placement sequence.
-		// `a=t` produces no display, so writing it ahead of the synchronized paint
-		// is artifact-free.
+
+		const intent: RenderIntent = fullPaint
+			? { kind: "fullPaint", clearScrollback: replaceRequested || geometryRebuild ? !isMultiplexerSession() : false }
+			: { kind: "update", chunkTo, windowTop };
+		this.#logRedraw(intent, frameLength, height);
+
+		// Load newly-displayed image data once, before this frame's placements
+		// (and any emitter) reference it. `a=t` produces no display, so writing
+		// it ahead of the synchronized paint is artifact-free.
 		const imageTransmits = this.#imageBudget.takeTransmits();
 		if (imageTransmits.length > 0) {
 			let transmitBuffer = "";
 			for (const seq of imageTransmits) transmitBuffer += seq;
 			this.terminal.write(transmitBuffer);
 		}
-		// 4. Execute.
-		switch (intent.kind) {
-			case "noop":
-				this.#writeCursorPosition(cursorPos, lines.length);
-				this.#viewportTopRow = Math.max(0, this.#maxLinesRendered - height);
-				this.#previousWidth = width;
-				this.#previousHeight = height;
-				return;
-			case "initial": {
-				const liveRegionStart = this.#nativeScrollbackLiveRegionStart;
-				if (
-					this.#eagerNativeScrollbackRebuild &&
-					eagerEraseScrollbackRisk &&
-					!allowUnknownViewportMutation &&
-					liveRegionStart !== undefined &&
-					liveRegionStart < lines.length &&
-					!isMultiplexerSession() &&
-					this.#readNativeViewportAtBottom() === undefined
-				) {
-					this.#emitInitialLiveRegionPinnedPaint(
-						lines,
-						width,
-						height,
-						cursorPos,
-						liveRegionStart,
-						this.#nativeScrollbackCommitSafeEnd,
-					);
-				} else {
-					this.#emitFullPaint(lines, width, height, cursorPos, { clearViewport: true, clearScrollback: false });
-				}
-				this.#hasEverRendered = true;
-				return;
-			}
-			case "sessionReplace":
-				this.#clearScrollbackOnNextRender = false;
-				this.#clearNativeScrollbackDirty();
-				this.#emitFullPaint(lines, width, height, cursorPos, {
-					clearViewport: true,
-					clearScrollback: !isMultiplexerSession(),
-				});
-				this.#hasEverRendered = true;
-				return;
-			case "historyRebuild":
-				this.#clearNativeScrollbackDirty();
-				this.#emitFullPaint(lines, width, height, cursorPos, {
-					clearViewport: true,
-					clearScrollback: !isMultiplexerSession(),
-				});
-				return;
-			case "overlayRebuild":
-				this.#clearNativeScrollbackDirty();
-				this.#emitFullPaint(baseLines, width, height, null, {
-					clearViewport: true,
-					clearScrollback: !isMultiplexerSession(),
-				});
-				this.#emitViewportRepaint(lines, width, height, cursorPos);
-				return;
-			case "liveRegionPinned":
-				this.#emitLiveRegionPinnedRepaint(
-					lines,
-					width,
-					height,
-					cursorPos,
-					intent.appendFrom,
-					intent.appendTo,
-					intent.renderViewportTop,
-					prevViewportTop,
-					prevHardwareCursorRow,
-				);
-				return;
-			case "viewportRepaint":
-				if (intent.appendFrom !== undefined) {
-					this.#emitAppendTail(lines, intent.appendFrom, height, width, prevViewportTop, prevHardwareCursorRow);
-				}
-				this.#emitViewportRepaint(lines, width, height, cursorPos);
-				return;
-			case "deferredTailRepaint":
-				this.#emitDeferredTailRepaint(
-					intent.line,
-					width,
-					height,
-					intent.row,
-					prevViewportTop,
-					prevHardwareCursorRow,
-				);
-				return;
-			case "deferredMutation":
-				return;
-			case "deferredShrink":
-				this.#emitViewportRepaint(
-					this.#padDeferredShrinkLines(lines, intent.paddedLength),
-					width,
-					height,
-					cursorPos,
-				);
-				return;
-			case "shrink":
-				this.#emitShrink(lines, width, height, cursorPos, prevHardwareCursorRow, prevViewportTop);
-				return;
-			case "diff":
-				this.#emitDiff(
-					lines,
-					width,
-					height,
-					cursorPos,
-					intent.firstChanged,
-					intent.lastChanged,
-					intent.appendedLines,
-					prevViewportTop,
-					prevHardwareCursorRow,
-				);
-				return;
+		// Purge graphics for images the budget demoted to text. Kitty keeps
+		// images in a store that text clears don't touch; demoted rows still
+		// visible re-render as text and the window diff repaints them.
+		// Committed placements are immutable — their pixels are deleted but
+		// their rows are not rewritten.
+		let purgeSequence = "";
+		if (TERMINAL.imageProtocol === ImageProtocol.Kitty) {
+			for (const id of this.#imageBudget.takePurgeIds()) purgeSequence += encodeKittyDeleteImage(id);
+		} else {
+			this.#imageBudget.takePurgeIds();
+		}
+
+		// 6. Emit.
+		if (intent.kind === "fullPaint") {
+			this.#emitFullPaint(frame, window, width, height, cursorPos, purgeSequence, {
+				clearScrollback: intent.clearScrollback,
+				chunkTo,
+				windowTop,
+			});
+			this.#committedPrefix = rawFrame.slice(0, chunkTo);
+			this.#updateCommittedAuditRows(true, preCommitRows, preCommitAuditRows, byteStableBoundary);
+			this.#clearScrollbackOnNextRender = false;
+			this.#hasEverRendered = true;
+			if (!firstPaint && frameLength > height) this.#armPostFullPaintSettle();
+			return;
 		}
+		this.#emitUpdate(frame, window, width, height, cursorPos, purgeSequence, {
+			chunkTo,
+			windowTop,
+			prevWindowTop,
+			prevHardwareCursorRow,
+			forceWindowRewrite: this.#forceViewportRepaintOnNextRender || (geometryChanged && isMultiplexerSession()),
+		});
+		for (let i = this.#committedPrefix.length; i < chunkTo; i++) {
+			this.#committedPrefix.push(rawFrame[i] ?? "");
+		}
+		this.#updateCommittedAuditRows(committedPrefixResliced, preCommitRows, preCommitAuditRows, byteStableBoundary);
 	}
 
 	/**
-	 * Map the current frame onto a single render intent. Order matters: forced
-	 * resets and session replacement short-circuit first, then a terminal resize
-	 * (width or height change) always reduces to a clean reset + redraw at the new
-	 * geometry — `historyRebuild` normally, `viewportRepaint` inside a multiplexer
-	 * whose pane scrollback cannot be erased. Pure content mutations fall through
-	 * to the differential machinery below.
+	 * Detect committed-prefix violations and re-anchor the commit index at the
+	 * first moved row, so subsequent rows recommit instead of being skipped:
+	 * the stale copy stays in history — duplication, never loss. Pure in-place
+	 * restyles keep their alignment and are left alone (stale styling in
+	 * history was always the accepted artifact).
 	 */
-	#planRender(
-		newLines: string[],
-		widthChanged: boolean,
-		heightChanged: boolean,
-		prevViewportTop: number,
-		height: number,
-		hasVisibleOverlay: boolean,
-		overlayVisibilityReduced: boolean,
-		allowUnknownViewportMutation: boolean,
-		liveRegionStart: number | undefined,
-		commitSafeEnd: number | undefined,
-	): RenderIntent {
-		// A forced scrollback wipe can be queued before start()'s initial paint runs
-		// (cold `prometheus --resume` does this while replacing the welcome frame with the
-		// restored transcript). Honor it before the normal initial-preserve path so
-		// the first committed frame is the clean session replay, not a deferred wipe
-		// that waits for the user's first keystroke.
-		if (this.#clearScrollbackOnNextRender) return { kind: "sessionReplace" };
-
-		// Initial paint after start(): scrollback must keep its prior shell
-		// content, but the viewport must be cleared so stale rows do not bleed
-		// into the new UI.
-		if (!this.#hasEverRendered) return { kind: "initial" };
-
-		const forceViewportRepaint = this.#forceViewportRepaintOnNextRender;
-		const eagerEraseScrollbackRisk = this.#hasEagerEraseScrollbackRisk();
-		if (overlayVisibilityReduced && !isMultiplexerSession()) {
-			return hasVisibleOverlay ? { kind: "overlayRebuild" } : { kind: "historyRebuild" };
-		}
-
-		// A terminal resize (width or height change) reflows the terminal's own
-		// buffer, moving rows between the viewport and native scrollback and
-		// invalidating every cursor/viewport anchor the diff and append emitters
-		// rely on. Always reset cleanly at the new geometry and redraw. Inside a
-		// multiplexer the pane's saved lines cannot be erased (ED 3 is a no-op there
-		// and a full replay only duplicates the transcript), so repaint the visible
-		// window in place; a visible overlay rebuilds with its composite. This
-		// deliberately drops the no-overflow and confirmed-scrolled guards — a
-		// resize is an explicit user action, so a scrolled reader snaps to the
-		// bottom and preexisting shell scrollback above the UI is cleared. The
-		// streaming cap above explicitly exempts geometry changes, so even during
-		// active ED3-risk foreground streaming this rebuild stands and erases the
-		// scrollback the terminal just re-wrapped at the old size.
-		if (widthChanged || heightChanged) {
-			if (isMultiplexerSession()) return { kind: "viewportRepaint" };
-			return hasVisibleOverlay ? { kind: "overlayRebuild" } : { kind: "historyRebuild" };
-		}
-
-		// Same dirty-scrollback opt-in policy as the non-overlay branch below: an
-		// ED3-risk macOS/POSIX terminal with an unobservable viewport ignores
-		// focused-input unknown opt-ins, so overlay selector Up/Down moves do not
-		// become ED3 clears plus full transcript replays. Non-ED3-risk POSIX still
-		// honors direct-input/IME/autocomplete opt-ins.
-		if (hasVisibleOverlay) {
-			const nativeViewportAtBottom = this.#readNativeViewportAtBottom();
-			// Multiplexer panes never get a destructive scrollback clear
-			// (clearScrollback is forced off inside them), so a dirty-scrollback
-			// "rebuild" would only append a full duplicate copy of the transcript
-			// to pane history on every dirty frame. Keep repainting the viewport
-			// and leave reconciliation to explicit checkpoints.
-			const allowDirtyUnknownViewportMutation = allowUnknownViewportMutation && !eagerEraseScrollbackRisk;
-			if (
-				this.#nativeScrollbackDirty &&
-				!isMultiplexerSession() &&
-				this.#canRebuildNativeScrollbackLive(nativeViewportAtBottom, allowDirtyUnknownViewportMutation)
-			) {
-				return { kind: "overlayRebuild" };
-			}
-			this.#markNativeScrollbackDirty();
-			return { kind: "viewportRepaint" };
-		}
-
-		const liveRegionPinnedIntent = this.#planLiveRegionPinnedRender(
-			newLines,
-			height,
-			liveRegionStart,
-			commitSafeEnd,
-			eagerEraseScrollbackRisk,
-			allowUnknownViewportMutation,
-		);
-		if (liveRegionPinnedIntent) return liveRegionPinnedIntent;
-
-		// After foreground tool streaming: when content finally shrinks from the
-		// streaming peak, rebuild with ED 3 to commit the settled state cleanly.
-		// The check uses `#streamingHighWater` (the real peak) rather than
-		// `#previousLines.length` because unpinned ED3-risk streaming frames may
-		// commit only a viewport slice while native history is deferred.
-		if (this.#streamingHighWater > height && newLines.length < this.#streamingHighWater && newLines.length > height) {
-			this.#streamingHighWater = 0;
-			return { kind: "historyRebuild" };
-		}
-		if (this.#streamingHighWater > 0 && newLines.length <= height) {
-			this.#streamingHighWater = 0;
-		}
-
-		if (this.#nativeScrollbackDirty && !isMultiplexerSession()) {
-			// A dirty flag means older native history is stale; it is not required to
-			// make the current focused-input frame correct. On ED3-risk macOS/POSIX
-			// terminals with an unobservable viewport, ignore focused-input unknown
-			// opt-ins so Up/Down selector moves do not become ED3 clears plus full
-			// transcript replays. Non-ED3-risk POSIX terminals keep their safe
-			// direct-input/IME/autocomplete opt-in.
-			const allowDirtyUnknownViewportMutation = allowUnknownViewportMutation && !eagerEraseScrollbackRisk;
-			if (
-				this.#canRebuildNativeScrollbackLive(this.#readNativeViewportAtBottom(), allowDirtyUnknownViewportMutation)
-			) {
-				return { kind: "historyRebuild" };
-			}
+	#auditCommittedPrefix(rawFrame: readonly string[]): void {
+		const prefix = this.#committedPrefix;
+		if (prefix.length === 0) return;
+		const resyncTo = findCommittedPrefixResync(rawFrame, prefix, this.#committedPrefixAuditRows);
+		if (resyncTo < 0) return;
+		this.#committedRows = resyncTo;
+		this.#committedPrefixAuditRows = Math.min(this.#committedPrefixAuditRows, resyncTo);
+		prefix.length = resyncTo;
+		if ($flag("PROMETHEUS_DEBUG_REDRAW")) {
+			const msg = `[${new Date().toISOString()}] commit resync: committed prefix diverged at row ${resyncTo}; recommitting\n`;
+			fs.appendFileSync(getDebugLogPath(), msg);
 		}
+	}
 
-		const diff = this.#diffLines(newLines);
-		// Shrink across the viewport boundary: the new transcript would re-expose
-		// rows already committed to native scrollback. Rebuild immediately when the
-		// viewport is known/allowed to be at the tail; otherwise defer the rewrite
-		// and repaint against the previous row count so users scrolled into history
-		// are not yanked. A viewport-only repaint for a bottom-anchored shrink leaves
-		// stale high-water rows in native scrollback and duplicates the new tail above
-		// the viewport.
-		const naturalViewportTop = Math.max(0, newLines.length - height);
-		if (
-			diff.firstChanged !== -1 &&
-			newLines.length < this.#previousLines.length &&
-			naturalViewportTop < this.#scrollbackHighWater &&
-			!isMultiplexerSession()
-		) {
-			const nativeViewportAtBottom = this.#readNativeViewportAtBottom();
-			if (this.#nativeViewportIsScrolled(nativeViewportAtBottom, allowUnknownViewportMutation)) {
-				this.#markNativeScrollbackDirty();
-				return { kind: "deferredShrink", paddedLength: this.#previousLines.length };
-			}
-			// A shrink that re-exposes rows already committed to native scrollback
-			// must rebuild so the stale committed copy is cleared. Rebuild only with a
-			// positive at-tail proof; unknown viewports stay dirty because the host
-			// scroll position is not observable and ED3 can yank readers.
-			if (this.#canRebuildNativeScrollbackLive(nativeViewportAtBottom, false)) {
-				return { kind: "historyRebuild" };
-			}
-			// POSIX terminals — and Windows Terminal/ConPTY — that cannot report the
-			// viewport position fall through here (`canRebuildNativeScrollbackLive` is
-			// false). A destructive rebuild emits `\x1b[3J` (xterm erase saved lines),
-			// which can clear or reposition native scrollback and yank a scrolled-up
-			// reader (issue #1635), so it is unsafe while the probe is unavailable.
-			//
-			const paddedViewportTop = Math.max(0, this.#previousLines.length - height);
-			// ED3-risk terminals with an unobservable viewport cannot safely clear
-			// saved lines. Direct user-input frames (autocomplete/IME) may still
-			// repaint the live viewport: the user action pins the host to the tail, and
-			// emitting zero bytes leaves stale autocomplete rows on screen until a later
-			// checkpoint. When the changed rows are at or below the previous viewport
-			// top, keep the old bottom anchor by padding the frame to its previous
-			// length; that clears stale popup rows without re-exposing rows already
-			// committed to native history. If an offscreen edit shifted rows above the
-			// viewport, padding would repaint the wrong seam, so use a viewport repaint
-			// for liveness and keep history dirty. Active eager streaming also uses a
-			// viewport repaint so the live tail keeps moving. With neither direct input
-			// nor active eager streaming, the reader may be scrolled, so defer
-			// completely rather than repainting over their history.
-			if (nativeViewportAtBottom === undefined && eagerEraseScrollbackRisk) {
-				this.#markNativeScrollbackDirty();
-				if (allowUnknownViewportMutation) {
-					return diff.firstChanged < prevViewportTop
-						? { kind: "viewportRepaint" }
-						: { kind: "deferredShrink", paddedLength: this.#previousLines.length };
-				}
-				return this.#eagerNativeScrollbackRebuild
-					? { kind: "viewportRepaint" }
-					: this.#planDeferredTailRepaint(newLines, prevViewportTop, height);
-			}
+	/**
+	 * Recompute the byte-stable audit-rows cap after a commit. The audited prefix
+	 * [0, auditRows) holds rows committed while byte-stable; rows committed under a
+	 * durable snapshot end (beyond byteStableBoundary) are excluded so the audit
+	 * never re-anchors on their expected drift (a streaming table widening). A
+	 * wholesale re-slice (full paint / shrink / geometry) re-bases the prefix from
+	 * the current frame, so the cap is just min(committed, byteStableBoundary). An
+	 * incremental extend keeps the cap once any snapshot row has committed
+	 * (auditRows < committedRows): a later rise in byteStableBoundary (a table
+	 * finalizing) must not pull already-committed stale snapshots back under audit.
+	 */
+	#updateCommittedAuditRows(
+		resliced: boolean,
+		preCommittedRows: number,
+		preAuditRows: number,
+		byteStableBoundary: number,
+	): void {
+		const committed = this.#committedRows;
+		this.#committedPrefixAuditRows =
+			resliced || preAuditRows >= preCommittedRows
+				? Math.min(committed, byteStableBoundary)
+				: Math.min(preAuditRows, committed);
+	}
 
-			// Non-ED3-risk POSIX with an unobservable viewport. `deferredShrink` is
-			// safe only when changed rows are at or below the previous viewport top.
-			// Middle/offscreen deletes renumber rows above the viewport and padding
-			// the old length would repaint shifted rows or blank tail cells.
-			if (newLines.length <= paddedViewportTop) {
-				return { kind: "historyRebuild" };
-			}
-			this.#markNativeScrollbackDirty();
-			if (diff.firstChanged < prevViewportTop) {
-				return this.#planDeferredTailRepaint(newLines, prevViewportTop, height);
+	/**
+	 * Prepare the composed frame for emission, in place. Rows below
+	 * `#preparedValidRows` are already prepared against the current frame (the
+	 * compose lowered that floor to the stable prefix); rows at/after it are
+	 * revalidated positionally — a row whose raw content and width match its
+	 * cached entry reuses the prepared line, anything else re-prepares.
+	 */
+	#prepareFrame(frame: readonly string[], width: number): string[] {
+		const prepared = this.#preparedFrame;
+		const meta = this.#preparedMeta;
+		if (prepared.length > frame.length) {
+			prepared.length = frame.length;
+			meta.length = frame.length;
+		}
+		for (let i = Math.min(this.#preparedValidRows, prepared.length); i < frame.length; i++) {
+			const raw = frame[i]!;
+			const cached = meta[i];
+			if (cached !== undefined && cached.raw === raw && cached.width === width) {
+				prepared[i] = cached.line;
+				continue;
 			}
-			return { kind: "deferredShrink", paddedLength: this.#previousLines.length };
+			const entry = this.#prepareLine(raw, width);
+			meta[i] = entry;
+			prepared[i] = entry.line;
 		}
+		this.#preparedValidRows = frame.length;
+		return prepared;
+	}
 
-		// Multiplexer panes do not give us a safe native-history rebuild path, but
-		// a shrink can still move the logical viewport upward (for example hiding an
-		// overlay that extended past the base frame). A row-diff from the old
-		// viewport top would only clear the old suffix and leave the newly exposed
-		// base rows stale/blank, so repaint the live viewport in place.
-		if (
-			isMultiplexerSession() &&
-			diff.firstChanged !== -1 &&
-			newLines.length < this.#previousLines.length &&
-			naturalViewportTop !== prevViewportTop
-		) {
-			return { kind: "viewportRepaint" };
+	/** Stateless variant for overlay-composited windows and alt-screen frames. */
+	#prepareLinesArray(lines: readonly string[], width: number): string[] {
+		const prepared: string[] = new Array(lines.length);
+		for (let i = 0; i < lines.length; i++) {
+			prepared[i] = this.#prepareLine(lines[i]!, width).line;
 		}
+		return prepared;
+	}
 
-		// Direct-input shrink can also move the natural viewport upward even when
-		// no stale high-water scrollback is involved (for example slash autocomplete
-		// filtering from many rows to a few). The diff emitter is anchored to the
-		// previous viewport top and would only clear the old suffix, hiding the
-		// editor above the live window.
-		if (
-			allowUnknownViewportMutation &&
-			diff.firstChanged !== -1 &&
-			newLines.length < this.#previousLines.length &&
-			naturalViewportTop !== prevViewportTop
-		) {
-			return { kind: "viewportRepaint" };
-		}
-
-		// A shrink that moves the bottom-anchored viewport upward must re-anchor the
-		// visible window. The shrink-across-high-water block above already
-		// rebuilt/deferred when the shrink re-exposes rows committed to native
-		// scrollback (`naturalViewportTop < #scrollbackHighWater`). The remaining
-		// case slips through when the high-water mark lags the logical viewport top:
-		// non-destructive viewport repaints during foreground-tool streaming on
-		// ED3-risk terminals (ghostty/kitty/…) advance `#maxLinesRendered` without
-		// committing the overflow to native history, so a later shrink finds
-		// `naturalViewportTop >= #scrollbackHighWater` yet still needs to move the
-		// window up. The diff emitter below anchors to `#maxLinesRendered - height`
-		// and would only rewrite the suffix — dropping the newly exposed top row and
-		// leaving a blank at the bottom, so the rows below appear to render over the
-		// ones above. Repaint the true bottom-anchored tail and leave stale
-		// scrollback for the next checkpoint.
-		if (
-			!isMultiplexerSession() &&
-			diff.firstChanged !== -1 &&
-			newLines.length < this.#previousLines.length &&
-			naturalViewportTop < prevViewportTop
-		) {
-			this.#markNativeScrollbackDirty();
-			return { kind: "viewportRepaint" };
+	#prepareLine(raw: string, width: number): PreparedLine {
+		if (TERMINAL.isImageLine(raw)) {
+			return { raw, width, line: raw };
 		}
-
-		const suppressSuffixScroll = this.#suppressNextSuffixScroll;
-		this.#suppressNextSuffixScroll = false;
-		if (
-			suppressSuffixScroll &&
-			diff.appendedLines &&
-			diff.firstChanged < this.#previousLines.length &&
-			!isMultiplexerSession()
-		) {
-			// A checkpoint replay is followed by one frame where transient live chrome
-			// (status/footer rows) may be inserted inside the visible suffix and then
-			// disappear; repaint it in place so it never enters scrollback. If the
-			// insertion grows the overflow boundary, native history would lose rows
-			// while the viewport looks correct, so rebuild instead.
-			const appendedTailStart = this.#findAppendedTailStart(newLines);
-			const overflowBefore = Math.max(0, this.#previousLines.length - height);
-			const overflowAfter = Math.max(0, newLines.length - height);
-			if (
-				appendedTailStart === newLines.length &&
-				diff.firstChanged >= prevViewportTop &&
-				overflowAfter <= overflowBefore
-			) {
-				return { kind: "viewportRepaint" };
-			}
-			const nativeViewportAtBottom = this.#readNativeViewportAtBottom();
-			if (this.#canRebuildNativeScrollbackLive(nativeViewportAtBottom, allowUnknownViewportMutation)) {
-				return { kind: "historyRebuild" };
-			}
-			this.#markNativeScrollbackDirty();
-			return { kind: "viewportRepaint" };
-		}
-
-		if (diff.firstChanged === -1) {
-			// Content unchanged. A forced render still refreshes the visible viewport
-			// but keeps the existing diff basis so later coalesced content mutations
-			// can still update native scrollback correctly.
-			if (forceViewportRepaint) return { kind: "viewportRepaint" };
-			return { kind: "noop" };
-		}
-
-		const contentGrew = newLines.length > this.#previousLines.length;
-		const pureAppend = diff.appendedLines && diff.firstChanged === this.#previousLines.length;
-		const structuralMutation = newLines.length !== this.#previousLines.length || diff.firstChanged < prevViewportTop;
-		if (pureAppend && contentGrew && this.#previousLines.length >= height && !isMultiplexerSession()) {
-			const nativeViewportAtBottom = this.#readNativeViewportAtBottom();
-			if (this.#nativeViewportIsKnownScrolled(nativeViewportAtBottom)) {
-				this.#markNativeScrollbackDirty();
-				return { kind: "deferredMutation" };
-			}
-			if (nativeViewportAtBottom === undefined && allowUnknownViewportMutation) {
-				// Direct input can grow transient live UI (autocomplete/IME/editor
-				// wraps) while the previous frame already touched the viewport bottom.
-				// A diff append would `\r\n`-scroll those transient rows into native
-				// history, and a later popup shrink would duplicate the stable prefix at
-				// the scrollback seam. Repaint the live viewport in place instead; the
-				// dirty checkpoint owns native-history reconciliation.
-				this.#markNativeScrollbackDirty();
-				return { kind: "viewportRepaint" };
-			}
-			if (this.#nativeViewportIsScrolled(nativeViewportAtBottom, allowUnknownViewportMutation)) {
-				this.#markNativeScrollbackDirty();
-				// Unknown viewport (e.g. native Windows Terminal where the probe cannot
-				// see WT host scrollback) is a different case: a no-op there freezes the
-				// editor on the keystroke that grows `lines.length` past the viewport
-				// (the wrap keystroke). Fall through to a non-destructive viewport
-				// repaint instead so the live UI keeps updating without yanking a
-				// possibly-scrolled reader.
-				return { kind: "viewportRepaint" };
-			}
+		const source = this.#lineFitSource(raw, width);
+		const normalized = normalizeTerminalOutput(source);
+		const asciiWidth = this.#ansiAsciiLineWidth(normalized, width);
+		if ((asciiWidth ?? visibleWidth(normalized)) <= width) {
+			return { raw, width, line: normalized };
 		}
-		// A structural mutation (offscreen edit or inserted rows) while bottom-
-		// anchored: when the reader is scrolled, repaint/clamp without trusting the
-		// stale viewport anchors; otherwise rebuild native history when a safe
-		// checkpoint allows.
-		if (!pureAppend && structuralMutation && !isMultiplexerSession()) {
-			const nativeViewportAtBottom = this.#readNativeViewportAtBottom();
-			if (this.#nativeViewportIsScrolled(nativeViewportAtBottom, allowUnknownViewportMutation)) {
-				this.#markNativeScrollbackDirty();
-				// See the matching comment on the pure-append branch above: confirmed
-				// scrolled stays a no-op; unknown viewport repaints the visible window
-				// so slash-command transitions and offscreen chrome edits paint on the
-				// same frame instead of stalling until the next prompt submit.
-				if (this.#nativeViewportIsKnownScrolled(nativeViewportAtBottom)) {
-					return { kind: "deferredMutation" };
-				}
-				return { kind: "viewportRepaint" };
-			}
-			// The append-tail path can only scroll a clean pure-tail append over an
-			// offscreen edit into history: the rows it pushes must equal the net
-			// growth, i.e. `#findAppendedTailStart` must land on `previousLines.length`
-			// (`tailAppendCount === addedCount`). Any mismatch is structurally
-			// ambiguous — more added than the matched tail means offscreen rows were
-			// inserted (a collapsed cell expanding); fewer means the previous last
-			// line repeats earlier so the tail is mis-located. Under-counting splices
-			// stale history; over-counting scrolls an extra row and duplicates the
-			// line at the viewport top. Rebuild whenever the replay checkpoint allows.
-			if (
-				contentGrew &&
-				diff.firstChanged < prevViewportTop &&
-				this.#canRebuildNativeScrollbackLive(nativeViewportAtBottom, false)
-			) {
-				const appendedTailStart = diff.appendedLines ? this.#findAppendedTailStart(newLines) : newLines.length;
-				const tailAppendCount = newLines.length - appendedTailStart;
-				const addedCount = newLines.length - this.#previousLines.length;
-				if (addedCount !== tailAppendCount) {
-					return { kind: "historyRebuild" };
+		const line = truncateToWidth(normalized, width, Ellipsis.Omit);
+		return { raw, width, line };
+	}
+
+	#lineFitSource(raw: string, width: number): string {
+		const safeWidth = Number.isFinite(width) ? Math.max(1, Math.trunc(width)) : 1;
+		const maxSourceLength = Math.min(
+			LINE_FIT_MAX_SOURCE_CODE_UNITS,
+			Math.max(LINE_FIT_MIN_SOURCE_CODE_UNITS, safeWidth * LINE_FIT_SOURCE_WIDTH_MULTIPLIER),
+		);
+		if (raw.length <= maxSourceLength) return raw;
+
+		let output = "";
+		let cells = 0;
+		for (let i = 0; i < raw.length && cells < safeWidth; ) {
+			if (raw.charCodeAt(i) === 0x1b) {
+				const end = this.#ansiSequenceEnd(raw, i);
+				if (end < 0) break;
+				if (this.#ansiSequenceHasVisiblePayload(raw, i)) {
+					const sequence = raw.slice(i, end);
+					if (output.length + sequence.length <= maxSourceLength) {
+						output += sequence;
+						cells += visibleWidth(sequence);
+					}
 				}
+				i = end;
+				continue;
 			}
-			if (
-				newLines.length !== this.#previousLines.length &&
-				this.#scrollbackHighWater > 0 &&
-				this.#canRebuildNativeScrollbackLive(nativeViewportAtBottom, allowUnknownViewportMutation)
-			) {
-				return { kind: "historyRebuild" };
-			}
-		}
-
-		// Configurable shrink-clear: opt-in path that repaints to wipe rows the
-		// diff path would leave behind.
-		if (this.#clearOnShrink && newLines.length < this.#previousLines.length && this.overlayStack.length === 0) {
-			return { kind: "viewportRepaint" };
-		}
-
-		// Pure trailing shrink: all changed indices live past the new tail.
-		if (diff.firstChanged >= newLines.length) {
-			return { kind: "shrink" };
-		}
 
-		// Offscreen edit: repainting only the viewport leaves native history stale
-		// while the user is bottom-anchored. Rebuild whenever replay is safe. If
-		// replay is not safe, keep the viewport stable, mark history dirty, and only
-		// scroll a clean appended tail so newly streamed rows remain reachable until
-		// the next checkpoint rebuild.
-		if (diff.firstChanged < prevViewportTop) {
-			const nativeViewportAtBottom = this.#readNativeViewportAtBottom();
-			const cleanTailAppend =
-				diff.appendedLines && this.#findAppendedTailStart(newLines) === this.#previousLines.length;
-			if (
-				!isMultiplexerSession() &&
-				this.#canRebuildNativeScrollbackLive(nativeViewportAtBottom, allowUnknownViewportMutation)
-			) {
-				return { kind: "historyRebuild" };
+			const code = raw.charCodeAt(i);
+			const next = code >= 0xd800 && code <= 0xdbff && i + 1 < raw.length ? i + 2 : i + 1;
+			const char = raw.slice(i, next);
+			const charWidth = visibleWidth(char);
+			if (charWidth > 0 && cells + charWidth > safeWidth) break;
+			if (output.length + char.length > maxSourceLength) {
+				if (charWidth > 0) break;
+				i = next;
+				continue;
 			}
-			this.#markNativeScrollbackDirty();
-			if (
-				nativeViewportAtBottom === undefined &&
-				eagerEraseScrollbackRisk &&
-				!cleanTailAppend &&
-				!this.#eagerNativeScrollbackRebuild
-			) {
-				return this.#planDeferredTailRepaint(newLines, prevViewportTop, height);
+			if (charWidth === 0) {
+				const remainingVisibleCells = safeWidth - cells;
+				const reservedCodeUnits = remainingVisibleCells * 2;
+				if (output.length + char.length > maxSourceLength - reservedCodeUnits) {
+					i = next;
+					continue;
+				}
 			}
-			return { kind: "viewportRepaint", appendFrom: cleanTailAppend ? this.#previousLines.length : undefined };
+			output += char;
+			cells += charWidth;
+			i = next;
 		}
 
-		if (forceViewportRepaint) {
-			if (isMultiplexerSession()) return { kind: "viewportRepaint" };
-			if (pureAppend && contentGrew && this.#previousLines.length >= height) {
-				return { kind: "viewportRepaint", appendFrom: this.#previousLines.length };
+		return output + SEGMENT_RESET;
+	}
+
+	#ansiSequenceEnd(line: string, start: number): number {
+		const next = line.charCodeAt(start + 1);
+		if (next === 0x5b) {
+			let i = start + 2;
+			while (i < line.length) {
+				const final = line.charCodeAt(i);
+				if (final >= 0x40 && final <= 0x7e) return i + 1;
+				i++;
 			}
-			if (newLines.length === this.#previousLines.length && diff.firstChanged >= prevViewportTop) {
-				return { kind: "viewportRepaint" };
+			return -1;
+		}
+		if (next === 0x5d) {
+			let i = start + 2;
+			while (i < line.length) {
+				const osc = line.charCodeAt(i);
+				if (osc === 0x07) return i + 1;
+				if (osc === 0x1b && line.charCodeAt(i + 1) === 0x5c) return i + 2;
+				i++;
 			}
+			return -1;
 		}
+		return start + 2 <= line.length ? start + 2 : -1;
+	}
 
-		return {
-			kind: "diff",
-			firstChanged: diff.firstChanged,
-			lastChanged: diff.lastChanged,
-			appendedLines: diff.appendedLines,
-		};
+	#ansiSequenceHasVisiblePayload(line: string, start: number): boolean {
+		// OSC 66 (`\x1b]66;META;TEXT\x1b\\`) carries visible cells inside the payload.
+		return (
+			line.charCodeAt(start + 1) === 0x5d &&
+			line.charCodeAt(start + 2) === 0x36 &&
+			line.charCodeAt(start + 3) === 0x36 &&
+			line.charCodeAt(start + 4) === 0x3b
+		);
 	}
 
-	/**
-	 * Two-pointer diff over `#previousLines` and `newLines`. `firstChanged` is
-	 * `-1` when the two are identical; otherwise it is the first differing
-	 * index. Trailing appends are normalized so `lastChanged` always ends at the
-	 * last row that needs to be touched.
-	 */
-	#diffLines(newLines: string[]): { firstChanged: number; lastChanged: number; appendedLines: boolean } {
-		let firstChanged = -1;
-		let lastChanged = -1;
-		const maxLines = Math.max(newLines.length, this.#previousLines.length);
-		for (let i = 0; i < maxLines; i++) {
-			const oldLine = i < this.#previousLines.length ? this.#previousLines[i] : "";
-			const newLine = i < newLines.length ? newLines[i] : "";
-			if (oldLine !== newLine) {
-				if (firstChanged === -1) firstChanged = i;
-				lastChanged = i;
+	#ansiAsciiLineWidth(line: string, maxWidth: number): number | undefined {
+		let col = 0;
+		for (let i = 0; i < line.length; ) {
+			const code = line.charCodeAt(i);
+			if (code === 0x1b) {
+				const next = line.charCodeAt(i + 1);
+				if (next === 0x5b) {
+					let j = i + 2;
+					while (j < line.length) {
+						const final = line.charCodeAt(j);
+						if (final >= 0x40 && final <= 0x7e) break;
+						j++;
+					}
+					if (j >= line.length) return undefined;
+					i = j + 1;
+					continue;
+				}
+				if (next === 0x5d) {
+					// OSC 66 text-sizing spans carry visible payload inside the OSC.
+					// Fall back to visibleWidth() so scaled cells stay exact.
+					if (
+						line.charCodeAt(i + 2) === 0x36 &&
+						line.charCodeAt(i + 3) === 0x36 &&
+						line.charCodeAt(i + 4) === 0x3b
+					) {
+						return undefined;
+					}
+					let j = i + 2;
+					while (j < line.length) {
+						const osc = line.charCodeAt(j);
+						if (osc === 0x07) {
+							i = j + 1;
+							break;
+						}
+						if (osc === 0x1b && line.charCodeAt(j + 1) === 0x5c) {
+							i = j + 2;
+							break;
+						}
+						j++;
+					}
+					if (j >= line.length) return undefined;
+					continue;
+				}
+				return undefined;
 			}
+			if (code < 0x20 || code > 0x7e) return undefined;
+			col++;
+			if (col > maxWidth) return col;
+			i++;
 		}
-		const appendedLines = newLines.length > this.#previousLines.length;
-		if (appendedLines) {
-			if (firstChanged === -1) firstChanged = this.#previousLines.length;
-			lastChanged = newLines.length - 1;
+		return col;
+	}
+
+	#lineRewriteSequence(line: string, width: number): string {
+		if (TERMINAL.isImageLine(line)) return ERASE_LINE + line;
+		const terminalLine = this.#terminalLine(line);
+		const asciiWidth = this.#ansiAsciiLineWidth(line, width);
+		if (asciiWidth !== undefined) {
+			// Exact width model: skip the erase only when the row truly fills
+			// the line (an EL there would eat the last cell via pending-wrap).
+			return asciiWidth >= width ? terminalLine : terminalLine + ERASE_TO_END_OF_LINE;
 		}
-		return { firstChanged, lastChanged, appendedLines };
+		// Non-ASCII rows: the native measure can over-count combining-heavy
+		// scripts, so a row it calls "full" may render short and leave stale
+		// cells from the previous occupant — which would then scroll into
+		// history baked into the committed row. Erase the line first instead
+		// (rewrites always start at column 1, so EL-to-end clears the whole
+		// row); the leading reset keeps BCE on the default background.
+		return SEGMENT_RESET + ERASE_TO_END_OF_LINE + terminalLine;
 	}
 
 	/**
-	 * Locate the longest suffix of `#previousLines` that appears in `newLines`.
-	 * The returned index is the first row past that suffix — the rows that are
-	 * "new appends" relative to the unchanged tail. Used to push streaming
-	 * output into scrollback even when an offscreen edit also moved rows.
+	 * Single state-transition point. Every emitter calls this exactly once at
+	 * the end so cursor/window accounting stays consistent.
 	 */
-	#findAppendedTailStart(newLines: string[]): number {
-		if (this.#previousLines.length === 0) return newLines.length;
-		const previousLast = this.#previousLines[this.#previousLines.length - 1];
-		let bestEnd = -1;
-		let bestLength = 0;
-		for (let end = newLines.length - 1; end >= 0; end--) {
-			if (newLines[end] !== previousLast) continue;
-			let length = 1;
-			while (
-				length < this.#previousLines.length &&
-				end - length >= 0 &&
-				this.#previousLines[this.#previousLines.length - 1 - length] === newLines[end - length]
-			) {
-				length += 1;
-			}
-			if (length > bestLength) {
-				bestLength = length;
-				bestEnd = end;
-			}
-		}
-		return bestEnd === -1 ? newLines.length : bestEnd + 1;
+	#commit(
+		lines: readonly string[],
+		window: string[],
+		width: number,
+		height: number,
+		hardwareCursor: HardwareCursorUpdate,
+	): void {
+		this.#previousFrameLength = lines.length;
+		this.#previousWindow = window;
+		this.#forceViewportRepaintOnNextRender = false;
+		this.#previousWidth = width;
+		this.#previousHeight = height;
+		this.#recordHardwareCursorUpdate(hardwareCursor);
 	}
 
-	#markNativeScrollbackDirty(): void {
-		this.#nativeScrollbackDirty = true;
+	#targetHardwareCursorState(
+		cursorPos: { row: number; col: number } | null,
+		totalLines: number,
+	): HardwareCursorState | null {
+		if (!cursorPos || totalLines <= 0) return null;
+		return {
+			row: Math.max(0, Math.min(cursorPos.row, totalLines - 1)),
+			col: Math.max(0, cursorPos.col),
+			visible: this.#showHardwareCursor,
+		};
 	}
 
-	#clearNativeScrollbackDirty(): void {
-		this.#nativeScrollbackDirty = false;
+	#recordHardwareCursorState(state: HardwareCursorState): void {
+		this.#hardwareCursorRow = state.row;
+		this.#hardwareCursorState = state;
+		this.#hardwareCursorVisible = state.visible;
+		this.#hardwareCursorVisibilityKnown = true;
 	}
 
-	#hasEagerEraseScrollbackRisk(): boolean {
-		if (process.platform === "win32") return false;
-		return this.terminal.hasEagerEraseScrollbackRisk?.() ?? TERMINAL.eagerEraseScrollbackRisk;
+	#recordHardwareCursorRowOnly(row: number, visible?: boolean): void {
+		this.#hardwareCursorRow = row;
+		this.#hardwareCursorState = null;
+		if (visible !== undefined) {
+			this.#hardwareCursorVisible = visible;
+			this.#hardwareCursorVisibilityKnown = true;
+		}
 	}
 
-	#readNativeViewportAtBottom(): boolean | undefined {
-		// A stale positive is destructive: live history rebuilds clear native
-		// scrollback. Require two consecutive at-bottom probes before trusting it.
-		const first = this.terminal.isNativeViewportAtBottom?.();
-		if (first !== true) return first;
-		const second = this.terminal.isNativeViewportAtBottom?.();
-		return second === true ? true : second;
+	#recordHardwareCursorUpdate(update: HardwareCursorUpdate): void {
+		if (update.state) {
+			this.#recordHardwareCursorState(update.state);
+			return;
+		}
+		this.#recordHardwareCursorRowOnly(update.toRow, update.visible);
 	}
 
-	#nativeViewportIsScrolled(
-		nativeViewportAtBottom: boolean | undefined,
-		allowUnknownViewportMutation = false,
-	): boolean {
-		return (
-			nativeViewportAtBottom === false ||
-			(nativeViewportAtBottom === undefined && process.platform === "win32" && !allowUnknownViewportMutation)
-		);
+	#recordHardwareCursorHidden(): void {
+		this.#hardwareCursorVisible = false;
+		this.#hardwareCursorVisibilityKnown = true;
+		if (!this.#hardwareCursorState) return;
+		this.#hardwareCursorState = { ...this.#hardwareCursorState, visible: false };
 	}
 
-	#nativeViewportIsKnownScrolled(nativeViewportAtBottom: boolean | undefined): boolean {
-		return nativeViewportAtBottom === false;
-	}
-	#canReplayNativeScrollbackAtCheckpoint(nativeViewportAtBottom: boolean | undefined): boolean {
-		return nativeViewportAtBottom === true;
+	#forgetHardwareCursorState(): void {
+		this.#hardwareCursorState = null;
+		this.#hardwareCursorVisibilityKnown = false;
 	}
 
-	/**
-	 * Live-frame counterpart to {@link #canReplayNativeScrollbackAtCheckpoint}.
-	 * Decides whether a destructive native scrollback rebuild
-	 * (`historyRebuild`/`overlayRebuild`, which clears saved lines and may move
-	 * the native viewport) is safe to emit *during ordinary rendering*. POSIX
-	 * terminals cannot report whether the user has scrolled up
-	 * (`isNativeViewportAtBottom()` is `undefined`), so an unknown position is
-	 * treated as unsafe: defer to a non-destructive viewport repaint and keep
-	 * scrollback dirty until a later render has a positive at-tail proof. A prompt
-	 * submit is no longer treated as proof for unobservable host scrollback.
-	 * this, every offscreen transcript edit while streaming wiped scrollback and
-	 * yanked a scrolled-up reader out of their current context.
-	 * `allowUnknownViewportMutation` (autocomplete/IME) opts directly
-	 * user-driven POSIX frames back into the rebuild. Native Windows and Windows
-	 * Terminal still cannot trust an unknown probe during live rendering — ConPTY
-	 * may be fronting host scrollback we cannot observe — so they keep deferring.
-	 */
-	#canRebuildNativeScrollbackLive(
-		nativeViewportAtBottom: boolean | undefined,
-		allowUnknownViewportMutation: boolean,
-	): boolean {
+	#sameHardwareCursorState(state: HardwareCursorState): boolean {
+		const current = this.#hardwareCursorState;
 		return (
-			nativeViewportAtBottom === true ||
-			(nativeViewportAtBottom === undefined && allowUnknownViewportMutation && process.platform !== "win32")
+			current !== null && current.row === state.row && current.col === state.col && current.visible === state.visible
 		);
 	}
 
-	#planLiveRegionPinnedRender(
-		newLines: string[],
-		height: number,
-		liveRegionStart: number | undefined,
-		commitSafeEnd: number | undefined,
-		eagerEraseScrollbackRisk: boolean,
-		allowUnknownViewportMutation: boolean,
-	): RenderIntent | undefined {
-		if (
-			liveRegionStart === undefined ||
-			liveRegionStart >= newLines.length ||
-			!this.#eagerNativeScrollbackRebuild ||
-			!eagerEraseScrollbackRisk ||
-			allowUnknownViewportMutation
-		) {
-			return undefined;
-		}
-		// Multiplexers (tmux/screen/zellij) cannot erase pane history with `\x1b[3J`
-		// and cannot answer a viewport-position probe, so the destructive checkpoint
-		// rebuild path is forever unavailable. The pinned emitter is built from the
-		// opposite primitives — relative cursor moves, per-line `\x1b[2K`, and
-		// `\r\n` to scroll sealed rows past the viewport bottom — which are exactly
-		// what tmux pane history accepts. Without this commit-as-you-go path, the
-		// streaming cap below clipped every frame to the visible tail and the
-		// scrolled-off head was committed nowhere (issue #1974).
-		if (newLines.length <= height && this.#scrollbackHighWater === 0) return undefined;
-		if (this.#readNativeViewportAtBottom() !== undefined) return undefined;
-
-		this.#markNativeScrollbackDirty();
-		const naturalViewportTop = Math.max(0, newLines.length - height);
-		// Rows before the live-region boundary are sealed. The commit boundary is
-		// the deeper of the sealed start and the append-only `commitSafeEnd`: a
-		// streaming assistant block reports a `commitSafeEnd` spanning its whole
-		// body, so its head rows that scroll above the viewport commit to native
-		// scrollback instead of vanishing (committed nowhere, repainted nowhere).
-		// A volatile live block (a tool preview that later collapses) omits
-		// `commitSafeEnd`, so the boundary falls back to `liveRegionStart` and its
-		// mutable rows stay deferred — otherwise a pending box that later collapses
-		// to its running/final shape leaves the old top half in scrollback and
-		// repaints the new tail below it, visually splitting one box across the
-		// scrollback seam.
-		const commitBoundary = commitSafeEnd ?? liveRegionStart;
-		const sealedAppendTo = Math.min(naturalViewportTop, commitBoundary);
-		const appendTo = Math.max(0, sealedAppendTo);
-		const appendFrom = Math.min(this.#scrollbackHighWater, appendTo);
-		// If the live-region collapse would re-expose committed rows already written
-		// to native scrollback, clamp the repaint below that committed prefix so
-		// committed rows are not duplicated. Mutable rows beyond the commit boundary
-		// may remain hidden above the viewport until the next checkpoint rebuild;
-		// that is safer than committing transient rows that can later re-layout.
-		const committedSealedEnd = Math.min(this.#scrollbackHighWater, commitBoundary);
-		const renderViewportTop = Math.max(naturalViewportTop, committedSealedEnd);
-		return { kind: "liveRegionPinned", appendFrom, appendTo, renderViewportTop };
-	}
-
-	#planDeferredTailRepaint(newLines: string[], prevViewportTop: number, height: number): RenderIntent {
-		const row = prevViewportTop + height - 1;
-		if (row < 0 || row >= this.#previousLines.length || newLines.length !== this.#previousLines.length) {
-			return { kind: "deferredMutation" };
-		}
-		const line = newLines[row] ?? "";
-		const previousLine = this.#deferredTailLine ?? this.#previousLines[row] ?? "";
-		if (line === previousLine) {
-			return { kind: "deferredMutation" };
-		}
-		return { kind: "deferredTailRepaint", row, line };
-	}
-
-	#padDeferredShrinkLines(lines: string[], paddedLength: number): string[] {
-		if (lines.length >= paddedLength) return lines;
-		return [...lines, ...new Array<string>(paddedLength - lines.length).fill("")];
-	}
-	/**
-	 * Truncate a line to the visible viewport width. Image lines are left
-	 * alone, narrow lines pass through unchanged. Truncation re-appends the
-	 * per-line terminator so SGR/OSC 8 state does not leak across rows when
-	 * `truncateToWidth` drops the trailing bytes appended by
-	 * {@link #applyLineResets}.
-	 */
-	#fitLinesToWidth(lines: string[], width: number): string[] {
-		for (let i = 0; i < lines.length; i++) {
-			lines[i] = this.#fitLineToWidth(lines[i], width);
-		}
-		return lines;
-	}
-
-	#fitLineToWidth(line: string, width: number): string {
-		if (TERMINAL.isImageLine(line)) return line;
-		if (visibleWidth(line) <= width) return line;
-		const truncated = truncateToWidth(line, width, Ellipsis.Omit);
-		return truncated + (truncated.includes("\x1b]8;") ? LINE_TERMINATOR : SEGMENT_RESET);
-	}
-
 	/**
-	 * Single state-transition point. Every emitter calls this exactly once at
-	 * the end so cursor/viewport/scrollback accounting stays consistent.
-	 */
-
-	#commit(lines: string[], width: number, height: number, viewportTop: number, hardwareCursorRow: number): void {
-		this.#deferredTailLine = undefined;
-		this.#previousLines = lines;
-		this.#previousVisibleOverlayComponents = this.#visibleOverlayComponentsThisRender;
-		this.#forceViewportRepaintOnNextRender = false;
-		this.#previousWidth = width;
-		this.#previousHeight = height;
-		this.#cursorRow = Math.max(0, lines.length - 1);
-		this.#viewportTopRow = viewportTop;
-		this.#hardwareCursorRow = hardwareCursorRow;
-	}
-
-	/**
-	 * Clear the viewport (optionally scrollback) and emit the full transcript.
-	 * Backs `initial`, `sessionReplace`, and `historyRebuild` intents.
+	 * Clear the viewport (optionally native scrollback) and replay the frame:
+	 * committed prefix `[0, chunkTo)` followed by the visible window. ED3
+	 * (`CSI 3 J`) is emitted here and only here, and only for gesture-driven
+	 * paints (session replace, resize, resetDisplay, or an explicit
+	 * `clearScrollback` initial paint).
 	 */
 	#emitFullPaint(
-		lines: string[],
+		frame: readonly string[],
+		window: string[],
 		width: number,
 		height: number,
 		cursorPos: { row: number; col: number } | null,
-		options: { clearViewport: boolean; clearScrollback: boolean },
+		purgeSequence: string,
+		options: { clearScrollback: boolean; chunkTo: number; windowTop: number },
 	): void {
 		this.#fullRedrawCount += 1;
-		let buffer = this.#paintBeginSequence;
-		// Purge graphics for images the budget just demoted to text. Kitty keeps
-		// images in a store that text-clear escapes don't touch, so delete them by
-		// id; other protocols bake images into cells the clear-screen below wipes.
-		const purgeIds = this.#imageBudget.takePurgeIds();
-		if (TERMINAL.imageProtocol === ImageProtocol.Kitty) {
-			for (const id of purgeIds) buffer += encodeKittyDeleteImage(id);
-		}
-		if (options.clearViewport) {
-			if (options.clearScrollback) {
-				buffer += "\x1b[2J\x1b[H\x1b[3J";
-			} else {
-				// Best-effort: push the pre-paint screen into scrollback on terminals
-				// that implement kitty's ED 22 (copy-screen-to-scrollback-then-erase).
-				// ED 22 is not universal: multiplexers (tmux/screen/zellij), non-kitty
-				// terminals, and old kitty ignore the unknown ED parameter, which left
-				// the initial paint with no viewport clear (stale prior-program content
-				// bled through until a resize). Always follow with ED 2 so the viewport
-				// is cleared regardless; on real kitty, ED 2 over the now-blank screen
-				// is a no-op and does not push a second (blank) copy to scrollback.
-				if (TERMINAL.supportsScreenToScrollback) buffer += "\x1b[22J";
-				buffer += "\x1b[2J\x1b[H";
-			}
-		}
-		// Only the final viewport rows stay on screen; everything above scrolls
-		// into native scrollback, so optimize the visible tail with DECCARA
-		// rectangles while writing scrollback-bound rows as full styled strings
-		// (their background must survive in history, which DECCARA cannot reach).
-		const visibleStart = Math.max(0, lines.length - height);
-		let fillSequence = "";
-		let visibleTexts: string[] | null = null;
-		if (TERMINAL.deccara && visibleStart < lines.length) {
-			const visible: string[] = new Array(lines.length - visibleStart);
-			for (let k = 0; k < visible.length; k++) {
-				visible[k] = this.#fitLineToWidth(lines[visibleStart + k], width);
-			}
-			const plan = planDeccaraFills(visible, width);
-			visibleTexts = plan.texts;
-			fillSequence = plan.sequence;
-		}
-		for (let i = 0; i < lines.length; i++) {
-			if (i > 0) buffer += "\r\n";
-			buffer +=
-				visibleTexts && i >= visibleStart ? visibleTexts[i - visibleStart] : this.#fitLineToWidth(lines[i], width);
-		}
-		buffer += fillSequence;
-		const finalRow = Math.max(0, lines.length - 1);
-		const { seq, toRow } = this.#cursorControlSequence(cursorPos, lines.length, finalRow);
-		buffer += seq;
-		buffer += this.#paintEndSequence;
-		this.terminal.write(buffer);
-
-		this.#maxLinesRendered = options.clearViewport ? lines.length : Math.max(this.#maxLinesRendered, lines.length);
+		const { chunkTo, windowTop } = options;
+		let buffer = this.#paintBeginSequence + this.#leaveResizeAltSequence() + purgeSequence;
 		if (options.clearScrollback) {
-			this.#scrollbackHighWater = 0;
-			this.#suppressNextSuffixScroll = lines.length > height;
-		}
-		const pushedNow = Math.max(0, lines.length - height);
-		if (pushedNow > this.#scrollbackHighWater) {
-			this.#scrollbackHighWater = pushedNow;
-		}
-		this.#commit(lines, width, height, Math.max(0, this.#maxLinesRendered - height), toRow);
-	}
-
-	/**
-	 * Initial foreground-stream paint on ED3-risk hosts with unknown viewport
-	 * position. Clears only the visible screen, commits the stable prefix, and
-	 * paints the mutable live tail without first writing hidden live rows into
-	 * native scrollback.
-	 */
-	#emitInitialLiveRegionPinnedPaint(
-		lines: string[],
-		width: number,
-		height: number,
-		cursorPos: { row: number; col: number } | null,
-		liveRegionStart: number,
-		commitSafeEnd: number | undefined,
-	): void {
-		this.#fullRedrawCount += 1;
-		this.#markNativeScrollbackDirty();
-		const naturalViewportTop = Math.max(0, lines.length - height);
-		const commitBoundary = commitSafeEnd ?? liveRegionStart;
-		const appendTo = Math.max(0, Math.min(naturalViewportTop, commitBoundary, lines.length));
-		const viewportTop = naturalViewportTop;
-
-		let buffer = this.#paintBeginSequence;
-		if (TERMINAL.supportsScreenToScrollback) buffer += "\x1b[22J";
-		buffer += "\x1b[2J\x1b[H";
-
+			buffer += "\x1b[2J\x1b[H\x1b[3J";
+		} else {
+			// Best-effort: push the pre-paint screen into scrollback on
+			// terminals that implement kitty's ED 22
+			// (copy-screen-to-scrollback-then-erase). Always follow with ED 2 so
+			// the viewport is cleared regardless; on real kitty, ED 2 over the
+			// now-blank screen is a no-op and does not push a second copy.
+			if (TERMINAL.supportsScreenToScrollback) buffer += "\x1b[22J";
+			buffer += "\x1b[2J\x1b[H";
+		}
+		// DECCARA fills optimize only the rows that stay visible; history-bound
+		// rows are written as full styled strings (their background must
+		// survive in scrollback, which DECCARA cannot reach).
+		const { texts, sequence } = this.#deccaraFillsEnabled()
+			? planDeccaraFills(window, width)
+			: { texts: window, sequence: "" };
 		let wroteLine = false;
-		for (let i = 0; i < appendTo; i++) {
+		for (let i = 0; i < chunkTo; i++) {
 			if (wroteLine) buffer += "\r\n";
-			buffer += this.#fitLineToWidth(lines[i] ?? "", width);
+			buffer += this.#terminalLine(frame[i] ?? "");
 			wroteLine = true;
 		}
 		for (let screenRow = 0; screenRow < height; screenRow++) {
 			if (wroteLine) buffer += "\r\n";
-			buffer += this.#fitLineToWidth(lines[viewportTop + screenRow] ?? "", width);
+			buffer += this.#terminalLine(texts[screenRow] ?? "");
 			wroteLine = true;
 		}
-
-		const viewportBottomRow = viewportTop + height - 1;
-		const contentBottomRow = Math.min(viewportBottomRow, Math.max(viewportTop, lines.length - 1));
-		const parkUp = viewportBottomRow - contentBottomRow;
+		buffer += sequence;
+		// Park the hardware cursor at real content bottom, not the padded
+		// window bottom — a later height shrink would otherwise scroll live
+		// rows into scrollback and duplicate them per resize step.
+		const contentRows = Math.max(1, Math.min(height, frame.length - windowTop));
+		const parkUp = height - contentRows;
 		if (parkUp > 0) buffer += `\x1b[${parkUp}A`;
-		const { seq, toRow } = this.#cursorControlSequence(cursorPos, lines.length, contentBottomRow);
-		buffer += seq;
+		const contentBottomRow = windowTop + contentRows - 1;
+		const cursorControl = this.#cursorControlSequence(cursorPos, frame.length, contentBottomRow);
+		buffer += cursorControl.seq;
 		buffer += this.#paintEndSequence;
 		this.terminal.write(buffer);
 
-		this.#maxLinesRendered = Math.max(lines.length, viewportTop + height);
-		this.#scrollbackHighWater = appendTo;
-		this.#commit(lines, width, height, viewportTop, toRow);
+		this.#committedRows = chunkTo;
+		this.#windowTopRow = windowTop;
+		this.#commit(frame, window, width, height, cursorControl);
 	}
+
 	/**
-	 * Rewrite the visible viewport in place. Cursor home, clear each row,
-	 * emit the bottom-anchored slice of `lines`. No scrollback growth.
+	 * Enter (or extend) the non-multiplexer resize fast path. Marks the drag
+	 * active so subsequent `#doRender` calls paint viewport-only, then (re)arms
+	 * the quiet-window timer whose callback ends the drag with one authoritative
+	 * full paint. Reset on every SIGWINCH, so the full replay fires only once the
+	 * user stops dragging.
 	 */
-	#emitViewportRepaint(
-		lines: string[],
-		width: number,
-		height: number,
-		cursorPos: { row: number; col: number } | null,
-	): void {
-		this.#fullRedrawCount += 1;
-		const viewportTop = Math.max(0, lines.length - height);
-		// Each visible screen row, bottom-anchored, blank past content.
-		const visible: string[] = new Array(height);
-		for (let screenRow = 0; screenRow < height; screenRow++) {
-			visible[screenRow] = this.#fitLineToWidth(lines[viewportTop + screenRow] ?? "", width);
-		}
-		const { texts, sequence } = TERMINAL.deccara
-			? planDeccaraFills(visible, width)
-			: { texts: visible, sequence: "" };
-		let buffer = `${this.#paintBeginSequence}\x1b[H`;
-		for (let screenRow = 0; screenRow < height; screenRow++) {
-			if (screenRow > 0) buffer += "\r\n";
-			buffer += "\x1b[2K";
-			buffer += texts[screenRow];
-		}
-		// DECCARA rectangles paint the visible fills before cursor positioning;
-		// the cleared cells written above are what the rectangles repaint.
-		buffer += sequence;
-		// The loop unconditionally writes `height` rows from screen row 0, so the
-		// hardware cursor lands at the padded viewport bottom (`viewportTop +
-		// height - 1`) even when the content is shorter than the viewport and the
-		// trailing rows are blank. Parking it below the content is unsafe: a later
-		// terminal height *shrink* scrolls the live content rows up into native
-		// scrollback to keep that cursor on screen, and the next repaint redraws
-		// them — committing a duplicate copy of the visible block to history once
-		// per resize step (a drag-resize multiplies it). Move the cursor up to the
-		// real content bottom so it matches the post-paint invariant every other
-		// emitter holds and the reflow has no live rows to scroll away. The move is
-		// physical (not just tracked), so `#cursorControlSequence`'s relative
-		// `rowDelta` stays correct and the IME cursor still lands on its row after a
-		// height-grow resize.
-		const viewportBottomRow = viewportTop + height - 1;
-		const contentBottomRow = Math.min(viewportBottomRow, Math.max(viewportTop, lines.length - 1));
-		const parkUp = viewportBottomRow - contentBottomRow;
-		if (parkUp > 0) buffer += `\x1b[${parkUp}A`;
-		const { seq, toRow } = this.#cursorControlSequence(cursorPos, lines.length, contentBottomRow);
-		buffer += seq;
-		buffer += this.#paintEndSequence;
-		this.terminal.write(buffer);
-
-		this.#maxLinesRendered = lines.length;
-		this.#commit(lines, width, height, viewportTop, toRow);
+	#beginResizeViewport(): void {
+		this.#resizeViewportActive = true;
+		this.#resizeViewportSettleTimer?.cancel();
+		this.#resizeViewportSettleTimer = this.#renderScheduler.scheduleRender(() => {
+			this.#resizeViewportSettleTimer = undefined;
+			this.#resizeViewportActive = false;
+			if (this.#stopped) return;
+			// The drag is quiet: replay the rewrapped transcript authoritatively.
+			// #resizeEventPending was preserved across every viewport-only frame
+			// (the fast path never consumes it), so this classifies as a geometry
+			// rebuild — ED3 + full history — and the clearScrollback intent below
+			// matches the gesture-driven reset path.
+			this.#resizeEventPending = true;
+			this.requestRender(true, { clearScrollback: !isMultiplexerSession() });
+		}, TUI.#RESIZE_VIEWPORT_SETTLE_MS);
+	}
+
+	#requestResizeViewportPaint(): void {
+		if (this.#stopped) return;
+		this.#resizeViewportPaintPending = true;
+		this.#renderRequested = false;
+		this.#lastRenderAt = this.#renderScheduler.now();
+		this.#doRender();
+		if (this.#renderRequested) this.#scheduleRender();
 	}
 
 	/**
-	 * Foreground-stream live-region paint for ED3-risk terminals with an
-	 * unobservable viewport. Commits the newly-sealed chunk to native scrollback
-	 * (so finished blocks stay scrollable) and repaints the live tail in place,
-	 * leaving the transient live region out of saved lines.
-	 *
-	 * Uses only the no-scroll-snap vocabulary of {@link #emitDiff}: relative
-	 * cursor moves, per-line `\x1b[2K`, and `\r\n` to push the sealed chunk into
-	 * history. It deliberately avoids a full-screen erase (`\x1b[2J`) and absolute
-	 * cursor home (`\x1b[H`): on Ghostty those snap a reader scrolled into history
-	 * back to the bottom on every frame.
+	 * Compose and paint only the viewport for one resize fast-path frame.
+	 * State-isolated: advances no commit/window/diff field and calls neither
+	 * `#commit` nor `#emitFullPaint`, so the settle full paint reconciles against
+	 * the pre-drag screen state.
 	 */
-	#emitLiveRegionPinnedRepaint(
-		lines: string[],
-		width: number,
-		height: number,
-		cursorPos: { row: number; col: number } | null,
-		appendFrom: number,
-		appendTo: number,
-		renderViewportTop: number,
-		prevViewportTop: number,
-		prevHardwareCursorRow: number,
-	): void {
-		this.#fullRedrawCount += 1;
-		const naturalViewportTop = Math.max(0, lines.length - height);
-		const viewportTop = Math.max(0, Math.min(renderViewportTop, lines.length));
-		const boundedAppendTo = Math.max(0, Math.min(appendTo, naturalViewportTop, lines.length));
-		const boundedAppendFrom = Math.max(0, Math.min(appendFrom, boundedAppendTo));
-
-		// Position at the top visible row with a relative move. Terminals clamp the
-		// hardware cursor to the viewport on resize, so clamp our tracking to match
-		// before computing the delta (mirrors #emitDiff).
-		const clampedCursor = Math.min(prevHardwareCursorRow, prevViewportTop + height - 1);
-		const currentScreenRow = Math.max(0, Math.min(height - 1, clampedCursor - prevViewportTop));
-		let buffer = this.#paintBeginSequence;
-		if (currentScreenRow > 0) buffer += `\x1b[${currentScreenRow}A`;
-		buffer += "\r";
+	#renderResizeViewport(width: number, height: number): void {
+		if (width <= 0 || height <= 0) return;
+		// Tail renders call block.render(), which observes inline images on the
+		// budget. This is a STABLE (partial) pass: the tail walk is bottom-up and
+		// sees only the visible subset, so display-order-by-call-order is wrong
+		// here — `beginPass(true)` makes observe() replay the last committed
+		// live/text split per image id instead, so images keep their on-screen
+		// state through the drag. Reset the pass each frame so a long drag does
+		// not accumulate; never endPass() here — that mutates the demotion ledger
+		// off a partial walk. The settle paint's own beginPass()/endPass() is the
+		// authoritative accounting, and its beginPass() wipes these frames.
+		this.#imageBudget.beginPass(true);
+		const { window, contentRows } = this.#composeResizeViewport(width, height);
+		this.#emitResizeViewport(window, height, contentRows, width);
+		this.#resizeViewportPaintCount += 1;
+	}
 
-		// Write the sealed chunk followed by the full viewport from the top row.
-		// The first (boundedAppendTo - boundedAppendFrom) rows scroll into native
-		// history; the trailing `height` rows fill the viewport. Each row clears
-		// itself with `\x1b[2K` instead of relying on a screen-wide erase.
-		let wroteLine = false;
-		for (let i = boundedAppendFrom; i < boundedAppendTo; i++) {
-			if (wroteLine) buffer += "\r\n";
-			buffer += `\x1b[2K${this.#fitLineToWidth(lines[i] ?? "", width)}`;
-			wroteLine = true;
+	/**
+	 * Build the viewport window for a resize fast-path frame: the bottom
+	 * `height` rows of the would-be full frame, collected bottom-up across root
+	 * children. {@link ViewportTailProvider}s (the transcript) yield only their
+	 * tail; the small live-region children below render in full — so every child
+	 * entirely above the fold is skipped. A frame shorter than the viewport is
+	 * top-aligned with blank rows below, matching the full-paint window geometry
+	 * (windowTop = max(0, frameLength - height)). Cursor markers are stripped
+	 * (the drag hides the hardware cursor) and rows are width-fitted via the
+	 * stateless preparer, so no persistent prepared-frame cache is touched.
+	 */
+	#composeResizeViewport(width: number, height: number): { window: readonly string[]; contentRows: number } {
+		const tail: string[] = []; // bottom-first
+		const children = this.children;
+		for (let i = children.length - 1; i >= 0 && tail.length < height; i--) {
+			const child = children[i]!;
+			const provider = asViewportTailProvider(child);
+			const rows = provider ? provider.renderViewportTail(width, height - tail.length) : child.render(width);
+			for (let r = rows.length - 1; r >= 0 && tail.length < height; r--) {
+				tail.push(rows[r]!);
+			}
 		}
+		const count = tail.length;
+		const window: string[] = new Array(height);
 		for (let screenRow = 0; screenRow < height; screenRow++) {
-			if (wroteLine) buffer += "\r\n";
-			buffer += `\x1b[2K${this.#fitLineToWidth(lines[viewportTop + screenRow] ?? "", width)}`;
-			wroteLine = true;
+			// `tail` holds the bottom `count` frame rows, bottom-first. They fill
+			// the viewport when the frame overflows it and sit at the top (blanks
+			// below) when it underflows.
+			window[screenRow] = screenRow < count ? tail[count - 1 - screenRow]! : "";
 		}
+		this.#extractCursorMarkers(window);
+		return { window: this.#prepareLinesArray(window, width), contentRows: count };
+	}
 
-		const viewportBottomRow = viewportTop + height - 1;
-		const contentBottomRow = Math.min(viewportBottomRow, Math.max(viewportTop, lines.length - 1));
-		const parkUp = viewportBottomRow - contentBottomRow;
-		if (parkUp > 0) buffer += `\x1b[${parkUp}A`;
-		const { seq, toRow } = this.#cursorControlSequence(cursorPos, lines.length, contentBottomRow);
-		buffer += seq;
-		buffer += this.#paintEndSequence;
-		this.terminal.write(buffer);
+	/** Enter or leave the alternate screen borrowed for transient resize frames. */
+	#enterResizeAltSequence(): string {
+		if (this.#resizeAltActive || this.#altActive) return "";
+		this.#resizeAltActive = true;
+		setAltScreenActive(true);
+		this.#forgetHardwareCursorState();
+		this.#recordHardwareCursorHidden();
+		return `${ALT_SCREEN_ENTER}${this.terminal.kittyEnableSequence ?? ""}`;
+	}
 
-		this.#maxLinesRendered = Math.max(lines.length, viewportTop + height);
-		if (boundedAppendTo > this.#scrollbackHighWater) {
-			this.#scrollbackHighWater = boundedAppendTo;
-		}
-		this.#commit(lines, width, height, viewportTop, toRow);
+	#leaveResizeAltSequence(): string {
+		if (!this.#resizeAltActive) return "";
+		const kittyPop = this.terminal.kittyEnableSequence ? "\x1b[<u" : "";
+		this.#resizeAltActive = false;
+		setAltScreenActive(false);
+		this.#forgetHardwareCursorState();
+		return `${kittyPop}${ALT_SCREEN_EXIT}`;
 	}
 
 	/**
-	 * Push the appended tail into terminal scrollback by `\r\n`-ing past the
-	 * previous viewport bottom. Used as a prefix to {@link #emitViewportRepaint}
-	 * when an offscreen edit and an append land in the same frame; does not
-	 * call {@link #commit} (the following repaint owns final state).
+	 * Emit a throwaway viewport repaint for the resize fast path as an alternate-
+	 * screen per-row overwrite. The normal buffer may reflow full-width rows on a
+	 * width change before the app can repaint; keeping the drag on the alternate
+	 * screen makes those transient resizes truncate instead of pushing wrapped
+	 * fragments into native scrollback. Normal-screen history is rebuilt once at
+	 * settle via `#emitFullPaint`.
 	 */
-	#emitAppendTail(
-		lines: string[],
-		start: number,
-		height: number,
-		width: number,
-		prevViewportTop: number,
-		prevHardwareCursorRow: number,
-	): void {
-		if (start >= lines.length) return;
-		let buffer = this.#paintBeginSequence;
-		// Clamp tracked cursor to the visible viewport bottom — terminals clamp
-		// on resize, so a prior frame may have committed a row that no longer
-		// exists. Without this the scroll math points outside the viewport.
-		const clampedCursor = Math.min(prevHardwareCursorRow, prevViewportTop + height - 1);
-		const currentScreenRow = Math.max(0, Math.min(height - 1, clampedCursor - prevViewportTop));
-		const moveToBottom = height - 1 - currentScreenRow;
-		if (moveToBottom > 0) buffer += `\x1b[${moveToBottom}B`;
-		for (let i = start; i < lines.length; i++) {
-			buffer += "\r\n";
-			buffer += this.#fitLineToWidth(lines[i], width);
-		}
+	#emitResizeViewport(window: readonly string[], height: number, contentRows: number, width: number): void {
+		let buffer = `${this.#paintBeginSequence + this.#enterResizeAltSequence()}\x1b[H`;
+		for (let r = 0; r < height; r++) {
+			if (r > 0) buffer += "\r\n";
+			buffer += this.#lineRewriteSequence(window[r] ?? "", width);
+		}
+		// Park the hardware cursor at the real content bottom, not the padded
+		// viewport bottom: a later height shrink would otherwise scroll the live
+		// rows below the cursor into native scrollback and duplicate them until
+		// the settle rebuild erases it.
+		const parkUp = height - Math.max(1, contentRows);
+		if (parkUp > 0) buffer += `\x1b[${parkUp}A`;
 		buffer += this.#paintEndSequence;
 		this.terminal.write(buffer);
-		const pushedNow = Math.max(0, lines.length - height);
-		if (pushedNow > this.#scrollbackHighWater) {
-			this.#scrollbackHighWater = pushedNow;
+	}
+
+	/** Topmost visible overlay requests the alternate-screen buffer. */
+	#wantsAltScreen(): boolean {
+		for (let i = this.overlayStack.length - 1; i >= 0; i--) {
+			const entry = this.overlayStack[i]!;
+			if (!this.#isOverlayVisible(entry)) continue;
+			return entry.options?.fullscreen === true;
 		}
+		return false;
 	}
 
 	/**
-	 * Paint only the active-grid bottom row while a scrollback mutation remains
-	 * deferred. If the native viewport is unknown and the user is scrolled up by a
-	 * single line, every active-grid row except the bottom can still be visible in
-	 * their scrollback window; touching only this row keeps that reader's viewport
-	 * unchanged while allowing bottom-anchored live chrome (spinner/status tail) to
-	 * advance for users at the tail.
+	 * Compose and paint a single fullscreen overlay frame on the alt buffer.
+	 * Cursor markers are stripped (the modal draws its own in-band caret and
+	 * keeps the hardware cursor hidden), and only the modal is composited over a
+	 * blank base — the transcript is never touched while the alt buffer is up.
 	 */
-	#emitDeferredTailRepaint(
-		line: string,
-		width: number,
-		height: number,
-		row: number,
-		prevViewportTop: number,
-		prevHardwareCursorRow: number,
-	): void {
-		const viewportBottom = prevViewportTop + height - 1;
-		if (row !== viewportBottom) return;
-
-		let buffer = this.#paintBeginSequence;
-		const clampedCursor = Math.min(prevHardwareCursorRow, viewportBottom);
-		const currentScreenRow = Math.max(0, Math.min(height - 1, clampedCursor - prevViewportTop));
-		const moveDown = height - 1 - currentScreenRow;
-		if (moveDown > 0) buffer += `\x1b[${moveDown}B`;
-		buffer += `\r\x1b[2K${this.#fitLineToWidth(line, width)}\x1b[?25l`;
-		buffer += this.#paintEndSequence;
-		this.terminal.write(buffer);
-
-		this.#deferredTailLine = line;
-		this.#previousWidth = width;
-		this.#previousHeight = height;
-		this.#viewportTopRow = prevViewportTop;
-		this.#hardwareCursorRow = row;
+	#renderAltFrame(width: number, height: number): void {
+		const base: string[] = new Array(Math.max(0, height)).fill("");
+		let lines = this.#compositeOverlaysIntoWindow(base, width, height);
+		this.#extractCursorMarkers(lines);
+		lines = this.#prepareLinesArray(lines, width);
+		this.#emitAltFrame(lines, width, height);
 	}
 
 	/**
-	 * Trailing-shrink: prior content shared a prefix with the new content; the
-	 * extra rows below the new tail need to be cleared without scrolling. Falls
-	 * back to {@link #emitViewportRepaint} when more rows must be cleared than
-	 * fit on screen.
+	 * Full per-row viewport rewrite on the alt buffer. Emits only sync-output
+	 * brackets, a cursor home, and per-row rewrites — never ED3, append-tail, or
+	 * any native-scrollback byte, so it is fully isolated from the planner and
+	 * #commit. The hardware cursor stays hidden (it is never re-shown here).
 	 */
-	#emitShrink(
-		lines: string[],
-		width: number,
-		height: number,
-		cursorPos: { row: number; col: number } | null,
-		prevHardwareCursorRow: number,
-		prevViewportTop: number,
-	): void {
-		const extraLines = this.#previousLines.length - lines.length;
-		if (extraLines <= 0) {
-			this.#commit(lines, width, height, Math.max(0, lines.length - height), prevHardwareCursorRow);
-			this.#maxLinesRendered = lines.length;
-			return;
-		}
-		if (extraLines > height) {
-			this.#emitViewportRepaint(lines, width, height, cursorPos);
-			return;
-		}
-
-		const viewportTop = Math.max(0, this.#maxLinesRendered - height);
-		const targetRow = Math.max(0, lines.length - 1);
-
-		let buffer = this.#paintBeginSequence;
-
-		const clampedCursor = Math.min(prevHardwareCursorRow, prevViewportTop + height - 1);
-		const currentScreenRow = clampedCursor - prevViewportTop;
-		const targetScreenRow = targetRow - viewportTop;
-		const lineDiff = targetScreenRow - currentScreenRow;
-		if (lineDiff > 0) buffer += `\x1b[${lineDiff}B`;
-		else if (lineDiff < 0) buffer += `\x1b[${-lineDiff}A`;
-		buffer += "\r";
-
-		const clearStartOffset = lines.length > 0 ? 1 : 0;
-		if (clearStartOffset > 0) {
-			buffer += `\x1b[${clearStartOffset}B`;
+	#emitAltFrame(lines: string[], width: number, height: number): void {
+		const fitted: string[] = new Array(height);
+		for (let r = 0; r < height; r++) fitted[r] = lines[r] ?? "";
+		// Flush queued image-data transmits (`a=t`, no visible output) before the
+		// paint so id-keyed placements and placeholder cells composed into this
+		// frame resolve against loaded data. The normal-screen path flushes these
+		// ahead of its paint; without this, an image first shown inside a
+		// fullscreen overlay (e.g. the settings shape preview) would render as
+		// blank placeholder cells until the overlay closed.
+		const imageTransmits = this.#imageBudget.takeTransmits();
+		if (imageTransmits.length > 0) {
+			let transmitBuffer = "";
+			for (const seq of imageTransmits) transmitBuffer += seq;
+			this.terminal.write(transmitBuffer);
 		}
-		for (let i = 0; i < extraLines; i++) {
-			buffer += "\r\x1b[2K";
-			if (i < extraLines - 1) buffer += "\x1b[1B";
+		// Skip an identical repaint (the modal is mostly static between
+		// keystrokes) — unless a forced repaint (resetDisplay,
+		// requestRender(true)) is pending: the redraw gesture must repair a
+		// corrupted modal even when our cached frame is byte-identical.
+		const force = this.#forceViewportRepaintOnNextRender;
+		this.#forceViewportRepaintOnNextRender = false;
+		if (!force && this.#altPreviousLines.length === height) {
+			let same = true;
+			for (let r = 0; r < height; r++) {
+				if (fitted[r] !== this.#altPreviousLines[r]) {
+					same = false;
+					break;
+				}
+			}
+			if (same) return;
 		}
-		const moveUp = extraLines - 1 + clearStartOffset;
-		if (moveUp > 0) {
-			buffer += `\x1b[${moveUp}A`;
+		let buffer = `${this.#paintBeginSequence}\x1b[H`;
+		for (let r = 0; r < height; r++) {
+			if (r > 0) buffer += "\r\n";
+			buffer += this.#lineRewriteSequence(fitted[r], width);
 		}
-
-		const { seq, toRow } = this.#cursorControlSequence(cursorPos, lines.length, targetRow);
-		buffer += seq;
 		buffer += this.#paintEndSequence;
 		this.terminal.write(buffer);
-
-		this.#maxLinesRendered = lines.length;
-		this.#commit(lines, width, height, Math.max(0, lines.length - height), toRow);
+		this.#altPreviousLines = fitted;
+		this.#fullRedrawCount += 1;
 	}
 
 	/**
-	 * Differential rewrite from `firstChanged` through `lastChanged`. Handles
-	 * three sub-shapes: pure append below the prior viewport (scroll + write),
-	 * in-place replace of visible rows, and replace-plus-trailing-shrink (clear
-	 * extras after writing). Cursor math is local to this method.
+	 * Incremental frame update. Three byte shapes:
+	 *
+	 * - scroll-append: the rows leaving the screen are exactly the newly
+	 *   committed chunk, already painted with final content — emit `\r\n` plus
+	 *   the new bottom rows, then rewrite whatever else changed in place;
+	 * - in-window diff: nothing scrolls, nothing commits — rewrite the changed
+	 *   row range (cursor-only when nothing changed);
+	 * - seam rewrite: write the chunk at the scrollback seam, then rewrite the
+	 *   whole window (live-region re-layout, hidden-gap backfill, mux resize).
+	 *
+	 * Only chunk rows ever enter native history; the live window repaints in
+	 * place with relative moves. This path never emits ED2/ED3 or an absolute
+	 * cursor home — those snap a reader scrolled into history back to the
+	 * bottom on several terminal families.
 	 */
-	#emitDiff(
-		lines: string[],
+	#emitUpdate(
+		frame: readonly string[],
+		window: string[],
 		width: number,
 		height: number,
 		cursorPos: { row: number; col: number } | null,
-		firstChanged: number,
-		lastChanged: number,
-		appendedLines: boolean,
-		prevViewportTop: number,
-		prevHardwareCursorRow: number,
+		purgeSequence: string,
+		options: {
+			chunkTo: number;
+			windowTop: number;
+			prevWindowTop: number;
+			prevHardwareCursorRow: number;
+			forceWindowRewrite: boolean;
+		},
 	): void {
-		let viewportTop = Math.max(0, this.#maxLinesRendered - height);
-		let activeViewportTop = prevViewportTop;
-		// Terminals clamp the hardware cursor to the visible viewport on resize.
-		// If our tracked row is past the viewport bottom, the real cursor was
-		// clamped; clamp our tracking to match so relative moves land correctly.
-		let hardwareCursorRow = Math.min(prevHardwareCursorRow, activeViewportTop + height - 1);
-
-		const appendStart = appendedLines && firstChanged === this.#previousLines.length && firstChanged > 0;
-		const moveTargetRow = appendStart ? firstChanged - 1 : firstChanged;
-
-		let buffer = this.#paintBeginSequence;
-
-		// Scroll-down branch: target row is past the bottom of the previous
-		// viewport (a pure append). Emit `\r\n`s so the terminal pushes the
-		// existing viewport into scrollback before we start writing.
-		const prevViewportBottom = activeViewportTop + height - 1;
-		if (moveTargetRow > prevViewportBottom) {
-			const currentScreenRow = Math.max(0, Math.min(height - 1, hardwareCursorRow - activeViewportTop));
-			const moveToBottom = height - 1 - currentScreenRow;
-			if (moveToBottom > 0) buffer += `\x1b[${moveToBottom}B`;
-			const scroll = moveTargetRow - prevViewportBottom;
-			buffer += "\r\n".repeat(scroll);
-			activeViewportTop += scroll;
-			viewportTop += scroll;
-			hardwareCursorRow = moveTargetRow;
-		}
-
-		// Position cursor at the row we need to start writing from.
-		const currentScreenRow = hardwareCursorRow - activeViewportTop;
-		const targetScreenRow = moveTargetRow - viewportTop;
-		const lineDiff = targetScreenRow - currentScreenRow;
-		if (lineDiff > 0) buffer += `\x1b[${lineDiff}B`;
-		else if (lineDiff < 0) buffer += `\x1b[${-lineDiff}A`;
-		buffer += appendStart ? "\r\n" : "\r";
-
-		// Repaint only firstChanged..lastChanged, not all rows to the end.
-		// This bounds flicker for single-row updates (e.g. spinner ticks).
-		const renderEnd = Math.min(lastChanged, lines.length - 1);
-		// Optimize the in-place rewrite of a contiguous visible row range with
-		// DECCARA. The rectangle coordinates are absolute screen rows, so two
-		// effects that the relatively-positioned text absorbs transparently must
-		// be folded into the coordinates explicitly:
-		//   1. Writing rows past the viewport bottom scrolls the terminal, so the
-		//      rewritten rows settle `scrollAmount` rows higher than where they
-		//      were first painted. The rectangles must target the post-scroll rows.
-		//   2. Rows pushed into history keep their full background padding (DECCARA
-		//      cannot reach scrollback), so only rows that remain in the final
-		//      viewport are shortened and repainted.
-		// The append/scroll branch (`moveTargetRow > prevViewportBottom`) already
-		// pushed rows into history and is excluded.
-		const scrollAmount = Math.max(0, renderEnd - viewportTop - (height - 1));
-		const fillViewportTop = viewportTop + scrollAmount;
-		const fillStart = Math.max(firstChanged, fillViewportTop);
-		let fillSequence = "";
-		let fillTexts: string[] | null = null;
-		if (TERMINAL.deccara && !appendStart && moveTargetRow <= prevViewportBottom && renderEnd >= fillStart) {
-			const slice: string[] = new Array(renderEnd - fillStart + 1);
-			for (let i = fillStart; i <= renderEnd; i++) {
-				slice[i - fillStart] = this.#fitLineToWidth(lines[i], width);
+		const { chunkTo, windowTop, prevWindowTop, prevHardwareCursorRow, forceWindowRewrite } = options;
+		const chunkFrom = this.#committedRows;
+		const chunkLength = chunkTo - chunkFrom;
+		const scroll = windowTop - prevWindowTop;
+		const previousWindow = this.#previousWindow;
+		const contentRows = Math.max(1, Math.min(height, frame.length - windowTop));
+		const contentBottomRow = windowTop + contentRows - 1;
+		// Terminals clamp the hardware cursor to the viewport on resize; clamp
+		// our tracking to match so relative moves land correctly.
+		const clampedCursor = Math.min(prevHardwareCursorRow, prevWindowTop + height - 1);
+		const currentScreenRow = Math.max(0, Math.min(height - 1, clampedCursor - prevWindowTop));
+
+		// Scroll-append: committing exactly the rows that scroll off the top,
+		// with content untouched since they were painted.
+		if (
+			!forceWindowRewrite &&
+			chunkLength > 0 &&
+			chunkLength === scroll &&
+			scroll < height &&
+			chunkFrom === prevWindowTop
+		) {
+			let prefixIntact = previousWindow.length === height;
+			for (let i = 0; prefixIntact && i < chunkLength; i++) {
+				if (previousWindow[i] !== frame[chunkFrom + i]) prefixIntact = false;
 			}
-			const plan = planDeccaraFills(slice, width, fillStart - fillViewportTop);
-			fillTexts = plan.texts;
-			fillSequence = plan.sequence;
-		}
-		for (let i = firstChanged; i <= renderEnd; i++) {
-			if (i > firstChanged) buffer += "\r\n";
-			buffer += "\x1b[2K";
-			buffer += fillTexts && i >= fillStart ? fillTexts[i - fillStart] : this.#fitLineToWidth(lines[i], width);
-		}
-
-		// If the prior frame was taller, clear the trailing rows.
-		let finalCursorRow = renderEnd;
-		if (this.#previousLines.length > lines.length) {
-			if (renderEnd < lines.length - 1) {
-				const moveDown = lines.length - 1 - renderEnd;
-				buffer += `\x1b[${moveDown}B`;
-				finalCursorRow = lines.length - 1;
+			if (prefixIntact) {
+				let buffer = this.#paintBeginSequence + purgeSequence;
+				const moveToBottom = height - 1 - currentScreenRow;
+				if (moveToBottom > 0) buffer += `\x1b[${moveToBottom}B`;
+				for (let r = height - scroll; r < height; r++) {
+					buffer += `\r\n${this.#lineRewriteSequence(window[r] ?? "", width)}`;
+				}
+				// Rewrite any remaining changed rows after the shift.
+				let firstChanged = -1;
+				let lastChanged = -1;
+				for (let r = 0; r < height - scroll; r++) {
+					if ((window[r] ?? "") === (previousWindow[r + scroll] ?? "")) continue;
+					if (firstChanged === -1) firstChanged = r;
+					lastChanged = r;
+				}
+				let cursorFromRow = windowTop + height - 1;
+				if (firstChanged !== -1) {
+					const up = height - 1 - firstChanged;
+					if (up > 0) buffer += `\x1b[${up}A`;
+					buffer += "\r";
+					for (let r = firstChanged; r <= lastChanged; r++) {
+						if (r > firstChanged) buffer += "\r\n";
+						buffer += this.#lineRewriteSequence(window[r] ?? "", width);
+					}
+					cursorFromRow = windowTop + lastChanged;
+				}
+				const cursorControl = this.#cursorControlSequence(cursorPos, frame.length, cursorFromRow);
+				buffer += cursorControl.seq;
+				buffer += this.#paintEndSequence;
+				this.terminal.write(buffer);
+				this.#committedRows = chunkTo;
+				this.#windowTopRow = windowTop;
+				this.#commit(frame, window, width, height, cursorControl);
+				return;
+			}
+		}
+
+		// In-window diff: nothing scrolls, nothing commits.
+		if (chunkLength === 0 && scroll === 0) {
+			if (forceWindowRewrite) this.#fullRedrawCount += 1;
+			let firstChanged = forceWindowRewrite ? 0 : -1;
+			let lastChanged = forceWindowRewrite ? height - 1 : -1;
+			if (!forceWindowRewrite) {
+				const comparable = previousWindow.length === height;
+				for (let r = 0; r < height; r++) {
+					if (comparable && (window[r] ?? "") === (previousWindow[r] ?? "")) continue;
+					if (firstChanged === -1) firstChanged = r;
+					lastChanged = r;
+				}
+			}
+			if (firstChanged === -1) {
+				if (purgeSequence.length > 0) this.terminal.write(purgeSequence);
+				this.#writeCursorPosition(cursorPos, frame.length);
+				this.#previousWidth = width;
+				this.#previousHeight = height;
+				return;
+			}
+			let buffer = this.#paintBeginSequence + purgeSequence;
+			const rowDelta = firstChanged - currentScreenRow;
+			if (rowDelta > 0) buffer += `\x1b[${rowDelta}B`;
+			else if (rowDelta < 0) buffer += `\x1b[${-rowDelta}A`;
+			buffer += "\r";
+			// DECCARA-optimize the contiguous rewritten range (visible rows
+			// only; rectangles are absolute screen rows).
+			let fillTexts: string[] | null = null;
+			let fillSequence = "";
+			if (this.#deccaraFillsEnabled()) {
+				const slice: string[] = new Array(lastChanged - firstChanged + 1);
+				for (let r = firstChanged; r <= lastChanged; r++) slice[r - firstChanged] = window[r] ?? "";
+				const plan = planDeccaraFills(slice, width, firstChanged);
+				fillTexts = plan.texts;
+				fillSequence = plan.sequence;
+			}
+			for (let r = firstChanged; r <= lastChanged; r++) {
+				if (r > firstChanged) buffer += "\r\n";
+				buffer += this.#lineRewriteSequence(fillTexts ? fillTexts[r - firstChanged] : (window[r] ?? ""), width);
 			}
-			const extraLines = this.#previousLines.length - lines.length;
-			for (let i = lines.length; i < this.#previousLines.length; i++) {
-				buffer += "\r\n\x1b[2K";
+			buffer += fillSequence;
+			// Never park below real content (a height shrink would scroll live
+			// rows into history and duplicate them per resize step).
+			let cursorFromRow = windowTop + lastChanged;
+			const contentBottomScreenRow = contentBottomRow - windowTop;
+			if (lastChanged > contentBottomScreenRow) {
+				buffer += `\x1b[${lastChanged - contentBottomScreenRow}A`;
+				cursorFromRow = contentBottomRow;
 			}
-			buffer += `\x1b[${extraLines}A`;
+			const cursorControl = this.#cursorControlSequence(cursorPos, frame.length, cursorFromRow);
+			buffer += cursorControl.seq;
+			buffer += this.#paintEndSequence;
+			this.terminal.write(buffer);
+			this.#commit(frame, window, width, height, cursorControl);
+			return;
 		}
-		// DECCARA rectangles for the rewritten visible fills. Absolute-positioned,
-		// so emitting them after the trailing-shrink cursor moves is safe.
-		buffer += fillSequence;
 
-		const { seq, toRow } = this.#cursorControlSequence(cursorPos, lines.length, finalCursorRow);
-		buffer += seq;
+		// Seam rewrite: write the chunk into history, then the whole window.
+		// Cursor moves to the window top with a relative move; the chunk rows
+		// pass through the screen and scroll off as the window rows are written
+		// below them, so the rows entering scrollback are exactly the chunk.
+		this.#fullRedrawCount += 1;
+		let buffer = this.#paintBeginSequence + purgeSequence;
+		if (currentScreenRow > 0) buffer += `\x1b[${currentScreenRow}A`;
+		buffer += "\r";
+		let wroteLine = false;
+		for (let i = chunkFrom; i < chunkTo; i++) {
+			if (wroteLine) buffer += "\r\n";
+			buffer += this.#lineRewriteSequence(frame[i] ?? "", width);
+			wroteLine = true;
+		}
+		for (let screenRow = 0; screenRow < height; screenRow++) {
+			if (wroteLine) buffer += "\r\n";
+			buffer += this.#lineRewriteSequence(window[screenRow] ?? "", width);
+			wroteLine = true;
+		}
+		const parkUp = height - 1 - (contentBottomRow - windowTop);
+		if (parkUp > 0) buffer += `\x1b[${parkUp}A`;
+		const cursorControl = this.#cursorControlSequence(cursorPos, frame.length, contentBottomRow);
+		buffer += cursorControl.seq;
 		buffer += this.#paintEndSequence;
-
-		this.#writeDiffDebug(
-			lines,
-			firstChanged,
-			viewportTop,
-			height,
-			lineDiff,
-			hardwareCursorRow,
-			renderEnd,
-			finalCursorRow,
-			cursorPos,
-			toRow,
-			buffer,
-		);
 		this.terminal.write(buffer);
-
-		this.#maxLinesRendered = lines.length;
-		if (lines.length > this.#previousLines.length) {
-			const pushedNow = Math.max(0, lines.length - height);
-			if (pushedNow > this.#scrollbackHighWater) {
-				this.#scrollbackHighWater = pushedNow;
-			}
-		}
-		this.#commit(lines, width, height, Math.max(0, lines.length - height), toRow);
+		this.#committedRows = chunkTo;
+		this.#windowTopRow = windowTop;
+		this.#commit(frame, window, width, height, cursorControl);
 	}
 
 	/** Optional intent log under PROMETHEUS_DEBUG_REDRAW. */
 	#logRedraw(intent: RenderIntent, newLength: number, height: number): void {
 		if (!$flag("PROMETHEUS_DEBUG_REDRAW")) return;
 		const detail =
-			intent.kind === "diff"
-				? `${intent.kind}(first=${intent.firstChanged}, last=${intent.lastChanged}, appended=${intent.appendedLines})`
-				: intent.kind === "liveRegionPinned"
-					? `${intent.kind}(append=${intent.appendFrom}..${intent.appendTo}, viewportTop=${intent.renderViewportTop})`
-					: intent.kind === "viewportRepaint" && intent.appendFrom !== undefined
-						? `${intent.kind}(appendFrom=${intent.appendFrom})`
-						: intent.kind === "deferredTailRepaint"
-							? `${intent.kind}(row=${intent.row})`
-							: intent.kind;
-		const msg = `[${new Date().toISOString()}] render: ${detail} (prev=${this.#previousLines.length}, new=${newLength}, height=${height})\n`;
+			intent.kind === "update"
+				? `update(chunk=${this.#committedRows}..${intent.chunkTo}, windowTop=${intent.windowTop})`
+				: `fullPaint(clearScrollback=${intent.clearScrollback})`;
+		const state =
+			`committed=${this.#committedRows}, windowTop=${this.#windowTopRow}, ` +
+			`lrStart=${this.#nativeScrollbackLiveRegionStart}, commitSafeEnd=${this.#nativeScrollbackCommitSafeEnd}`;
+		const msg = `[${new Date().toISOString()}] render: ${detail} (prev=${this.#previousFrameLength}, new=${newLength}, height=${height}, ${state})\n`;
 		fs.appendFileSync(getDebugLogPath(), msg);
 	}
 
-	/** Optional per-render dump under PROMETHEUS_TUI_DEBUG; isolated so #emitDiff stays readable. */
-	#writeDiffDebug(
-		lines: string[],
-		firstChanged: number,
-		viewportTop: number,
-		height: number,
-		lineDiff: number,
-		hardwareCursorRow: number,
-		renderEnd: number,
-		finalCursorRow: number,
-		cursorPos: { row: number; col: number } | null,
-		toRow: number,
-		buffer: string,
-	): void {
-		if (!$flag("PROMETHEUS_TUI_DEBUG")) return;
-		const debugDir = "/tmp/tui";
-		fs.mkdirSync(debugDir, { recursive: true });
-		const debugPath = path.join(debugDir, `render-${Date.now()}-${Math.random().toString(36).slice(2)}.log`);
-		const debugData = [
-			`firstChanged: ${firstChanged}`,
-			`viewportTop: ${viewportTop}`,
-			`cursorRow: ${this.#cursorRow}`,
-			`height: ${height}`,
-			`lineDiff: ${lineDiff}`,
-			`hardwareCursorRow: ${hardwareCursorRow}`,
-			`hardwareCursorRow (post): ${toRow}`,
-			`renderEnd: ${renderEnd}`,
-			`finalCursorRow: ${finalCursorRow}`,
-			`cursorPos: ${JSON.stringify(cursorPos)}`,
-			`newLines.length: ${lines.length}`,
-			`previousLines.length: ${this.#previousLines.length}`,
-			"",
-			"=== newLines ===",
-			JSON.stringify(lines, null, 2),
-			"",
-			"=== previousLines ===",
-			JSON.stringify(this.#previousLines, null, 2),
-			"",
-			"=== buffer ===",
-			JSON.stringify(buffer),
-		].join("\n");
-		fs.writeFileSync(debugPath, debugData);
-	}
-
 	/**
 	 * Build cursor control sequences to position the hardware cursor for the IME
 	 * candidate window. Returns escape sequences and the resulting cursor row for
@@ -2948,16 +3314,15 @@ export class TUI extends Container {
 		cursorPos: { row: number; col: number } | null,
 		totalLines: number,
 		fromRow: number,
-	): { seq: string; toRow: number } {
-		// No IME target or no content — hide cursor regardless of preference
-		if (!cursorPos || totalLines <= 0) return { seq: "\x1b[?25l", toRow: fromRow };
-
-		// Clamp cursor position to valid range
-		const targetRow = Math.max(0, Math.min(cursorPos.row, totalLines - 1));
-		const targetCol = Math.max(0, cursorPos.col);
+	): CursorControlResult {
+		// No IME target or no content — hide cursor regardless of preference.
+		const target = this.#targetHardwareCursorState(cursorPos, totalLines);
+		if (!target) {
+			return { seq: "\x1b[?25l", toRow: fromRow, toCol: 0, visible: false, state: null };
+		}
 
-		// Move cursor from current position to target
-		const rowDelta = targetRow - fromRow;
+		// Move cursor from current position to target.
+		const rowDelta = target.row - fromRow;
 		let seq = "";
 		if (rowDelta > 0) {
 			seq += `\x1b[${rowDelta}B`; // Move down
@@ -2965,10 +3330,14 @@ export class TUI extends Container {
 			seq += `\x1b[${-rowDelta}A`; // Move up
 		}
 		// Move to absolute column (1-indexed)
-		seq += `\x1b[${targetCol + 1}G`;
-		seq += this.#showHardwareCursor ? "\x1b[?25h" : "\x1b[?25l";
+		seq += `\x1b[${target.col + 1}G`;
+		seq += target.visible ? "\x1b[?25h" : "\x1b[?25l";
+
+		return { seq, toRow: target.row, toCol: target.col, visible: target.visible, state: target };
+	}
 
-		return { seq, toRow: targetRow };
+	#isHiddenCursorKnown(): boolean {
+		return this.#hardwareCursorVisibilityKnown && !this.#hardwareCursorVisible;
 	}
 
 	/**
@@ -2977,12 +3346,16 @@ export class TUI extends Container {
 	 * to embed the sequences into.
 	 */
 	#writeCursorPosition(cursorPos: { row: number; col: number } | null, totalLines: number): void {
-		if (!cursorPos || totalLines <= 0) {
+		const target = this.#targetHardwareCursorState(cursorPos, totalLines);
+		if (!target) {
+			if (this.#isHiddenCursorKnown()) return;
 			this.terminal.hideCursor();
+			this.#recordHardwareCursorHidden();
 			return;
 		}
-		const { seq, toRow } = this.#cursorControlSequence(cursorPos, totalLines, this.#hardwareCursorRow);
-		this.#hardwareCursorRow = toRow;
-		this.terminal.write(`${this.#cursorBeginSequence}${seq}${this.#cursorEndSequence}`);
+		if (this.#sameHardwareCursorState(target)) return;
+		const cursorControl = this.#cursorControlSequence(cursorPos, totalLines, this.#hardwareCursorRow);
+		this.terminal.write(`${this.#cursorBeginSequence}${cursorControl.seq}${this.#cursorEndSequence}`);
+		this.#recordHardwareCursorUpdate(cursorControl);
 	}
 }