@oh-my-pi/pi-tui 18.4.2 → 18.4.3

package/src/status-line/component.ts

@@ -48,6 +48,13 @@ import type {
 	StatusLineSettings,
 } from "./types";
 
+/**
+ * Freshness window for the git segment's working-tree counts. A whole-worktree
+ * `git status` costs ~1 CPU-second on large repos and every open session polls
+ * it, so edits surface within this window; HEAD moves refetch immediately via
+ * {@link StatusLineComponent.invalidateGitCaches}.
+ */
+const GIT_STATUS_TTL_MS = 10_000;
 const JJ_REFRESH_TTL_MS = 5000;
 const JJ_COMMAND_TIMEOUT_MS = 5_000;
 const WATCHER_FAILURE_POLL_TTL_MS = 5000;
@@ -586,6 +593,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 	#cachedGitStatus: { staged: number; unstaged: number; untracked: number } | null = null;
 	#cachedGitStatusCwd: string | undefined = undefined;
 	#gitStatusLastFetch = 0;
+	#gitStatusGeneration = 0;
 	#gitStatusInFlightCwd: string | undefined = undefined;
 	#cachedJjBranch: string | null = null;
 	#jjBranchLastFetch = 0;
@@ -1254,6 +1262,11 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		this.#branchLastFetch = undefined;
 		this.#branchCacheGeneration++;
 		this.#cachedPrContext = undefined;
+		// A HEAD move (commit, checkout, reset) changes the dirty counts; keep the
+		// stale counts on screen but refetch on the next render. The generation
+		// bump stops an in-flight pre-move result from re-stamping freshness.
+		this.#gitStatusLastFetch = 0;
+		this.#gitStatusGeneration++;
 		// jj label/status share the git segment's lifecycle: a HEAD move (e.g. a
 		// colocated `jj new`/bookmark move) must drop the throttled jj caches too,
 		// so the next render refetches.
@@ -1493,11 +1506,12 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 		if (this.#gitStatusInFlightCwd !== undefined) {
 			return this.#cachedGitStatusCwd === gitCwd ? this.#cachedGitStatus : null;
 		}
-		if (this.#cachedGitStatusCwd === gitCwd && Date.now() - this.#gitStatusLastFetch < 1000) {
+		if (this.#cachedGitStatusCwd === gitCwd && Date.now() - this.#gitStatusLastFetch < GIT_STATUS_TTL_MS) {
 			return this.#cachedGitStatus;
 		}
 
 		this.#gitStatusInFlightCwd = gitCwd;
+		const generation = this.#gitStatusGeneration;
 
 		(async () => {
 			let nextStatus: { staged: number; unstaged: number; untracked: number } | null = null;
@@ -1510,7 +1524,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 					const prev = this.#cachedGitStatusCwd === gitCwd ? this.#cachedGitStatus : null;
 					this.#cachedGitStatus = nextStatus;
 					this.#cachedGitStatusCwd = gitCwd;
-					this.#gitStatusLastFetch = Date.now();
+					this.#gitStatusLastFetch = this.#gitStatusGeneration === generation ? Date.now() : 0;
 					this.#gitStatusInFlightCwd = undefined;
 					if (!this.#disposed && JSON.stringify(prev) !== JSON.stringify(nextStatus)) {
 						this.#invalidateStatusLineRenderCache();

package/src/stdin-buffer.ts

@@ -424,11 +424,11 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	#rawPasteCandidate = "";
 	#rawPasteTimer?: NodeJS.Timeout;
 	// Unbracketed raw-paste classification is a fallback for terminals that do
-	// not wrap pastes in DECSET 2004 markers. When the terminal confirms mode
-	// 2004 support, a genuine paste always arrives bracketed, so the heuristic
-	// can only misfire on keystrokes an event-loop stall batched into one read
-	// (issue #12540) — Terminal disables it via `setRawPasteClassification`.
-	#rawPasteClassificationEnabled = true;
+	// not wrap pastes in DECSET 2004 markers. Once the terminal confirms mode
+	// 2004, Terminal installs this probe: an unmarked multiline burst is then
+	// an input-method commit (#13344) unless an event-loop stall batched the
+	// keystrokes into one read (#12540). See `setRawPasteStallProbe`.
+	#rawPasteStallProbe?: () => boolean;
 	#stringDiscardActive = false;
 	#stringDiscardBytes = 0;
 	#stringDiscardEscHeld = false;
@@ -491,14 +491,13 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			} else {
 				this.#rawPasteCandidate += str;
 				if (isRawMultilineBurst(this.#rawPasteCandidate)) {
-					this.#emitRawPasteCandidate();
+					this.#classifyRawPasteCandidate();
 				}
 				return;
 			}
 		}
 
 		if (
-			this.#rawPasteClassificationEnabled &&
 			this.#buffer.length === 0 &&
 			str.indexOf(ESC) === -1 &&
 			(str.indexOf("\r") !== -1 || str.indexOf("\n") !== -1)
@@ -508,7 +507,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			// Enter is replayed unchanged when the fixed window expires.
 			this.#rawPasteCandidate = str;
 			if (isRawMultilineBurst(str)) {
-				this.#emitRawPasteCandidate();
+				this.#classifyRawPasteCandidate();
 			} else {
 				this.#armRawPasteTimer();
 			}
@@ -649,18 +648,18 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	}
 
 	/**
-	 * Enable or disable unbracketed raw-paste classification. Terminal disables
-	 * it once DECRQM confirms bracketed-paste (mode 2004) support: a genuine
-	 * paste then always arrives wrapped, so the heuristic can only misfire on
-	 * keystrokes an event-loop stall batched into one read (issue #12540).
-	 * Disabling flushes any candidate already held by the classification window
-	 * as ordinary key events so no buffered input is lost.
+	 * Gate unbracketed raw-paste classification on event-loop responsiveness.
+	 * Terminal installs a probe once DECRQM confirms bracketed-paste (mode
+	 * 2004) support: a genuine paste then always arrives wrapped, so an
+	 * unmarked multiline burst is either an input-method commit — IME,
+	 * dictation, and emoji commits are typed input, never bracketed (#13344) —
+	 * or keystrokes an event-loop stall batched into one read (#12540). A burst
+	 * classified while `stalled()` reports a stall is replayed as the original
+	 * keys so every Enter submits; otherwise it is delivered as one paste.
+	 * `undefined` restores unconditional classification.
 	 */
-	setRawPasteClassification(enabled: boolean): void {
-		this.#rawPasteClassificationEnabled = enabled;
-		if (!enabled && this.#rawPasteCandidate.length > 0) {
-			this.#flushRawPasteCandidate();
-		}
+	setRawPasteStallProbe(stalled: (() => boolean) | undefined): void {
+		this.#rawPasteStallProbe = stalled;
 	}
 
 	/** Start one fixed window from the first break-bearing raw read. */
@@ -686,8 +685,15 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		return content;
 	}
 
-	/** Emit a classified raw multiline burst through the paste channel. */
-	#emitRawPasteCandidate(): void {
+	/**
+	 * Deliver a classified raw multiline burst: one paste, or the original
+	 * keys when the stall probe says a blocked loop batched typed input.
+	 */
+	#classifyRawPasteCandidate(): void {
+		if (this.#rawPasteStallProbe?.()) {
+			this.#flushRawPasteCandidate();
+			return;
+		}
 		const content = this.#takeRawPasteCandidate();
 		this.#pendingKittyPrintableCodepoint = undefined;
 		this.emit("paste", content);

package/src/terminal.ts

@@ -460,6 +460,15 @@ export interface TerminalStartOptions {
 	 * echoes even while module loading blocks the event loop.
 	 */
 	deferInput?: boolean;
+	/**
+	 * Reports whether the event loop is stalled or just recovered from a
+	 * stall. Once the terminal confirms bracketed paste, an unmarked multiline
+	 * burst is an input-method commit (IME, dictation) delivered as one paste
+	 * on a responsive loop, but keystrokes a stall batched into one read —
+	 * replayed as keys so Enter submits — while this returns true. Without a
+	 * probe every such burst is treated as an input-method commit.
+	 */
+	isLoopStalled?: () => boolean;
 }
 /** Identity of an accepted explicit terminal appearance refresh request. */
 export type TerminalAppearanceRequestToken = number;
@@ -717,6 +726,7 @@ export class ProcessTerminal implements Terminal {
 	#resizeHandler?: () => void;
 	/** True between a `deferInput` start() and enableInput(). */
 	#inputDeferred = false;
+	#isLoopStalled?: () => boolean;
 	#stdoutResizeListener?: () => void;
 	#kittyProtocolActive = false;
 	#kittyEnableSeq: string | null = null;
@@ -923,6 +933,7 @@ export class ProcessTerminal implements Terminal {
 		this.#inputHandler = onInput;
 		this.#resizeHandler = onResize;
 		this.#disconnectHandler = onDisconnect;
+		this.#isLoopStalled = options?.isLoopStalled;
 		// The host terminal's cursor visibility is unknown until we write it.
 		this.#cursorVisible = undefined;
 
@@ -1081,9 +1092,10 @@ export class ProcessTerminal implements Terminal {
 		this.#queryPrivateMode(2048);
 		this.#queryPrivateMode(2031);
 		// 2004 (bracketed paste) is queried only to confirm the terminal brackets
-		// pastes; once confirmed, the unbracketed raw-paste heuristic in
-		// StdinBuffer is disabled so keystrokes an event-loop stall batches into
-		// one read are never misclassified as a paste (#12540).
+		// pastes; once confirmed, StdinBuffer's unbracketed raw-paste heuristic
+		// consults the host's stall probe so keystrokes an event-loop stall
+		// batches into one read stay keys (#12540) while input-method commits
+		// still land as one paste (#13344).
 		this.#queryPrivateMode(2004);
 		for (const mode of XTERM_SCROLL_TO_BOTTOM_MODES) {
 			this.#queryPrivateMode(mode);
@@ -1774,15 +1786,17 @@ export class ProcessTerminal implements Terminal {
 		}
 		if (mode === 2048 && supported) this.#enableInBandResize();
 		if (mode === 2031) this.#syncWindowsTerminalAppearancePolling(supported);
-		// Confirmed bracketed-paste support makes the unbracketed raw-paste
-		// heuristic pure downside — turn it off so stall-batched keystrokes are
-		// not misread as a paste (#12540). `supported` is only true here after an
-		// explicit DECRPM reply (the DA1-sentinel fallback resolves unsupported).
+		// Confirmed bracketed-paste support means a genuine paste arrives
+		// wrapped, so an unmarked multiline burst is an input-method commit
+		// (#13344) unless an event-loop stall batched typed keys into one read
+		// (#12540). Let the host's stall probe decide per burst. `supported` is
+		// only true here after an explicit DECRPM reply (the DA1-sentinel
+		// fallback resolves unsupported).
 		if (mode === 2004 && supported) {
-			this.#stdinBuffer?.setRawPasteClassification(false);
+			this.#stdinBuffer?.setRawPasteStallProbe(this.#isLoopStalled);
 			// A terminal can reset this mode after the initial probe (for example,
 			// iTerm2's Terminal State toggle). Keep the mode asserted while we own
-			// the TTY, since the raw fallback is disabled after confirmation.
+			// the TTY, since a stalled loop now replays unmarked bursts as keys.
 			this.#bracketedPasteRefreshTimer ??= setInterval(() => {
 				if (this.#active && !this.#dead) this.#safeWrite("\x1b[?2004h");
 			}, 1000);

package/src/theme/mermaid-cache.ts

@@ -1,4 +1,5 @@
 import type { MermaidRenderOptions } from "@oh-my-pi/pi-natives";
+import { LRUCache } from "@oh-my-pi/pi-utils/lru";
 import * as mermaidAscii from "@oh-my-pi/pi-utils/mermaid-ascii";
 
 /**
@@ -19,7 +20,15 @@ export interface MermaidResolveOptions extends MermaidRenderOptions {
 // Memoizes rendered ASCII (and failures) keyed on the render options + the
 // layout-direction variant + source. Width selection happens per call against
 // the cached renders, so a terminal resize re-decides without re-rendering.
-const cache = new Map<string, string | null>();
+// Bounded by entry count and by UTF-16 length of key (which embeds the whole
+// source) plus rendered ASCII, so long sessions cannot pin every diagram.
+const MERMAID_CACHE_MAX = 256;
+const MERMAID_CACHE_MAX_SIZE = 4 * 1024 * 1024;
+const cache = new LRUCache<string, string | null>({
+	max: MERMAID_CACHE_MAX,
+	maxSize: MERMAID_CACHE_MAX_SIZE,
+	sizeCalculation: (ascii, key) => key.length + (ascii?.length ?? 0),
+});
 
 /** Display columns, ignoring ANSI so themed diagrams are measured as drawn. */
 const DISPLAY_WIDTH = { countAnsiEscapeCodes: false } as const;

package/src/theme/tui-adapters.ts

@@ -59,7 +59,20 @@ function getHighlightColors(t: Theme): NativeHighlightColors {
  * the 33ms frame budget and starving the spinner/render timers (the "TUI freeze").
  */
 const HIGHLIGHT_CACHE_MAX = 256;
-const highlightCache = new LRUCache<string, string>({ max: HIGHLIGHT_CACHE_MAX });
+// Size-bound like markdown's render cache: a streaming block (bash command,
+// eval cell) inserts one full `code + highlighted` pair per growth frame, so a
+// count cap alone would retain 256 near-copies of a large payload. Sizes are
+// UTF-16 code units of key + value (ANSI output runs several times the source
+// length). The per-entry cap stays generous so a large but settled code body
+// repainting every frame still hits; only payloads past it re-highlight.
+const HIGHLIGHT_CACHE_MAX_SIZE = 8 * 1024 * 1024;
+const HIGHLIGHT_CACHE_MAX_ENTRY_SIZE = 1024 * 1024;
+const highlightCache = new LRUCache<string, string>({
+	max: HIGHLIGHT_CACHE_MAX,
+	maxSize: HIGHLIGHT_CACHE_MAX_SIZE,
+	maxEntrySize: HIGHLIGHT_CACHE_MAX_ENTRY_SIZE,
+	sizeCalculation: (value, key) => Math.max(1, key.length + value.length),
+});
 let highlightCacheTheme: Theme | undefined;
 
 function highlightCached(code: string, validLang: string | undefined, highlightTheme: Theme): string | null {

package/src/tools/bash.ts

@@ -130,19 +130,51 @@ function unescapePartialJsonString(value: string): string {
 	return output;
 }
 
-function extractPartialBashEnv(partialJson: string | undefined): Record<string, string> | undefined {
+// One-slot memo: every render path over one streamed args object (call
+// preview, result header, repaint) asks for the same buffer.
+let lastPartialEnvJson: string | undefined;
+let lastPartialEnv: Readonly<Record<string, string>> | undefined;
+
+function extractPartialBashEnv(partialJson: string | undefined): Readonly<Record<string, string>> | undefined {
 	if (!partialJson) return undefined;
+	if (partialJson === lastPartialEnvJson) return lastPartialEnv;
+	let env: Record<string, string> | undefined;
 	const envStart = partialJson.search(/"env"\s*:\s*\{/u);
-	if (envStart === -1) return undefined;
-	const objectStart = partialJson.indexOf("{", envStart);
-	if (objectStart === -1) return undefined;
-	const envBody = partialJson.slice(objectStart + 1);
-	const env: Record<string, string> = {};
-	const matcher = /"([A-Za-z_][A-Za-z0-9_]*)"\s*:\s*"((?:\\.|[^"\\])*)(?:"|$)/gu;
-	for (const match of envBody.matchAll(matcher)) {
-		env[match[1]!] = unescapePartialJsonString(match[2]!);
+	const objectStart = envStart === -1 ? -1 : partialJson.indexOf("{", envStart);
+	if (objectStart !== -1) {
+		// Scan only the env object: stop at its closing brace (outside strings)
+		// so the keys that follow it are not read as env assignments.
+		let objectEnd = partialJson.length;
+		let depth = 0;
+		for (let i = objectStart + 1; i < partialJson.length; i++) {
+			const ch = partialJson.charCodeAt(i);
+			if (ch === 0x22) {
+				// Skip the string body, honoring escapes; an unterminated string runs to the end.
+				for (i++; i < partialJson.length; i++) {
+					const inner = partialJson.charCodeAt(i);
+					if (inner === 0x5c) i++;
+					else if (inner === 0x22) break;
+				}
+			} else if (ch === 0x7b || ch === 0x5b) {
+				depth++;
+			} else if (ch === 0x7d || ch === 0x5d) {
+				if (depth === 0) {
+					objectEnd = i;
+					break;
+				}
+				depth--;
+			}
+		}
+		const envBody = partialJson.slice(objectStart + 1, objectEnd);
+		const matcher = /"([A-Za-z_][A-Za-z0-9_]*)"\s*:\s*"((?:\\.|[^"\\])*)(?:"|$)/gu;
+		for (const match of envBody.matchAll(matcher)) {
+			env ??= {};
+			env[match[1]!] = unescapePartialJsonString(match[2]!);
+		}
 	}
-	return Object.keys(env).length > 0 ? env : undefined;
+	lastPartialEnvJson = partialJson;
+	lastPartialEnv = env ? Object.freeze(env) : undefined;
+	return lastPartialEnv;
 }
 
 function formatWallTimeSeconds(wallTimeMs: number): string {
@@ -243,8 +275,12 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 	return {
 		renderCall(args: TArgs, options: RenderResultOptions, uiTheme: Theme): Component {
 			const renderArgs = toBashRenderArgs(args, config);
-			const cmdLines = formatBashCommandLines(renderArgs, uiTheme);
+			// Highlighting the whole (possibly still-streaming) command is the
+			// expensive part: defer it to the first paint, once per component,
+			// so a rebuild that is replaced before painting never pays for it.
+			let cmdLines: string[] | undefined;
 			return framedToolCard(uiTheme, () => {
+				cmdLines ??= formatBashCommandLines(renderArgs, uiTheme);
 				const header =
 					config.showHeader === false
 						? undefined
@@ -275,7 +311,7 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 			args?: TArgs,
 		): Component {
 			const renderArgs = toBashRenderArgs(args, config);
-			const cmdLines = args ? formatBashCommandLines(renderArgs, uiTheme) : undefined;
+			let cmdLines: string[] | undefined;
 			const isError = result.isError === true;
 			const isPartial = options.isPartial === true;
 			const success = !isPartial && !isError;
@@ -438,7 +474,11 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 							{
 								// Viewport-sized tail window in every state — streaming and final
 								// render identically; only ctrl+o uncaps.
-								content: capPreviewLines(cmdLines ?? [], uiTheme, { expanded }),
+								content: capPreviewLines(
+									args ? (cmdLines ??= formatBashCommandLines(renderArgs, uiTheme)) : [],
+									uiTheme,
+									{ expanded },
+								),
 							},
 							{ label: uiTheme.fg("toolTitle", "Output"), content: outputLines },
 						],

package/src/tools/edit.ts

@@ -239,16 +239,14 @@ function decodePartialJsonStringFragment(fragment: string): string {
 	}
 }
 
-function extractPartialJsonString(partialJson: string | undefined, key: string): string | undefined {
-	if (!partialJson) return undefined;
-	const pattern = new RegExp(`"${key}"\\s*:\\s*"((?:\\\\.|[^"\\\\])*)`, "u");
-	const match = pattern.exec(partialJson);
-	if (!match) return undefined;
-	return decodePartialJsonStringFragment(match[1]);
-}
+// `"path": "<possibly unterminated string>` in a raw streamed args buffer.
+const PARTIAL_JSON_PATH_RE = /"path"\s*:\s*"((?:\\.|[^"\\])*)/u;
 
 function getPartialJsonEditPath(args: EditRenderArgs): string | undefined {
-	return filePathFromEditEntry(extractPartialJsonString(args.__partialJson, "path"));
+	const partialJson = args.__partialJson;
+	if (!partialJson) return undefined;
+	const match = PARTIAL_JSON_PATH_RE.exec(partialJson);
+	return match ? decodePartialJsonStringFragment(match[1]!) : undefined;
 }
 
 /** Count distinct file paths in an edits array. */
@@ -427,8 +425,33 @@ function hasEditCallPayload(args: EditRenderArgs, renderContext: EditRenderConte
 	return false;
 }
 
+/**
+ * Head-window preview of streamed replacement text. Only the displayed head is
+ * sanitized and split; the hidden-line count comes from a raw newline scan.
+ * That matches sanitizing the whole text because, on ESC-free input,
+ * `sanitizeText` only deletes individual code units and never a `\n`: the
+ * cut sits on a `\n`, so it cannot split a surrogate pair. The one non-local
+ * rule — a lone surrogate anywhere drops every U+FFFD — is replayed on the
+ * head. ESC-bearing text (ANSI stripping can span lines) takes the full path.
+ */
 function renderPlainTextPreview(text: string, uiTheme: Theme, _filePath?: string): string {
-	const previewLines = cappedHeadLines(sanitizeText(text).split("\n"), CALL_TEXT_PREVIEW_LINES);
+	let previewLines: { lines: readonly string[]; hidden: number };
+	let headEnd = -1;
+	if (!text.includes("\x1b")) {
+		for (let newlines = 0; newlines < CALL_TEXT_PREVIEW_LINES; newlines++) {
+			headEnd = text.indexOf("\n", headEnd + 1);
+			if (headEnd === -1) break;
+		}
+	}
+	if (headEnd === -1) {
+		previewLines = cappedHeadLines(sanitizeText(text).split("\n"), CALL_TEXT_PREVIEW_LINES);
+	} else {
+		let head = sanitizeText(text.slice(0, headEnd));
+		if (head.includes("\ufffd") && !text.isWellFormed()) head = head.replaceAll("\ufffd", "");
+		let hidden = 1;
+		for (let i = text.indexOf("\n", headEnd + 1); i !== -1; i = text.indexOf("\n", i + 1)) hidden++;
+		previewLines = { lines: head.split("\n"), hidden };
+	}
 	let preview = "\n\n";
 	for (const line of previewLines.lines) {
 		preview += `${uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), CALL_TEXT_PREVIEW_WIDTH))}\n`;
@@ -751,17 +774,30 @@ interface EditCallFacts {
  * fields tolerate a small lag) or when the payload shrinks (rewind). The
  * final frame (`isPartial === false`) always recomputes. This turns the
  * per-frame O(n) stringify+parse+scan into O(n^2/K) total per call.
+ *
+ * The reveal hands over a fresh args object on every frame, so the gate
+ * keys on the streamed raw payload (`__partialJson`) rather than on args
+ * identity: a frame reuses the facts only when its payload extends, byte for
+ * byte, the payload the facts were derived from, and every direct field the
+ * facts read (path, file_path, rename, op, edits) is unchanged. Final args
+ * carry no `__partialJson`, so the completed call always derives exact facts.
  */
 const EDIT_FACTS_MIN_GROWTH = 512;
-let lastFactsCache:
-	| {
-			editArgs: EditRenderArgs;
-			isPartial: boolean;
-			editMode: EditMode | undefined;
-			length: number;
-			facts: EditCallFacts;
-	  }
-	| undefined;
+interface EditFactsCacheEntry {
+	editArgs: EditRenderArgs;
+	isPartial: boolean;
+	editMode: EditMode | undefined;
+	length: number;
+	/** Streamed raw payload the facts were derived from; set only for streamed `input` payloads. */
+	streamedPayload: string | undefined;
+	filePath: unknown;
+	path: unknown;
+	rename: unknown;
+	op: Operation | undefined;
+	edits: EditRenderEntry[] | undefined;
+	facts: EditCallFacts;
+}
+let lastFactsCache: EditFactsCacheEntry | undefined;
 
 function editFactsInputLength(editArgs: EditRenderArgs): number {
 	const input = editArgs.input ?? editArgs._input;
@@ -772,27 +808,72 @@ function editFactsInputLength(editArgs: EditRenderArgs): number {
 	return Array.isArray(editArgs.edits) ? editArgs.edits.length : 0;
 }
 
+/**
+ * Raw streamed payload of a mid-stream `input` edit, or undefined when the
+ * args are final (no `__partialJson`) or carry no `input` string — only the
+ * `input` payloads pay the expensive whole-payload inspect per frame.
+ */
+function streamedInputPayload(editArgs: EditRenderArgs): string | undefined {
+	if (typeof (editArgs.input ?? editArgs._input) !== "string") return undefined;
+	const payload = editArgs.__partialJson;
+	return typeof payload === "string" ? payload : undefined;
+}
+
+/**
+ * Whether a fresh streamed frame continues the payload `cached` was derived
+ * from within the growth gate. Exact: the cached payload must be a verbatim
+ * prefix of the new one, so a rewind or another call's payload never reuses.
+ */
+function continuesCachedPayload(cached: EditFactsCacheEntry, editArgs: EditRenderArgs): boolean {
+	const base = cached.streamedPayload;
+	if (base === undefined) return false;
+	const payload = streamedInputPayload(editArgs);
+	if (payload === undefined || payload.length < base.length) return false;
+	if (payload.length - base.length >= EDIT_FACTS_MIN_GROWTH) return false;
+	if (
+		editArgs.file_path !== cached.filePath ||
+		editArgs.path !== cached.path ||
+		editArgs.rename !== cached.rename ||
+		editArgs.op !== cached.op ||
+		editArgs.edits !== cached.edits
+	) {
+		return false;
+	}
+	return payload.startsWith(base);
+}
+
 function resolveEditCallFacts(
 	editArgs: EditRenderArgs,
 	isPartial: boolean,
 	editMode: EditMode | undefined,
 ): EditCallFacts {
 	const cached = lastFactsCache;
-	if (
-		cached !== undefined &&
-		cached.editArgs === editArgs &&
-		cached.isPartial === isPartial &&
-		cached.editMode === editMode
-	) {
-		const length = editFactsInputLength(editArgs);
-		// Same args object, still growing gradually: reuse. A rewind
-		// (shorter), a jump past the gate, or the final frame recomputes.
-		if (isPartial && length >= cached.length && length - cached.length < EDIT_FACTS_MIN_GROWTH) {
+	if (cached !== undefined && isPartial && cached.isPartial && cached.editMode === editMode) {
+		if (cached.editArgs === editArgs) {
+			const length = editFactsInputLength(editArgs);
+			// Same args object, still growing gradually: reuse. A rewind
+			// (shorter), a jump past the gate, or the final frame recomputes.
+			if (length >= cached.length && length - cached.length < EDIT_FACTS_MIN_GROWTH) {
+				return cached.facts;
+			}
+		} else if (continuesCachedPayload(cached, editArgs)) {
 			return cached.facts;
 		}
 	}
 	const facts = resolveEditCallFactsUncached(editArgs, isPartial, editMode);
-	lastFactsCache = { editArgs, isPartial, editMode, length: editFactsInputLength(editArgs), facts };
+	lastFactsCache = {
+		editArgs,
+		isPartial,
+		editMode,
+		length: editFactsInputLength(editArgs),
+		streamedPayload: streamedInputPayload(editArgs),
+		filePath: editArgs.file_path,
+		path: editArgs.path,
+		rename: editArgs.rename,
+		op: editArgs.op,
+		edits: editArgs.edits,
+		facts,
+	};
 	return facts;
 }