silvery 0.21.0 → 0.23.0

package/dist/chain-bridge-CkYcMxlq.mjs

@@ -0,0 +1,4149 @@
+import { _ as getAncestorPath } from "./mouse-events-WQ2h-uqG.mjs";
+import { _ as rectEqual, a as findActiveParkRect, g as setWrapMeasurer, h as getWrapMeasurer, i as findActiveCursorRectWithProvenance, n as computeContentRect, r as findActiveCursorRect, t as commitLayoutSnapshot } from "./layout-signals-CGYbHmxy.mjs";
+import { B as resolveNonTTYMode, L as countLines, R as createOutputTransformer, _t as findActiveCursorNode, k as createPipeline } from "./src-DbqcSrhy.mjs";
+import { $t as bufferToText, Ct as isStrictEnabled, D as runWithMeasurer, L as wrapTextWithOffsets, N as stripAnsi, bt as recordOutputCursorDiagnostics, en as cellEquals, gt as outputPhase, ht as getLastOutputPhaseDiagnostics, it as createOsc52Backend, kt as ANSI, mn as parseHotkey, nn as colorEquals, pt as clearLastOutputPhaseDiagnostics, vt as IncrementalRenderMismatchError } from "./unicode-CxyxVGmB.mjs";
+import { C as isDirty, x as isAnyDirty } from "./reconciler--_-biN23.mjs";
+import { n as createRenderPostState, o as FRESH_LAYOUT_STRICT_SLUG, s as markLayoutTreeDirty, t as createAg } from "./ag-q9lRlKlt.mjs";
+import { createLogger } from "loggily";
+import { appendFileSync, existsSync, mkdirSync } from "node:fs";
+import { createContext } from "react";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { Fragment, jsx } from "react/jsx-runtime";
+//#region packages/ag/src/focus-events.ts
+/**
+* Create a synthetic keyboard event.
+*/
+function createKeyEvent(input, key, target) {
+	let propagationStopped = false;
+	let defaultPrevented = false;
+	return {
+		key: input,
+		input,
+		ctrl: key.ctrl,
+		meta: key.meta,
+		shift: key.shift,
+		super: key.super,
+		hyper: key.hyper,
+		eventType: key.eventType,
+		target,
+		currentTarget: target,
+		nativeEvent: {
+			input,
+			key
+		},
+		get propagationStopped() {
+			return propagationStopped;
+		},
+		get defaultPrevented() {
+			return defaultPrevented;
+		},
+		stopPropagation() {
+			propagationStopped = true;
+		},
+		preventDefault() {
+			defaultPrevented = true;
+		}
+	};
+}
+/**
+* Create a synthetic focus event.
+*/
+function createFocusEvent(type, target, relatedTarget) {
+	let propagationStopped = false;
+	return {
+		type,
+		target,
+		relatedTarget,
+		currentTarget: target,
+		get propagationStopped() {
+			return propagationStopped;
+		},
+		stopPropagation() {
+			propagationStopped = true;
+		}
+	};
+}
+/**
+* Dispatch a keyboard event through the render tree with DOM-style
+* capture/target/bubble phases.
+*
+* For press/repeat events:
+*   1. Capture phase: root → target (onKeyDownCapture props)
+*   2. Target phase: target's onKeyDown
+*   3. Bubble phase: target parent → root (onKeyDown props)
+*
+* For release events:
+*   1. Target phase: target's onKeyUp
+*   2. Bubble phase: target parent → root (onKeyUp props)
+*   (No capture phase for keyUp — deliberate simplification; React DOM has onKeyUpCapture)
+*
+* stopPropagation() halts traversal at any phase.
+*/
+function dispatchKeyEvent(event, dispatch) {
+	const path = getAncestorPath(event.target);
+	const mutableEvent = event;
+	const isRelease = event.eventType === "release";
+	const handlerProp = isRelease ? "onKeyUp" : "onKeyDown";
+	if (!isRelease) for (let i = path.length - 1; i > 0; i--) {
+		if (event.propagationStopped) return;
+		const node = path[i];
+		const handler = node.props.onKeyDownCapture;
+		if (handler) {
+			mutableEvent.currentTarget = node;
+			handler(event);
+		}
+	}
+	if (!event.propagationStopped) {
+		const target = path[0];
+		mutableEvent.currentTarget = target;
+		const handler = target.props[handlerProp];
+		if (handler) handler(event, dispatch);
+	}
+	for (let i = 1; i < path.length; i++) {
+		if (event.propagationStopped) return;
+		const node = path[i];
+		const handler = node.props[handlerProp];
+		if (handler) {
+			mutableEvent.currentTarget = node;
+			handler(event, dispatch);
+		}
+	}
+}
+/**
+* Dispatch a focus event through the render tree.
+*
+* Fires onFocus/onBlur on the target, then bubbles to ancestors.
+*/
+function dispatchFocusEvent(event) {
+	const handlerProp = event.type === "focus" ? "onFocus" : "onBlur";
+	const path = getAncestorPath(event.target);
+	const mutableEvent = event;
+	for (const node of path) {
+		if (event.propagationStopped) break;
+		const handler = node.props[handlerProp];
+		if (handler) {
+			mutableEvent.currentTarget = node;
+			handler(event);
+		}
+	}
+}
+//#endregion
+//#region packages/create/src/pipe.ts
+function pipe(base, ...plugins) {
+	let result = base;
+	for (const plugin of plugins) result = plugin(result);
+	return result;
+}
+//#endregion
+//#region packages/create/src/internal/capability-registry.ts
+/** Create a new capability registry (one per app instance). */
+function createCapabilityRegistry() {
+	const capabilities = /* @__PURE__ */ new Map();
+	return {
+		register(key, capability) {
+			capabilities.set(key, capability);
+		},
+		get(key) {
+			return capabilities.get(key);
+		}
+	};
+}
+//#endregion
+//#region packages/create/src/internal/capabilities.ts
+/**
+* Capability symbols — well-known keys for the CapabilityRegistry.
+*
+* Features register themselves under these symbols so other parts
+* of the composition chain can discover and interact with them.
+*
+* @internal Not exported from the public barrel.
+*/
+/** Selection feature: text selection state + mouse handling. */
+const SELECTION_CAPABILITY = Symbol.for("silvery.selection");
+/** Drag feature: drag-and-drop state + mouse handling. */
+const DRAG_CAPABILITY = Symbol.for("silvery.drag");
+//#endregion
+//#region packages/ag-term/src/features/selection.ts
+/**
+* Create a bridge SelectionFeature that delegates to an external state owner.
+*
+* Used by create-app to expose its inline selection state to React hooks
+* (useSelection) and copy-mode (which calls setRange/clear) without
+* duplicating the state machine. Mouse handlers are no-ops — the external
+* owner (create-app's event loop) handles mouse events directly.
+*/
+function createSelectionBridge(options) {
+	return {
+		get state() {
+			return options.getState();
+		},
+		subscribe(listener) {
+			return options.subscribe(listener);
+		},
+		handleMouseDown(_col, _row, _altKey) {},
+		handleMouseMove(_col, _row) {},
+		handleMouseUp(_col, _row) {},
+		setRange(range) {
+			options.setRange(range);
+		},
+		clear() {
+			options.clear();
+		},
+		copySelection() {
+			options.copy?.();
+		},
+		dispose() {}
+	};
+}
+//#endregion
+//#region packages/create/src/runtime/with-terminal-chain.ts
+/**
+* Install the terminal observer + lifecycle plugin.
+*
+* The returned app exposes the terminal slice at `app.terminal`.
+* Plugins upstream (last in `pipe()`) see ops first; this plugin
+* should go near the BASE of the chain so focused/useInput plugins
+* handle actual key content before the terminal observer peeks at
+* modifier state.
+*/
+function withTerminalChain(options = {}) {
+	return (app) => {
+		const store = {
+			cols: options.cols ?? 80,
+			rows: options.rows ?? 24,
+			focused: options.focused ?? true,
+			modifiers: {
+				ctrl: false,
+				shift: false,
+				alt: false,
+				meta: false,
+				super: false,
+				hyper: false
+			}
+		};
+		const prev = app.apply;
+		app.apply = (op) => {
+			if (op.type === "input:key") {
+				const key = op.key;
+				if (key) store.modifiers = {
+					ctrl: !!key.ctrl,
+					shift: !!key.shift,
+					alt: !!key.alt || !!key.meta,
+					meta: !!key.meta,
+					super: !!key.super,
+					hyper: !!key.hyper
+				};
+				return prev(op);
+			}
+			if (op.type === "term:resize") {
+				const cols = op.cols;
+				const rows = op.rows;
+				if (typeof cols === "number") store.cols = cols;
+				if (typeof rows === "number") store.rows = rows;
+				const effects = [{ type: "render" }];
+				const downstream = prev(op);
+				if (downstream !== false) effects.push(...downstream);
+				return effects;
+			}
+			if (op.type === "term:focus") {
+				const focused = !!op.focused;
+				store.focused = focused;
+				if (!focused) store.modifiers = {
+					ctrl: false,
+					shift: false,
+					alt: false,
+					meta: false,
+					super: false,
+					hyper: false
+				};
+				return [];
+			}
+			return prev(op);
+		};
+		return Object.assign(app, { terminal: store });
+	};
+}
+//#endregion
+//#region packages/create/src/runtime/with-focus-chain.ts
+function isModifierOnly$1(_input, key) {
+	return key?.isModifierOnly === true;
+}
+/**
+* Install the focus-dispatch plugin.
+*
+* Place this plugin OUTERMOST in the input-handling chain so focused
+* targets see the key before the `useInput` fallback store.
+*/
+function withFocusChain(options) {
+	return (app) => {
+		const store = { lastConsumed: false };
+		const prev = app.apply;
+		app.apply = (op) => {
+			if (op.type !== "input:key") return prev(op);
+			const input = op.input ?? "";
+			const key = op.key;
+			const isRelease = key?.eventType === "release";
+			const modOnly = isModifierOnly$1(input, key);
+			if ((isRelease || modOnly) && !options.dispatchReleaseAndModifierOnly) return prev(op);
+			let consumed = false;
+			try {
+				consumed = !!options.dispatchKey(input, key ?? {});
+			} catch (err) {
+				console.error("[withFocusChain] dispatchKey threw", err);
+			}
+			store.lastConsumed = consumed;
+			if (consumed) return [{ type: "render" }];
+			return prev(op);
+		};
+		return Object.assign(app, { focusChain: store });
+	};
+}
+//#endregion
+//#region packages/commands/src/with-commands.ts
+/**
+* Find command by short name or full id.
+*
+* Supports both:
+* - Exact id match: `cmd['cursor_down']`
+* - Short name match: `cmd.down` (matches 'cursor_down', 'navigation_down', etc.)
+*/
+function findCommand(registry, key) {
+	const byId = registry.get(key);
+	if (byId) return byId;
+	return registry.getAll().find((c) => {
+		return c.id.split(/[._]/).pop() === key;
+	});
+}
+/**
+* Get keys bound to a command.
+*/
+function getKeysForCommand(commandId, keybindings) {
+	if (!keybindings) return [];
+	return keybindings.filter((kb) => kb.commandId === commandId).map((kb) => {
+		const parts = [];
+		if (kb.cmd) parts.push("Cmd");
+		if (kb.ctrl) parts.push("Ctrl");
+		if (kb.alt || kb.opt) parts.push("Alt");
+		if (kb.shift) parts.push("Shift");
+		parts.push(kb.key);
+		return parts.join("+");
+	});
+}
+/**
+* Format help text for all commands.
+*/
+function formatHelp(registry, keybindings) {
+	return registry.getAll().map((cmd) => {
+		const keys = getKeysForCommand(cmd.id, keybindings);
+		const keyStr = keys.length > 0 ? ` [${keys.join(", ")}]` : "";
+		return `${cmd.id}${keyStr}: ${cmd.description}`;
+	}).join("\n");
+}
+function withCommands(appOrOptions, maybeOptions) {
+	if (maybeOptions === void 0) {
+		const options = appOrOptions;
+		return (app) => applyCommands(app, options);
+	}
+	return applyCommands(appOrOptions, maybeOptions);
+}
+function applyCommands(app, options) {
+	const { registry, getContext, handleAction, getKeybindings } = options;
+	const cmd = new Proxy({}, {
+		get(_, prop) {
+			if (typeof prop === "symbol") return void 0;
+			if (prop === "all") return () => {
+				const commands = registry.getAll();
+				const keybindings = getKeybindings?.();
+				return commands.map((c) => ({
+					id: c.id,
+					name: c.name,
+					description: c.description,
+					keys: getKeysForCommand(c.id, keybindings)
+				}));
+			};
+			if (prop === "describe") return () => formatHelp(registry, getKeybindings?.());
+			const def = findCommand(registry, prop);
+			if (!def) return void 0;
+			const fn = async () => {
+				const ctx = getContext();
+				const result = def.execute(ctx);
+				if (result) {
+					const actions = Array.isArray(result) ? result : [result];
+					for (const action of actions) handleAction(action);
+				}
+				await Promise.resolve();
+			};
+			const keybindings = getKeybindings?.();
+			Object.defineProperties(fn, {
+				id: {
+					value: def.id,
+					enumerable: true
+				},
+				name: {
+					value: def.name,
+					enumerable: true
+				},
+				help: {
+					value: def.description,
+					enumerable: true
+				},
+				keys: {
+					value: getKeysForCommand(def.id, keybindings),
+					enumerable: true
+				}
+			});
+			return fn;
+		},
+		has(_, prop) {
+			if (typeof prop === "symbol") return false;
+			if (prop === "all" || prop === "describe") return true;
+			return !!findCommand(registry, prop);
+		}
+	});
+	const getState = () => {
+		const commands = registry.getAll();
+		const keybindings = getKeybindings?.();
+		return {
+			screen: app.text,
+			commands: commands.map((c) => ({
+				id: c.id,
+				name: c.name,
+				description: c.description,
+				keys: getKeysForCommand(c.id, keybindings)
+			})),
+			focus: void 0
+		};
+	};
+	return Object.assign(app, {
+		cmd,
+		getState
+	});
+}
+//#endregion
+//#region packages/commands/src/with-keybindings.ts
+/**
+* Resolve a key press to a command ID using keybinding lookup.
+*/
+function resolveKeybinding(key, modifiers, bindings, ctx) {
+	for (const binding of bindings) {
+		if (binding.key !== key) continue;
+		if (!!binding.ctrl !== !!modifiers.ctrl) continue;
+		if (!!binding.opt !== !!modifiers.meta) continue;
+		if (!!binding.cmd !== !!modifiers.super) continue;
+		if (!(key.length === 1 && key >= "A" && key <= "Z" && !binding.shift) && !!binding.shift !== !!modifiers.shift) continue;
+		if (binding.modes && binding.modes.length > 0) {
+			if (!binding.modes.includes(ctx.mode)) continue;
+		}
+		if (binding.when && !binding.when(ctx)) continue;
+		return binding.commandId;
+	}
+	return null;
+}
+function withKeybindings(appOrOptions, maybeOptions) {
+	if (maybeOptions === void 0) {
+		const options = appOrOptions;
+		return (app) => applyKeybindings(app, options);
+	}
+	return applyKeybindings(appOrOptions, maybeOptions);
+}
+function applyKeybindings(app, options) {
+	const { bindings, getKeyContext } = options;
+	const originalPress = app.press.bind(app);
+	return new Proxy(app, { get(target, prop, receiver) {
+		if (prop === "press") return async function interceptedPress(keyStr) {
+			const { key, ...modifiers } = parseHotkey(keyStr);
+			const commandId = resolveKeybinding(key, modifiers, bindings, getKeyContext());
+			if (commandId) {
+				const cmd = target.cmd[commandId];
+				if (cmd) {
+					await cmd();
+					return receiver;
+				}
+			}
+			await originalPress(keyStr);
+			return receiver;
+		};
+		return Reflect.get(target, prop, receiver);
+	} });
+}
+//#endregion
+//#region packages/test/src/compare-buffers.ts
+/**
+* Buffer comparison utility for differential rendering tests.
+*
+* Compares two terminal buffers cell-by-cell, returning the first
+* mismatch found (or null if buffers are identical).
+*
+* ## Documented-distinct from the termless comparator family
+*
+* The terminal-flow vertical slice (§7 "Comparator family") converges the
+* ecosystem's differs — termless `diffBuffers`, `terminalStateDigest` /
+* `diffTerminalStates`, and the restore-equivalence oracle's state digest — into
+* ONE compare family in termless. `compareBuffers` here is deliberately **NOT** a
+* member of that family, and NOT a duplicate of `diffBuffers`. It is a
+* **render-level** check, kept distinct by design:
+*
+* - **Different input.** The termless family compares terminal *state* read
+*   through the `TerminalReadable` contract ("are these two terminals in the same
+*   observable state?"). `compareBuffers` compares two silvery `TerminalBuffer`s —
+*   silvery's internal packed render target, which is NOT a `TerminalReadable` and
+*   cannot be one: it carries render-only semantics (the `SELECTABLE_FLAG`, the
+*   `DEFAULT_BG` sentinel, inheritedBg-resolved cells, `continuation` occupancy)
+*   that exist only inside the render pipeline, before any emulator sees output.
+* - **Different question.** Every caller (`with-diagnostics`'s `SILVERY_STRICT`
+*   `incremental` check, the incremental-rendering fuzz, `render-plan-parity`)
+*   asks "did silvery's incremental / replayed render path produce the identical
+*   render buffer as a fresh / recorded render?" — the incremental≡fresh
+*   invariant. That has no analog in the termless state-equivalence family.
+* - **Non-temporal A/B framing.** `cellA`/`cellB` are two renders of the SAME
+*   frame (incremental vs fresh, replayed vs recorded) — deliberately NOT the
+*   `oldCell`/`newCell` temporal framing of `diffBuffers`, and it returns the
+*   FIRST mismatch (fail-fast for an assertion) rather than every changed cell
+*   (a differential corpus).
+*
+* Structural correspondence, for readers crossing between the two: this file's
+* `{ x, y }` is `diffBuffers`'s `{ col, row }` (x=col, y=row); `cellA`/`cellB`
+* carry silvery buffer `Cell`s (fg/bg = `number | { r, g, b, index? } | null`),
+* whose color shape is index-preserving and thus structurally compatible with the
+* termless `Cell`'s `Color = { r, g, b, index? }` — but the two types are never
+* imported across the silvery↔termless boundary (compatible shapes, not shared
+* imports; slice §9 rule 7).
+*/
+/**
+* Compare two terminal buffers cell-by-cell.
+*
+* @returns The first mismatch found, or null if buffers are identical.
+*/
+function compareBuffers(a, b) {
+	const width = Math.max(a.width, b.width);
+	const height = Math.max(a.height, b.height);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		const cellA = a.inBounds(x, y) ? a.getCell(x, y) : {
+			char: " ",
+			fg: null,
+			bg: null,
+			underlineColor: null,
+			attrs: {},
+			wide: false,
+			continuation: false
+		};
+		const cellB = b.inBounds(x, y) ? b.getCell(x, y) : {
+			char: " ",
+			fg: null,
+			bg: null,
+			underlineColor: null,
+			attrs: {},
+			wide: false,
+			continuation: false
+		};
+		if (!cellEquals(cellA, cellB)) return {
+			x,
+			y,
+			cellA,
+			cellB
+		};
+	}
+	return null;
+}
+/**
+* Format a buffer mismatch for human-readable error output.
+*/
+function formatMismatch(mismatch, context) {
+	const { x, y, cellA, cellB } = mismatch;
+	const lines = [
+		`Buffer mismatch at (${x}, ${y})`,
+		`  incremental: char=${JSON.stringify(cellA.char)} fg=${JSON.stringify(cellA.fg)} bg=${JSON.stringify(cellA.bg)} attrs=${JSON.stringify(cellA.attrs)}`,
+		`  fresh:       char=${JSON.stringify(cellB.char)} fg=${JSON.stringify(cellB.fg)} bg=${JSON.stringify(cellB.bg)} attrs=${JSON.stringify(cellB.attrs)}`
+	];
+	if (context?.seed !== void 0) lines.push(`  seed: ${context.seed}`);
+	if (context?.iteration !== void 0) lines.push(`  iteration: ${context.iteration}`);
+	if (context?.key) lines.push(`  key: ${JSON.stringify(context.key)}`);
+	if (context?.incrementalText) lines.push("", "--- incremental ---", context.incrementalText);
+	if (context?.freshText) lines.push("", "--- fresh ---", context.freshText);
+	return lines.join("\n");
+}
+//#endregion
+//#region packages/ag-term/src/plugins/with-diagnostics.ts
+/**
+* withDiagnostics - Plugin for buffer and rendering diagnostic checks
+*
+* Wraps the `cmd` object to check invariants after command execution:
+* - All commands: Check incremental vs fresh render
+* - Cursor moves: Also check buffer content stability
+* - Optional: ANSI replay verification (characters AND SGR styles)
+*
+* ## Design Note: Why wrap `cmd` instead of `sendInput`?
+*
+* The two approaches are complementary:
+*
+* 1. **`sendInput()` level** (in renderer.ts) — Already has `SILVERY_STRICT`
+*    which catches ALL inputs regardless of how they arrive (raw key presses,
+*    type(), press(), etc.). This is the right place for incremental render checks.
+*
+* 2. **`cmd` level** (this plugin) — Command-aware, can selectively check stability
+*    for cursor moves only. Raw sendInput doesn't know which inputs are cursor
+*    commands that should preserve content. Another option would be `withInput()`
+*    which could wrap sendInput with awareness of what input was sent.
+*
+* This plugin focuses on the command-aware checks. For comprehensive incremental
+* render checking, use `SILVERY_STRICT=1` environment variable which enables all checks.
+*
+* @example
+* ```typescript
+* import { withDiagnostics } from '@silvery/ag-term/toolbelt';
+*
+* // All checks enabled by default when you call withDiagnostics()
+* const driver = withDiagnostics(createBoardDriver(repo, rootId));
+*
+* // Or disable specific checks
+* const driver = withDiagnostics(createBoardDriver(repo, rootId), {
+*   checkReplay: false  // skip ANSI replay check
+* });
+*
+* // Commands now run invariant checks automatically
+* await driver.cmd.down();  // Checks incremental + stability + replay
+* await driver.cmd.search();  // Checks incremental + replay
+* ```
+*/
+/**
+* Virtual terminal simulator for testing ANSI replay equivalence.
+*
+* Parses ANSI sequences and applies them to a 2D grid tracking both
+* character content and SGR style attributes (fg, bg, bold, italic, etc.).
+* Used to verify the Replay Equivalence invariant: applying the ANSI
+* diff to the previous buffer state should produce the target buffer.
+*
+* Handles:
+* - Cursor positioning (H, G, A, B, C, D)
+* - Line clear (K)
+* - Wide characters (emojis, CJK)
+* - CR/LF
+* - SGR style sequences (m) — fg/bg colors, text attributes
+*/
+var VirtualTerminal = class {
+	grid;
+	wideMarker;
+	styles;
+	sgr;
+	cursorX = 0;
+	cursorY = 0;
+	constructor(width, height) {
+		this.width = width;
+		this.height = height;
+		this.grid = Array.from({ length: height }, () => Array(width).fill(" "));
+		this.wideMarker = Array.from({ length: height }, () => Array(width).fill(false));
+		this.styles = Array.from({ length: height }, () => Array.from({ length: width }, () => createDefaultVTermStyle()));
+		this.sgr = createDefaultVTermStyle();
+	}
+	/**
+	* Initialize grid from a TerminalBuffer (for incremental replay).
+	* Loads both character content and style attributes.
+	*/
+	loadFromBuffer(buffer) {
+		for (let y = 0; y < Math.min(this.height, buffer.height); y++) for (let x = 0; x < Math.min(this.width, buffer.width); x++) if (buffer.isCellContinuation(x, y)) {
+			this.wideMarker[y][x] = true;
+			this.grid[y][x] = "";
+			this.styles[y][x] = createDefaultVTermStyle();
+		} else {
+			this.grid[y][x] = buffer.getCellChar(x, y);
+			this.wideMarker[y][x] = false;
+			const cell = buffer.getCell(x, y);
+			this.styles[y][x] = {
+				fg: cell.fg,
+				bg: cell.bg,
+				bold: !!cell.attrs.bold,
+				dim: !!cell.attrs.dim,
+				italic: !!cell.attrs.italic,
+				underline: !!cell.attrs.underline || !!cell.attrs.underlineStyle,
+				blink: !!cell.attrs.blink,
+				inverse: !!cell.attrs.inverse,
+				hidden: !!cell.attrs.hidden,
+				strikethrough: !!cell.attrs.strikethrough
+			};
+		}
+	}
+	/**
+	* Apply ANSI escape sequence string to the virtual terminal.
+	*/
+	applyAnsi(ansi) {
+		let i = 0;
+		while (i < ansi.length) {
+			if (ansi[i] === "\x1B" && ansi[i + 1] === "[") {
+				const match = ansi.slice(i).match(/^\x1b\[([0-9;:?]*)([A-Za-z])/);
+				if (match) {
+					this.handleCsi(match[1] || "", match[2]);
+					i += match[0].length;
+					continue;
+				}
+			}
+			if (ansi[i] === "\x1B" && ansi[i + 1] === "]") {
+				let j = i + 2;
+				while (j < ansi.length) {
+					if (ansi[j] === "\x07") {
+						j++;
+						break;
+					}
+					if (ansi[j] === "\x1B" && ansi[j + 1] === "\\") {
+						j += 2;
+						break;
+					}
+					j++;
+				}
+				i = j;
+				continue;
+			}
+			if (ansi[i] === "\r") {
+				this.cursorX = 0;
+				i++;
+				continue;
+			}
+			if (ansi[i] === "\n") {
+				this.cursorY = Math.min(this.cursorY + 1, this.height - 1);
+				i++;
+				continue;
+			}
+			const char = this.extractChar(ansi, i);
+			if (this.cursorX < this.width && this.cursorY < this.height) {
+				this.grid[this.cursorY][this.cursorX] = char;
+				this.wideMarker[this.cursorY][this.cursorX] = false;
+				this.styles[this.cursorY][this.cursorX] = { ...this.sgr };
+				this.cursorX++;
+				if (this.isWideChar(char) && this.cursorX < this.width) {
+					this.grid[this.cursorY][this.cursorX] = "";
+					this.wideMarker[this.cursorY][this.cursorX] = true;
+					this.styles[this.cursorY][this.cursorX] = createDefaultVTermStyle();
+					this.cursorX++;
+				}
+			}
+			i += char.length;
+		}
+	}
+	/**
+	* Check if a character is wide (emoji, CJK, etc).
+	*/
+	isWideChar(char) {
+		if (char.length === 0) return false;
+		if (char.includes("️")) return true;
+		const code = char.codePointAt(0) || 0;
+		if (code >= 127744 && code <= 129535) return true;
+		if (code >= 9728 && code <= 9983) return true;
+		if (code >= 9984 && code <= 10175) return true;
+		if (code >= 19968 && code <= 40959) return true;
+		if (code >= 12288 && code <= 12351) return true;
+		if (code >= 65280 && code <= 65519) return true;
+		return false;
+	}
+	/**
+	* Extract a single Unicode character (which may be multiple bytes).
+	* Includes VS16 (U+FE0F) if it follows, since VS16 is a presentation selector
+	* that modifies the preceding character's rendering width.
+	*/
+	extractChar(str, start) {
+		const code = str.codePointAt(start);
+		if (code === void 0) return str[start] || "";
+		let char;
+		if (code > 65535) char = String.fromCodePoint(code);
+		else char = str[start] || "";
+		const nextIdx = start + char.length;
+		if (nextIdx < str.length && str.codePointAt(nextIdx) === 65039) char += "️";
+		return char;
+	}
+	handleCsi(params, cmd) {
+		switch (cmd) {
+			case "H": {
+				const parts = params.split(";");
+				this.cursorY = Math.max(0, (Number.parseInt(parts[0] || "1", 10) || 1) - 1);
+				this.cursorX = Math.max(0, (Number.parseInt(parts[1] || "1", 10) || 1) - 1);
+				break;
+			}
+			case "G":
+				this.cursorX = Math.max(0, (Number.parseInt(params || "1", 10) || 1) - 1);
+				break;
+			case "A": {
+				const n = Number.parseInt(params || "1", 10) || 1;
+				this.cursorY = Math.max(0, this.cursorY - n);
+				break;
+			}
+			case "B": {
+				const n = Number.parseInt(params || "1", 10) || 1;
+				this.cursorY = Math.min(this.height - 1, this.cursorY + n);
+				break;
+			}
+			case "C": {
+				const n = Number.parseInt(params || "1", 10) || 1;
+				this.cursorX = Math.min(this.width - 1, this.cursorX + n);
+				break;
+			}
+			case "D": {
+				const n = Number.parseInt(params || "1", 10) || 1;
+				this.cursorX = Math.max(0, this.cursorX - n);
+				break;
+			}
+			case "K": {
+				const mode = Number.parseInt(params || "0", 10);
+				if (mode === 0) for (let x = this.cursorX; x < this.width; x++) {
+					this.grid[this.cursorY][x] = " ";
+					this.wideMarker[this.cursorY][x] = false;
+					this.styles[this.cursorY][x] = {
+						...createDefaultVTermStyle(),
+						bg: this.sgr.bg
+					};
+				}
+				else if (mode === 1) for (let x = 0; x <= this.cursorX; x++) {
+					this.grid[this.cursorY][x] = " ";
+					this.wideMarker[this.cursorY][x] = false;
+					this.styles[this.cursorY][x] = {
+						...createDefaultVTermStyle(),
+						bg: this.sgr.bg
+					};
+				}
+				else if (mode === 2) for (let x = 0; x < this.width; x++) {
+					this.grid[this.cursorY][x] = " ";
+					this.wideMarker[this.cursorY][x] = false;
+					this.styles[this.cursorY][x] = {
+						...createDefaultVTermStyle(),
+						bg: this.sgr.bg
+					};
+				}
+				break;
+			}
+			case "m":
+				this.applySgr(params);
+				break;
+			case "l":
+			case "h": break;
+		}
+	}
+	/**
+	* Apply SGR parameters to the current style state.
+	* Parses the semicolon-separated parameter string and updates this.sgr.
+	*/
+	applySgr(params) {
+		if (params === "" || params === "0") {
+			Object.assign(this.sgr, createDefaultVTermStyle());
+			return;
+		}
+		const parts = params.split(";");
+		let i = 0;
+		while (i < parts.length) {
+			const code = parts[i];
+			const colonIdx = code.indexOf(":");
+			if (colonIdx >= 0) {
+				if (Number.parseInt(code.substring(0, colonIdx), 10) === 4) {
+					const sub = Number.parseInt(code.substring(colonIdx + 1), 10);
+					this.sgr.underline = sub > 0;
+				}
+				i++;
+				continue;
+			}
+			const n = Number.parseInt(code, 10);
+			if (n === 0) Object.assign(this.sgr, createDefaultVTermStyle());
+			else if (n === 1) this.sgr.bold = true;
+			else if (n === 2) this.sgr.dim = true;
+			else if (n === 3) this.sgr.italic = true;
+			else if (n === 4) this.sgr.underline = true;
+			else if (n === 5 || n === 6) this.sgr.blink = true;
+			else if (n === 7) this.sgr.inverse = true;
+			else if (n === 8) this.sgr.hidden = true;
+			else if (n === 9) this.sgr.strikethrough = true;
+			else if (n === 22) {
+				this.sgr.bold = false;
+				this.sgr.dim = false;
+			} else if (n === 23) this.sgr.italic = false;
+			else if (n === 24) this.sgr.underline = false;
+			else if (n === 25) this.sgr.blink = false;
+			else if (n === 27) this.sgr.inverse = false;
+			else if (n === 28) this.sgr.hidden = false;
+			else if (n === 29) this.sgr.strikethrough = false;
+			else if (n >= 30 && n <= 37) this.sgr.fg = n - 30;
+			else if (n === 38) {
+				if (i + 1 < parts.length && parts[i + 1] === "5" && i + 2 < parts.length) {
+					this.sgr.fg = Number.parseInt(parts[i + 2], 10);
+					i += 2;
+				} else if (i + 1 < parts.length && parts[i + 1] === "2" && i + 4 < parts.length) {
+					this.sgr.fg = {
+						r: Number.parseInt(parts[i + 2], 10),
+						g: Number.parseInt(parts[i + 3], 10),
+						b: Number.parseInt(parts[i + 4], 10)
+					};
+					i += 4;
+				}
+			} else if (n === 39) this.sgr.fg = null;
+			else if (n >= 40 && n <= 47) this.sgr.bg = n - 40;
+			else if (n === 48) {
+				if (i + 1 < parts.length && parts[i + 1] === "5" && i + 2 < parts.length) {
+					this.sgr.bg = Number.parseInt(parts[i + 2], 10);
+					i += 2;
+				} else if (i + 1 < parts.length && parts[i + 1] === "2" && i + 4 < parts.length) {
+					this.sgr.bg = {
+						r: Number.parseInt(parts[i + 2], 10),
+						g: Number.parseInt(parts[i + 3], 10),
+						b: Number.parseInt(parts[i + 4], 10)
+					};
+					i += 4;
+				}
+			} else if (n === 49) this.sgr.bg = null;
+			else if (n >= 90 && n <= 97) this.sgr.fg = n - 90 + 8;
+			else if (n >= 100 && n <= 107) this.sgr.bg = n - 100 + 8;
+			i++;
+		}
+	}
+	/**
+	* Get the character at a position.
+	*/
+	getChar(x, y) {
+		if (this.wideMarker[y]?.[x]) return "";
+		return this.grid[y]?.[x] ?? " ";
+	}
+	/**
+	* Get the style at a position.
+	*/
+	getStyle(x, y) {
+		return this.styles[y]?.[x] ?? createDefaultVTermStyle();
+	}
+	/**
+	* Compare with a TerminalBuffer and return character mismatches.
+	*/
+	compareToBuffer(buffer) {
+		const mismatches = [];
+		for (let y = 0; y < Math.min(this.height, buffer.height); y++) for (let x = 0; x < Math.min(this.width, buffer.width); x++) {
+			if (buffer.isCellContinuation(x, y)) continue;
+			const expected = buffer.getCellChar(x, y);
+			const actual = this.getChar(x, y);
+			if (expected !== actual) mismatches.push({
+				x,
+				y,
+				expected,
+				actual
+			});
+		}
+		return mismatches;
+	}
+	/**
+	* Compare styles with a TerminalBuffer and return style mismatches.
+	* Checks fg, bg, bold, dim, italic, underline, blink, inverse, hidden, strikethrough.
+	*/
+	compareStylesToBuffer(buffer) {
+		const mismatches = [];
+		for (let y = 0; y < Math.min(this.height, buffer.height); y++) for (let x = 0; x < Math.min(this.width, buffer.width); x++) {
+			if (buffer.isCellContinuation(x, y)) continue;
+			const cell = buffer.getCell(x, y);
+			const actual = this.getStyle(x, y);
+			const diffs = [];
+			if (!colorEquals(actual.fg, cell.fg)) diffs.push(`fg: ${formatVTermColor(actual.fg)} vs ${formatVTermColor(cell.fg)}`);
+			if (!colorEquals(actual.bg, cell.bg)) diffs.push(`bg: ${formatVTermColor(actual.bg)} vs ${formatVTermColor(cell.bg)}`);
+			if (actual.bold !== !!cell.attrs.bold) diffs.push(`bold: ${actual.bold} vs ${!!cell.attrs.bold}`);
+			if (actual.dim !== !!cell.attrs.dim) diffs.push(`dim: ${actual.dim} vs ${!!cell.attrs.dim}`);
+			if (actual.italic !== !!cell.attrs.italic) diffs.push(`italic: ${actual.italic} vs ${!!cell.attrs.italic}`);
+			const expectedUnderline = !!cell.attrs.underline || !!cell.attrs.underlineStyle;
+			if (actual.underline !== expectedUnderline) diffs.push(`underline: ${actual.underline} vs ${expectedUnderline}`);
+			if (actual.blink !== !!cell.attrs.blink) diffs.push(`blink: ${actual.blink} vs ${!!cell.attrs.blink}`);
+			if (actual.inverse !== !!cell.attrs.inverse) diffs.push(`inverse: ${actual.inverse} vs ${!!cell.attrs.inverse}`);
+			if (actual.hidden !== !!cell.attrs.hidden) diffs.push(`hidden: ${actual.hidden} vs ${!!cell.attrs.hidden}`);
+			if (actual.strikethrough !== !!cell.attrs.strikethrough) diffs.push(`strikethrough: ${actual.strikethrough} vs ${!!cell.attrs.strikethrough}`);
+			if (diffs.length > 0) mismatches.push({
+				x,
+				y,
+				char: cell.char,
+				diffs
+			});
+		}
+		return mismatches;
+	}
+};
+/**
+* Create a default VTermStyle with all attributes reset to defaults.
+*/
+function createDefaultVTermStyle() {
+	return {
+		fg: null,
+		bg: null,
+		bold: false,
+		dim: false,
+		italic: false,
+		underline: false,
+		blink: false,
+		inverse: false,
+		hidden: false,
+		strikethrough: false
+	};
+}
+/**
+* Format a color value for diagnostic display.
+*/
+function formatVTermColor(c) {
+	if (c === null) return "default";
+	if (typeof c === "number") return `${c}`;
+	return `rgb(${c.r},${c.g},${c.b})`;
+}
+/** Commands that should preserve buffer content (only cursor position changes) */
+const CURSOR_COMMANDS = new Set([
+	"cursor_up",
+	"cursor_down",
+	"cursor_left",
+	"cursor_right",
+	"up",
+	"down",
+	"left",
+	"right"
+]);
+/**
+* Parse SILVERY_STABILITY_SKIP_LINES environment variable.
+* Format: comma-separated integers, e.g., "0,-1"
+*/
+function parseSkipLines(env) {
+	if (!env) return [];
+	return env.split(",").map((s) => Number.parseInt(s.trim(), 10)).filter((n) => !isNaN(n));
+}
+/**
+* Compare text content before and after a command.
+* Returns the first mismatch found, or null if content matches.
+*
+* @param before - Text before command execution
+* @param after - Text after command execution
+* @param skipLines - Line indices to skip (supports negative indices from end)
+*/
+function compareText(before, after, skipLines) {
+	const beforeLines = before.split("\n");
+	const afterLines = after.split("\n");
+	const maxLines = Math.max(beforeLines.length, afterLines.length);
+	const skipSet = /* @__PURE__ */ new Set();
+	for (const line of skipLines) if (line >= 0) skipSet.add(line);
+	else skipSet.add(maxLines + line);
+	for (let i = 0; i < maxLines; i++) {
+		if (skipSet.has(i)) continue;
+		const b = beforeLines[i] ?? "";
+		const a = afterLines[i] ?? "";
+		if (b !== a) return {
+			line: i,
+			before: b,
+			after: a
+		};
+	}
+	return null;
+}
+/**
+* Check layout tree integrity. Returns violation messages, or empty array if valid.
+*
+* Checks:
+* - All rect dimensions are finite and non-negative (width >= 0, height >= 0)
+* - All positions are finite (x, y are valid numbers)
+* - No NaN values in computed layout
+* - Children don't overflow parent bounds (1px tolerance for rounding)
+*   - Skips overflow check for nodes with overflow:hidden/scroll (they intentionally clip)
+*/
+function checkLayoutInvariants(node) {
+	const violations = [];
+	walkLayout(node, null, violations);
+	return violations;
+}
+function walkLayout(node, parentRect, violations) {
+	const rect = node.boxRect;
+	if (!rect) return;
+	const id = node.props.id ?? node.type;
+	if (!Number.isFinite(rect.width) || rect.width < 0) violations.push(`${id}: invalid width ${rect.width}`);
+	if (!Number.isFinite(rect.height) || rect.height < 0) violations.push(`${id}: invalid height ${rect.height}`);
+	if (!Number.isFinite(rect.x)) violations.push(`${id}: invalid x ${rect.x}`);
+	if (!Number.isFinite(rect.y)) violations.push(`${id}: invalid y ${rect.y}`);
+	if (parentRect && !parentRect.clipped) {
+		const TOLERANCE = 1;
+		if (rect.x + rect.width > parentRect.x + parentRect.width + TOLERANCE) violations.push(`${id}: overflows parent right (${rect.x + rect.width} > ${parentRect.x + parentRect.width})`);
+		if (rect.y + rect.height > parentRect.y + parentRect.height + TOLERANCE) violations.push(`${id}: overflows parent bottom (${rect.y + rect.height} > ${parentRect.y + parentRect.height})`);
+		if (rect.x < parentRect.x - TOLERANCE) violations.push(`${id}: overflows parent left (${rect.x} < ${parentRect.x})`);
+		if (rect.y < parentRect.y - TOLERANCE) violations.push(`${id}: overflows parent top (${rect.y} < ${parentRect.y})`);
+	}
+	const overflow = node.props.overflow;
+	const clipped = overflow === "hidden" || overflow === "scroll";
+	const childParentRect = {
+		x: rect.x,
+		y: rect.y,
+		width: rect.width,
+		height: rect.height,
+		clipped
+	};
+	for (const child of node.children) walkLayout(child, childParentRect, violations);
+}
+/**
+* Add diagnostic checking to an app with commands.
+*
+* Wraps the `cmd` proxy to intercept all command executions and run checks:
+* - **All commands**: Check that incremental render matches fresh render
+* - **Cursor commands**: Also check that buffer content didn't change
+*
+* **All checks are enabled by default** when you call this function.
+* The principle: if you wrapped with withDiagnostics(), you want diagnostics.
+*
+* @param app - App with command system (from withCommands)
+* @param options - Diagnostic check configuration (all enabled by default)
+* @returns App with wrapped cmd that runs diagnostic checks
+*/
+function withDiagnostics(app, options = {}) {
+	const { checkIncremental = true, checkStability = true, checkReplay = true, checkLayout = true, skipLines = parseSkipLines(process.env.SILVERY_STABILITY_SKIP_LINES), captureOnFailure = false, screenshotDir = "/tmp/silvery-diagnostics" } = options;
+	if (!checkIncremental && !checkStability && !checkReplay && !checkLayout) return app;
+	/** Capture screenshot on diagnostic failure (best-effort, never masks original error) */
+	async function captureFailureScreenshot(commandId, checkType) {
+		if (!captureOnFailure) return null;
+		try {
+			await mkdir(screenshotDir, { recursive: true });
+			const filepath = join(screenshotDir, `fail-${commandId}-${checkType}.png`);
+			await app.screenshot(filepath);
+			return filepath;
+		} catch {
+			return null;
+		}
+	}
+	const wrappedCmd = new Proxy(app.cmd, {
+		get(target, prop) {
+			if (typeof prop === "symbol") return Reflect.get(target, prop);
+			const original = Reflect.get(target, prop);
+			if (typeof original !== "function") return original;
+			if (prop === "all" || prop === "describe") return original;
+			const command = original;
+			const wrapped = async () => {
+				const beforeText = app.text;
+				const beforeBuffer = checkReplay ? app.lastBuffer() : null;
+				await command();
+				if (checkIncremental) {
+					const incremental = app.lastBuffer();
+					try {
+						const fresh = app.freshRender();
+						if (incremental && fresh) {
+							const mismatch = compareBuffers(incremental, fresh);
+							if (mismatch) {
+								const incrementalText = app.text;
+								const freshText = fresh ? Array.from({ length: fresh.height }, (_, y) => Array.from({ length: fresh.width }, (_, x) => fresh.getCellChar(x, y)).join("")).join("\n") : "(no fresh buffer)";
+								const screenshotPath = await captureFailureScreenshot(command.id, "incremental");
+								throw new Error(`SILVERY_DIAGNOSTIC: Incremental/fresh mismatch after ${command.id}\n` + formatMismatch(mismatch, {
+									key: command.id,
+									incrementalText,
+									freshText
+								}) + (screenshotPath ? `\n  Screenshot saved: ${screenshotPath}` : ""));
+							}
+						}
+					} catch (e) {
+						if (!(e instanceof Error) || !e.message.includes("only available in test renderer")) throw e;
+					}
+				}
+				if (checkStability && CURSOR_COMMANDS.has(command.id)) {
+					const afterText = app.text;
+					const mismatch = compareText(beforeText, afterText, skipLines);
+					if (mismatch) {
+						const screenshotPath = await captureFailureScreenshot(command.id, "stability");
+						throw new Error(`SILVERY_DIAGNOSTIC: Content changed after cursor move ${command.id}\n  Line ${mismatch.line}: "${mismatch.before}" → "${mismatch.after}"` + (screenshotPath ? `\n  Screenshot saved: ${screenshotPath}` : ""));
+					}
+				}
+				if (checkReplay && beforeBuffer) {
+					const afterBuffer = app.lastBuffer();
+					if (afterBuffer) {
+						const ansiDiff = outputPhase(beforeBuffer, afterBuffer);
+						const vterm = new VirtualTerminal(afterBuffer.width, afterBuffer.height);
+						vterm.loadFromBuffer(beforeBuffer);
+						vterm.applyAnsi(ansiDiff);
+						const mismatches = vterm.compareToBuffer(afterBuffer);
+						if (mismatches.length > 0) {
+							const details = mismatches.slice(0, 5).map((m) => `  (${m.x},${m.y}): expected="${m.expected}" actual="${m.actual}"`).join("\n");
+							const screenshotPath = await captureFailureScreenshot(command.id, "replay");
+							throw new Error(`SILVERY_DIAGNOSTIC: ANSI replay mismatch after ${command.id}\n  ${mismatches.length} cells differ:\n${details}` + (mismatches.length > 5 ? `\n  ... and ${mismatches.length - 5} more` : "") + (screenshotPath ? `\n  Screenshot saved: ${screenshotPath}` : ""));
+						}
+						const styleMismatches = vterm.compareStylesToBuffer(afterBuffer);
+						if (styleMismatches.length > 0) {
+							const details = styleMismatches.slice(0, 5).map((m) => `  (${m.x},${m.y}) char="${m.char}": ${m.diffs.join(", ")}`).join("\n");
+							const screenshotPath = await captureFailureScreenshot(command.id, "replay-style");
+							throw new Error(`SILVERY_DIAGNOSTIC: ANSI replay style mismatch after ${command.id}\n  ${styleMismatches.length} cells have style differences:\n${details}` + (styleMismatches.length > 5 ? `\n  ... and ${styleMismatches.length - 5} more` : "") + (screenshotPath ? `\n  Screenshot saved: ${screenshotPath}` : ""));
+						}
+					}
+				}
+				if (checkLayout) {
+					const violations = checkLayoutInvariants(app.getContainer());
+					if (violations.length > 0) {
+						const details = violations.slice(0, 10).map((v) => `  ${v}`).join("\n");
+						const screenshotPath = await captureFailureScreenshot(command.id, "layout");
+						throw new Error(`SILVERY_DIAGNOSTIC: Layout invariant violation after ${command.id}\n  ${violations.length} violation(s):\n${details}` + (violations.length > 10 ? `\n  ... and ${violations.length - 10} more` : "") + (screenshotPath ? `\n  Screenshot saved: ${screenshotPath}` : ""));
+					}
+				}
+			};
+			Object.defineProperties(wrapped, {
+				id: {
+					value: command.id,
+					enumerable: true
+				},
+				name: {
+					value: command.name,
+					enumerable: true
+				},
+				help: {
+					value: command.help,
+					enumerable: true
+				},
+				keys: {
+					value: command.keys,
+					enumerable: true
+				}
+			});
+			return wrapped;
+		},
+		has(target, prop) {
+			return Reflect.has(target, prop);
+		},
+		ownKeys(target) {
+			return Reflect.ownKeys(target);
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			return Reflect.getOwnPropertyDescriptor(target, prop);
+		}
+	});
+	return Object.assign(app, { cmd: wrappedCmd });
+}
+//#endregion
+//#region packages/ag-term/src/plugins/with-render.ts
+/**
+* Extend a Term with render pipeline capabilities.
+*
+* Creates a pipeline config (width measurer + output phase) from the term's caps,
+* and adds render() and renderStatic() methods plus measurer methods.
+*
+* @param term - A Term instance (from createTerm)
+* @returns Extended term with render and measurement capabilities
+*/
+function withRender(term) {
+	const pipelineConfig = createPipeline({ caps: term.caps });
+	const { measurer } = pipelineConfig;
+	function renderPipeline(root, width, height, prevBuffer, options) {
+		const { mode = "fullscreen", skipLayoutNotifications = false, skipScrollStateUpdates = false, scrollbackOffset = 0, termRows, cursorPos } = typeof options === "string" ? { mode: options } : options ?? {};
+		const doRender = () => {
+			const ag = createAg(root, { measurer });
+			ag.layout({
+				cols: width,
+				rows: height
+			}, {
+				skipLayoutNotifications,
+				skipScrollStateUpdates
+			});
+			const { buffer, overlay } = ag.render({ prevBuffer });
+			let output = (pipelineConfig.outputPhaseFn ?? outputPhase)(prevBuffer, buffer, mode, scrollbackOffset, termRows, cursorPos);
+			if (overlay) output += overlay;
+			return {
+				output,
+				buffer
+			};
+		};
+		return measurer ? runWithMeasurer(measurer, doRender) : doRender();
+	}
+	async function renderStaticFn(element, options) {
+		const { renderString } = await import("./render-string-DaghHpLN.mjs");
+		return renderString(element, {
+			...options,
+			pipelineConfig
+		});
+	}
+	return Object.create(term, {
+		maybeWideEmojis: {
+			get: () => measurer.maybeWideEmojis,
+			enumerable: true
+		},
+		textSizing: {
+			get: () => measurer.textSizing,
+			enumerable: true
+		},
+		displayWidth: {
+			value: measurer.displayWidth.bind(measurer),
+			enumerable: true
+		},
+		displayWidthAnsi: {
+			value: measurer.displayWidthAnsi.bind(measurer),
+			enumerable: true
+		},
+		graphemeWidth: {
+			value: measurer.graphemeWidth.bind(measurer),
+			enumerable: true
+		},
+		wrapText: {
+			value: measurer.wrapText.bind(measurer),
+			enumerable: true
+		},
+		sliceByWidth: {
+			value: measurer.sliceByWidth.bind(measurer),
+			enumerable: true
+		},
+		sliceByWidthFromEnd: {
+			value: measurer.sliceByWidthFromEnd.bind(measurer),
+			enumerable: true
+		},
+		pipelineConfig: {
+			value: pipelineConfig,
+			enumerable: true
+		},
+		render: {
+			value: renderPipeline,
+			enumerable: true
+		},
+		renderStatic: {
+			value: renderStaticFn,
+			enumerable: true
+		}
+	});
+}
+//#endregion
+//#region packages/create/src/runtime/base-app.ts
+/**
+* Create a fresh {@link BaseApp}. The base handles nothing — all
+* behavior comes from plugins.
+*
+* Call order inside `dispatch(op)`:
+*   1. `apply(op)` (runs the plugin chain, inside reentry guard)
+*   2. Queue the returned effects (if handled)
+*   3. Drain loop — dispatch-type effects re-enter, others bubble up to
+*      the runner via {@link BaseApp.drainEffects}
+*/
+function createBaseApp() {
+	let dispatching = false;
+	let draining = false;
+	/** Effects currently queued from the active dispatch() + its drain. */
+	const effectQueue = [];
+	/** Effects the runner should interpret (everything not consumed by
+	*  the internal dispatch-drain, e.g. render/exit). */
+	const pendingRunnerEffects = [];
+	const app = {
+		dispatch(op) {
+			if (dispatching) throw new Error(`Reentrant dispatch: ${op.type}`);
+			dispatching = true;
+			try {
+				const result = app.apply(op);
+				if (result !== false) effectQueue.push(...result);
+			} finally {
+				dispatching = false;
+			}
+			if (draining) return;
+			draining = true;
+			try {
+				while (effectQueue.length > 0) {
+					const batch = effectQueue.splice(0);
+					for (const eff of batch) if (eff.type === "dispatch") {
+						const nested = eff.op;
+						if (!nested || typeof nested.type !== "string") continue;
+						dispatching = true;
+						try {
+							const nestedResult = app.apply(nested);
+							if (nestedResult !== false) effectQueue.push(...nestedResult);
+						} finally {
+							dispatching = false;
+						}
+					} else pendingRunnerEffects.push(eff);
+				}
+			} finally {
+				draining = false;
+			}
+		},
+		apply() {
+			return false;
+		},
+		drainEffects() {
+			if (pendingRunnerEffects.length === 0) return [];
+			return pendingRunnerEffects.splice(0);
+		}
+	};
+	return app;
+}
+createContext(null);
+createContext({
+	activeId: void 0,
+	isFocusEnabled: true,
+	add() {},
+	remove() {},
+	activate() {},
+	deactivate() {},
+	enableFocus() {},
+	disableFocus() {},
+	focusNext() {},
+	focusPrevious() {},
+	focus() {},
+	blur() {}
+});
+//#endregion
+//#region packages/ag-term/src/bytes-out-monitor.ts
+/**
+* Render-output throughput monitor — backs the `SILVERY_STRICT=bytes_out`
+* slug. Watches the bytes silvery's render pipeline writes to stdout and
+* trips at fixed thresholds.
+*
+* Why this exists: silvery emits ANSI bytes to stdout; those bytes leave the
+* process and land in the pty parent's buffer (terminal multiplexer
+* scrollback — cmux, tmux, etc.). Internal heap profilers
+* (`process.memoryUsage`, `Bun.heapStats`, `--inspect`) cannot see this
+* firehose because the bytes are already gone. The 2026-05-13 cmux/silvercode
+* incident attributed multi-GB of memory to cmux, not silvercode; silvercode's
+* own heap looked healthy throughout. See
+* `docs/lessons/cmux-pty-buffer-firehose.md` (in km root) for the full
+* incident write-up.
+*
+* Behavior (fixed thresholds — no env knobs):
+* - WARN at sustained ≥1 MB/s over a 10s window. Emits a `silvery:bytes_out`
+*   log + writes frame summaries to `/tmp/silvery-bytes-out-warn-<pid>-<ts>.txt`.
+*   Cooldown 10s before re-trip.
+* - PANIC at burst ≥100 MB/s over a 2s window. Emits frame summaries AND a
+*   v8 heap snapshot. Cooldown 60s before re-trip.
+*
+* Activation: tier 1 default (inherited from `SILVERY_STRICT=1`). Opt out per
+* test/session with `SILVERY_STRICT=1,!bytes_out`. The options below are
+* TEST overrides only — production reads no env knobs (per the user's
+* "diagnostics that require remembering ad-hoc env vars don't get used" rule).
+*/
+const NS$2 = "silvery:bytes_out";
+const FRAME_HISTORY$1 = 100;
+const WARN_WINDOW_MS = 1e4;
+const PANIC_WINDOW_MS = 2e3;
+const WARN_COOLDOWN_MS = 1e4;
+const PANIC_COOLDOWN_MS$1 = 6e4;
+const EVICT_OLDER_THAN_MS$1 = 6e4;
+const DEFAULT_WARN_MB_PER_SEC = 1;
+const DEFAULT_PANIC_MB_PER_SEC = 100;
+function createBytesOutMonitor(options = {}) {
+	const warnMbPerSec = options.warnMbPerSec ?? DEFAULT_WARN_MB_PER_SEC;
+	const panicMbPerSec = options.panicMbPerSec ?? DEFAULT_PANIC_MB_PER_SEC;
+	const skipHeapSnapshot = options.skipHeapSnapshot ?? false;
+	const snapshotDir = options.snapshotDir ?? "/tmp";
+	const log = options.logger ?? createLogger(NS$2);
+	const now = options.now ?? Date.now;
+	const writeHeapSnapshot = options.writeHeapSnapshot ?? defaultWriteHeapSnapshot;
+	const writeFile = options.writeFile ?? defaultWriteFile$1;
+	const pid = options.pid ?? process.pid;
+	const warnBytesInWindow = warnMbPerSec * 1e6 * (WARN_WINDOW_MS / 1e3);
+	const panicBytesInWindow = panicMbPerSec * 1e6 * (PANIC_WINDOW_MS / 1e3);
+	const frames = [];
+	let lastWarnAt = 0;
+	let lastPanicAt = 0;
+	let lastTrip = null;
+	let disposed = false;
+	function evictOld(cutoff) {
+		while (frames.length > 0 && frames[0].ts < cutoff) frames.shift();
+	}
+	function sumBytesInWindow(windowMs, t) {
+		const horizon = t - windowMs;
+		let sum = 0;
+		for (let i = frames.length - 1; i >= 0; i--) {
+			const f = frames[i];
+			if (f.ts < horizon) break;
+			sum += f.bytes;
+		}
+		return sum;
+	}
+	function dumpFrameSummaries(filePath) {
+		try {
+			writeFile(filePath, "# frameNum	ts	bytes	source	owner	phase	artifactKind	reason	mode	width	height	prevWidth	prevHeight	changedCells	rawChangedCells	dirtyRows	outputChars	cursorChars	syncWrapped\n" + frames.slice(-FRAME_HISTORY$1).map((f) => {
+				const d = f.diagnostics;
+				return [
+					f.frameNum,
+					new Date(f.ts).toISOString(),
+					f.bytes,
+					d?.source,
+					d?.owner,
+					d?.phase,
+					d?.artifactKind,
+					d?.reason,
+					d?.mode,
+					d?.width,
+					d?.height,
+					d?.prevWidth,
+					d?.prevHeight,
+					d?.changedCells,
+					d?.rawChangedCells,
+					d?.dirtyRows,
+					d?.outputChars,
+					d?.cursorChars,
+					d?.syncWrapped
+				].map(formatSummaryField).join("	");
+			}).join("\n") + "\n");
+			return true;
+		} catch (e) {
+			log.error?.(`failed to write frame summary: ${e.message}`);
+			return false;
+		}
+	}
+	function maybePanic(t) {
+		if (t - lastPanicAt < PANIC_COOLDOWN_MS$1) return false;
+		const burstBytes = sumBytesInWindow(PANIC_WINDOW_MS, t);
+		if (burstBytes < panicBytesInWindow) return false;
+		const summaryPath = `${snapshotDir}/silvery-bytes-out-panic-${pid}-${t}.summary.txt`;
+		dumpFrameSummaries(summaryPath);
+		let snapshotPath;
+		if (!skipHeapSnapshot) {
+			const candidate = `${snapshotDir}/silvery-firehose-${pid}-${t}.heapsnapshot`;
+			try {
+				const written = writeHeapSnapshot(candidate);
+				snapshotPath = typeof written === "string" ? written : candidate;
+			} catch (e) {
+				log.error?.(`failed to write heap snapshot: ${e.message}`);
+			}
+		}
+		const mbPerSec = burstBytes / 1e6 / (PANIC_WINDOW_MS / 1e3);
+		log.error?.(`PANIC render-out burst ${mbPerSec.toFixed(1)} MB/s exceeds ${panicMbPerSec} MB/s for ${PANIC_WINDOW_MS}ms`, {
+			summary: summaryPath,
+			heapSnapshot: snapshotPath
+		});
+		lastPanicAt = t;
+		lastTrip = {
+			kind: "panic",
+			ts: t,
+			mbPerSec,
+			summaryPath,
+			snapshotPath
+		};
+		return true;
+	}
+	function maybeWarn(t) {
+		if (t - lastWarnAt < WARN_COOLDOWN_MS) return false;
+		const sustainedBytes = sumBytesInWindow(WARN_WINDOW_MS, t);
+		if (sustainedBytes < warnBytesInWindow) return false;
+		const summaryPath = `${snapshotDir}/silvery-bytes-out-warn-${pid}-${t}.summary.txt`;
+		dumpFrameSummaries(summaryPath);
+		const mbPerSec = sustainedBytes / 1e6 / (WARN_WINDOW_MS / 1e3);
+		log.warn?.(`WARN render-out sustained ${mbPerSec.toFixed(1)} MB/s exceeds ${warnMbPerSec} MB/s over ${WARN_WINDOW_MS}ms`, { summary: summaryPath });
+		lastWarnAt = t;
+		lastTrip = {
+			kind: "warn",
+			ts: t,
+			mbPerSec,
+			summaryPath
+		};
+		return true;
+	}
+	function recordWrite(frameNum, bytes, diagnostics) {
+		if (disposed) return;
+		const t = now();
+		evictOld(t - EVICT_OLDER_THAN_MS$1);
+		frames.push({
+			frameNum,
+			ts: t,
+			bytes,
+			diagnostics
+		});
+		if (maybePanic(t)) return;
+		maybeWarn(t);
+	}
+	function snapshotFrames() {
+		return frames.slice();
+	}
+	function dispose() {
+		disposed = true;
+		frames.length = 0;
+	}
+	return {
+		recordWrite,
+		get lastTrip() {
+			return lastTrip;
+		},
+		snapshotFrames,
+		dispose
+	};
+}
+function formatSummaryField(value) {
+	if (value === void 0 || value === null) return "";
+	return String(value);
+}
+function defaultWriteHeapSnapshot(path) {
+	return loadV8().writeHeapSnapshot(path);
+}
+function defaultWriteFile$1(path, contents) {
+	process.getBuiltinModule("node:fs").writeFileSync(path, contents);
+}
+function loadV8() {
+	return process.getBuiltinModule("node:v8");
+}
+//#endregion
+//#region packages/ag-term/src/flicker-monitor.ts
+/**
+* Repaint-storm (flicker) monitor — backs the `SILVERY_STRICT=flicker` slug
+* (alias intent: "cls_storm"). Watches the ANSI byte stream silvery's render
+* pipeline writes to the terminal and PANICs when destructive full-screen
+* clears / scroll-region resets repeat fast enough to constitute visible
+* flicker.
+*
+* Why this exists: flicker is the single hardest render bug to catch — it is
+* invisible to text-frame assertions (the FINAL frame is correct; the damage
+* is the transient blank between frames) and historically took eyeball +
+* `#undead` rounds to pin down. The `@ag/code/20297-pane-flicker-on-resize`
+* incident was a bare `\x1b[2J` emitted OUTSIDE the DEC-2026 sync region on
+* every resize: each `2J` blanked the pane for one composited frame before the
+* repaint landed. Repeated rapidly (resize-drag, a layout limit-cycle, or a
+* stale process re-emitting frames) that is a strobing blank-flash. This
+* monitor makes that class fail LOUD + NAMED at the source.
+*
+* What counts as a storm signal (per frame written to the terminal):
+* - `\x1b[2J` / `\x1b[3J` — erase-in-display (the 20297 culprit). `\x1b[J` and
+*   `\x1b[0J` (erase-to-end) and `\x1b[1J` (erase-to-start) are NOT counted:
+*   they are partial, non-blanking, and used legitimately by inline/static
+*   output. Only the full-screen erasers blank the viewport.
+* - `\x1b[r` / `\x1b[<top>;<bottom>r` — DECSTBM scroll-region reset/set. A
+*   scroll-region thrash (set/reset churn) is the other shape of repaint
+*   storm (a "scroll storm"); a single frame carrying one is benign,
+*   repetition in the window is not.
+*
+* What does NOT count (CRITICAL — the 20297 *fix* must never false-trip):
+* - A homed full-viewport repaint (`\x1b[H` followed by a full `bufferToAnsi`
+*   rewrite of every cell) is the LEGITIMATE post-20297 resize/focus frame. It
+*   carries NO `2J`/`3J` at all, so it registers ZERO storm signals — it can
+*   never trip this monitor regardless of size. The monitor targets
+*   destructive-clear REPETITION within a window, not full repaints, and not a
+*   single isolated clear.
+*
+* Behavior (fixed thresholds — no env knobs):
+* - PANIC when ≥ `PANIC_CLEARS` destructive clears land within `WINDOW_MS`
+*   with no intervening settle (a settle = a frame in the window that carried
+*   zero storm signals, i.e. the storm actually paused). The diagnostic NAMES
+*   the offending sequence + the count + the window, plus a culprit hint
+*   (bare `2J` outside the sync region — the @ag/code/20297 signature).
+*   Cooldown `PANIC_COOLDOWN_MS` before a re-trip so a genuine sustained storm
+*   logs once, not every frame.
+*
+* Activation: tier 1 default (inherited from `SILVERY_STRICT=1`, the same tier
+* as `bytes_out`/`mem`). Opt out per test/session with
+* `SILVERY_STRICT=1,!flicker`. The options below are TEST overrides only —
+* production reads no env knobs (per the user's "diagnostics that require
+* remembering ad-hoc env vars don't get used" rule).
+*/
+const NS$1 = "silvery:flicker";
+/** Rolling window over which clears are counted. */
+const WINDOW_MS = 1e3;
+/**
+* Number of destructive full-screen clears within the window (with no
+* intervening settle frame) that constitutes a repaint storm.
+*
+* Three is deliberately above any LEGITIMATE clear cadence:
+* - A normal session emits at most ONE full clear per discrete event (startup
+*   alt-screen entry, an explicit `invalidate({ clearScreen })` on focus-in).
+*   Post-20297 a resize/focus repaint emits ZERO `2J` (the homed full repaint
+*   IS the clear), so even rapid resize-drag produces no clears at all.
+* - The 20297 BUG emitted a `2J` on EVERY resize frame; a resize-drag fires
+*   tens of frames per second → ≫3 clears in a 1 s window → trips.
+*/
+const PANIC_CLEARS = 3;
+/** Cooldown before a sustained storm is allowed to re-log. */
+const PANIC_COOLDOWN_MS = 5e3;
+/** Drop frame records older than this to keep memory bounded. */
+const EVICT_OLDER_THAN_MS = 1e4;
+/** Last-N frames retained for the diagnostic dump. */
+const FRAME_HISTORY = 50;
+/**
+* Destructive full-screen erase-in-display: `\x1b[2J` (whole viewport) and
+* `\x1b[3J` (viewport + scrollback). Deliberately does NOT match `\x1b[J`,
+* `\x1b[0J`, or `\x1b[1J` — those are partial, non-blanking erases.
+*/
+const FULL_CLEAR_RE = /\x1b\[[23]J/g;
+/**
+* DECSTBM scroll-region reset/set: `\x1b[r` (reset to full screen) or
+* `\x1b[<top>;<bottom>r`. A private-mode variant (`\x1b[?...r`) is matched too
+* so DEC private scroll-region churn is caught.
+*/
+const SCROLL_REGION_RE = /\x1b\[\??(?:\d+(?:;\d+)*)?r/g;
+function createFlickerMonitor(options = {}) {
+	const panicClears = options.panicClears ?? PANIC_CLEARS;
+	const windowMs = options.windowMs ?? WINDOW_MS;
+	const noThrow = options.noThrow ?? false;
+	const log = options.logger ?? createLogger(NS$1);
+	const now = options.now ?? Date.now;
+	const writeFile = options.writeFile ?? defaultWriteFile;
+	const snapshotDir = options.snapshotDir ?? "/tmp";
+	const pid = options.pid ?? process.pid;
+	const frames = [];
+	let lastPanicAt = 0;
+	let lastTrip = null;
+	let disposed = false;
+	function evictOld(cutoff) {
+		while (frames.length > 0 && frames[0].ts < cutoff) frames.shift();
+	}
+	/**
+	* Count storm signals across the in-window tail. Returns the totals AND
+	* whether the storm settled (a window frame carried zero signals) — a settle
+	* resets the "fast repetition" judgment so a slow trickle of clears spread
+	* across calm frames never trips.
+	*/
+	function tallyWindow(t) {
+		const horizon = t - windowMs;
+		let fullClears = 0;
+		let scrollRegionResets = 0;
+		let settled = false;
+		for (let i = frames.length - 1; i >= 0; i--) {
+			const f = frames[i];
+			if (f.ts < horizon) break;
+			const s = f.signals;
+			if (s.fullClears + s.scrollRegionResets === 0) {
+				settled = true;
+				break;
+			}
+			fullClears += s.fullClears;
+			scrollRegionResets += s.scrollRegionResets;
+		}
+		return {
+			fullClears,
+			scrollRegionResets,
+			settled
+		};
+	}
+	function dumpFrameSummaries(filePath) {
+		try {
+			writeFile(filePath, "# frameNum	ts	bytes	fullClears	scrollRegionResets\n" + frames.slice(-FRAME_HISTORY).map((f) => [
+				f.frameNum,
+				new Date(f.ts).toISOString(),
+				f.bytes,
+				f.signals.fullClears,
+				f.signals.scrollRegionResets
+			].join("	")).join("\n") + "\n");
+		} catch (e) {
+			log.error?.(`failed to write flicker frame summary: ${e.message}`);
+		}
+	}
+	function maybePanic(t) {
+		if (t - lastPanicAt < PANIC_COOLDOWN_MS) return;
+		const { fullClears, scrollRegionResets, settled } = tallyWindow(t);
+		if (settled) return;
+		if (fullClears < panicClears) return;
+		const summaryPath = `${snapshotDir}/silvery-flicker-panic-${pid}-${t}.summary.txt`;
+		dumpFrameSummaries(summaryPath);
+		const clearSeq = "\\x1b[2J";
+		const sequence = scrollRegionResets > 0 ? "\\x1b[2J/\\x1b[3J full-screen clear + \\x1b[r scroll-region reset" : "\\x1b[2J/\\x1b[3J full-screen clear";
+		const message = `PANIC repaint storm: ${fullClears} full-screen clears` + (scrollRegionResets > 0 ? ` + ${scrollRegionResets} scroll-region resets` : "") + ` in ${windowMs}ms (threshold ${panicClears}). Offending sequence: ${sequence}. Likely culprit: a destructive ${clearSeq} emitted per-frame outside the DEC-2026 sync region (the @ag/code/20297-pane-flicker-on-resize signature) — a full repaint should home (\\x1b[H) and overwrite cells instead. Frame summary: ${summaryPath}`;
+		log.error?.(message, {
+			clears: fullClears,
+			scrollRegionResets,
+			windowMs,
+			summary: summaryPath
+		});
+		lastPanicAt = t;
+		lastTrip = {
+			kind: "panic",
+			ts: t,
+			clears: fullClears,
+			scrollRegionResets,
+			windowMs,
+			sequence,
+			message,
+			summaryPath
+		};
+		if (!noThrow) throw new Error(message);
+	}
+	function recordFrame(frameNum, output) {
+		if (disposed) return;
+		const t = now();
+		evictOld(t - EVICT_OLDER_THAN_MS);
+		const signals = {
+			fullClears: countMatches(output, FULL_CLEAR_RE),
+			scrollRegionResets: countMatches(output, SCROLL_REGION_RE)
+		};
+		frames.push({
+			frameNum,
+			ts: t,
+			bytes: output.length,
+			signals
+		});
+		maybePanic(t);
+	}
+	function snapshotFrames() {
+		return frames.slice();
+	}
+	function dispose() {
+		disposed = true;
+		frames.length = 0;
+	}
+	return {
+		recordFrame,
+		get lastTrip() {
+			return lastTrip;
+		},
+		snapshotFrames,
+		dispose
+	};
+}
+function countMatches(haystack, re) {
+	re.lastIndex = 0;
+	let count = 0;
+	while (re.exec(haystack) !== null) count++;
+	re.lastIndex = 0;
+	return count;
+}
+function defaultWriteFile(path, contents) {
+	process.getBuiltinModule("node:fs").writeFileSync(path, contents);
+}
+//#endregion
+//#region packages/ag-term/src/mem-monitor.ts
+/**
+* In-process heap poll monitor — backs the `SILVERY_STRICT=mem` slug
+* (Layer 2 of the memory-observability stack).
+*
+* Samples `process.memoryUsage()` every 30 s on a fixed interval, logs the
+* full breakdown via the `silvery:mem` loggily namespace, and trips a
+* one-shot WARN line if RSS or `external + arrayBuffers` doubles within a
+* 60 s window.
+*
+* Where this fits: L1 (`bytes_out`) watches data leaving the process via the
+* render pipeline. L2 (`mem`, this file) watches data still inside the
+* process. L4 (`bun memwatch <pid>`) is the external view. Together they
+* cover the bytes-out / bytes-in / RSS-outside triad for a pty-attached
+* TUI. See `docs/lessons/cmux-pty-buffer-firehose.md` (in km root) for the
+* motivating incident.
+*
+* Convention: tier-1 default, opt-out via `SILVERY_STRICT=1,!mem`. No env
+* knobs — fixed sample cadence + threshold in code. Per the user-direction
+* documented in `vendor/silvery/docs/guide/debugging.md`:
+* "diagnostics that require remembering ad-hoc env vars don't get used."
+*/
+const NS = "silvery:mem";
+const SAMPLE_INTERVAL_MS = 3e4;
+const DOUBLE_WINDOW_MS = 6e4;
+const SAMPLE_HISTORY = 8;
+function createMemMonitor(options = {}) {
+	const log = options.logger ?? createLogger(NS);
+	const now = options.now ?? Date.now;
+	const memoryUsage = options.memoryUsage ?? process.memoryUsage;
+	const manual = options.manual ?? false;
+	const samples = [];
+	let lastWarn = null;
+	let lastWarnReason = null;
+	let disposed = false;
+	let interval = null;
+	function evictOld(cutoff) {
+		while (samples.length > 0 && samples[0].ts < cutoff) samples.shift();
+		while (samples.length > SAMPLE_HISTORY) samples.shift();
+	}
+	function snapshotMin(field, windowMs, t) {
+		const horizon = t - windowMs;
+		let min = Number.POSITIVE_INFINITY;
+		for (const s of samples) {
+			if (s.ts < horizon) continue;
+			const v = s[field];
+			if (v < min) min = v;
+		}
+		return min;
+	}
+	function tick() {
+		if (disposed) return;
+		const t = now();
+		const m = memoryUsage();
+		const sample = {
+			ts: t,
+			rss: m.rss,
+			heapUsed: m.heapUsed,
+			heapTotal: m.heapTotal,
+			external: m.external,
+			arrayBuffers: m.arrayBuffers
+		};
+		samples.push(sample);
+		evictOld(t - DOUBLE_WINDOW_MS * 2);
+		log.info?.("mem sample", {
+			rss_mb: Math.round(sample.rss / 1e6),
+			heap_used_mb: Math.round(sample.heapUsed / 1e6),
+			heap_total_mb: Math.round(sample.heapTotal / 1e6),
+			external_mb: Math.round(sample.external / 1e6),
+			array_buffers_mb: Math.round(sample.arrayBuffers / 1e6)
+		});
+		const rssMin = snapshotMin("rss", DOUBLE_WINDOW_MS, t);
+		if (Number.isFinite(rssMin) && rssMin > 0 && sample.rss >= rssMin * 2) {
+			const reason = `RSS doubled in ${DOUBLE_WINDOW_MS / 1e3}s: ${Math.round(rssMin / 1e6)} → ${Math.round(sample.rss / 1e6)} MB`;
+			if (reason !== lastWarnReason) {
+				log.warn?.(`WARN ${reason}`);
+				lastWarn = {
+					ts: t,
+					reason
+				};
+				lastWarnReason = reason;
+			}
+			return;
+		}
+		const offHeapNow = sample.external + sample.arrayBuffers;
+		const horizon = t - DOUBLE_WINDOW_MS;
+		let offHeapMin = Number.POSITIVE_INFINITY;
+		for (const s of samples) {
+			if (s.ts < horizon) continue;
+			const sum = s.external + s.arrayBuffers;
+			if (sum < offHeapMin) offHeapMin = sum;
+		}
+		if (Number.isFinite(offHeapMin) && offHeapMin > 0 && offHeapNow >= offHeapMin * 2) {
+			const reason = `external+arrayBuffers doubled in ${DOUBLE_WINDOW_MS / 1e3}s: ${Math.round(offHeapMin / 1e6)} → ${Math.round(offHeapNow / 1e6)} MB`;
+			if (reason !== lastWarnReason) {
+				log.warn?.(`WARN ${reason}`);
+				lastWarn = {
+					ts: t,
+					reason
+				};
+				lastWarnReason = reason;
+			}
+		}
+	}
+	function dispose() {
+		if (disposed) return;
+		disposed = true;
+		if (interval !== null) {
+			clearInterval(interval);
+			interval = null;
+		}
+		samples.length = 0;
+	}
+	if (!manual) {
+		interval = setInterval(tick, SAMPLE_INTERVAL_MS);
+		const maybeUnref = interval;
+		if (typeof maybeUnref.unref === "function") maybeUnref.unref();
+	}
+	return {
+		tick,
+		get lastSample() {
+			return samples.length > 0 ? samples[samples.length - 1] : null;
+		},
+		get lastWarn() {
+			return lastWarn;
+		},
+		dispose
+	};
+}
+//#endregion
+//#region packages/test/src/debug-mismatch.ts
+/**
+* Find the innermost node at a screen position.
+*/
+function findNodeAtPosition(root, x, y) {
+	let result = null;
+	function visit(node) {
+		const rect = node.scrollRect;
+		if (!rect) return;
+		if (x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height) {
+			result = node;
+			for (const child of node.children) visit(child);
+		}
+	}
+	visit(root);
+	return result;
+}
+/**
+* Find all nodes whose scrollRect contains the given position.
+* Returns nodes from root to innermost (outermost first).
+*/
+function findAllContainingNodes(root, x, y) {
+	const result = [];
+	function visit(node) {
+		const rect = node.scrollRect;
+		if (!rect) return;
+		if (x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height) {
+			result.push(node);
+			for (const child of node.children) visit(child);
+		}
+	}
+	visit(root);
+	return result;
+}
+/**
+* Get the path from root to a node (for identification).
+*/
+function getNodePath(node) {
+	const parts = [];
+	let current = node;
+	while (current) {
+		const props = current.props;
+		if (props.id) parts.unshift(`#${props.id}`);
+		else if (current.parent) {
+			const idx = current.parent.children.indexOf(current);
+			parts.unshift(`[${idx}]`);
+		} else parts.unshift("root");
+		current = current.parent;
+	}
+	return parts.join(" > ");
+}
+/**
+* Check if a rect changed (position or size).
+*/
+function rectChanged(a, b) {
+	if (a === b) return false;
+	if (!a || !b) return true;
+	return a.x !== b.x || a.y !== b.y || a.width !== b.width || a.height !== b.height;
+}
+/**
+* Extract debug info from a node.
+*/
+function getNodeDebugInfo(node) {
+	const props = node.props;
+	let childIndex = null;
+	if (node.parent) childIndex = node.parent.children.indexOf(node);
+	return {
+		id: props.id,
+		type: node.type,
+		path: getNodePath(node),
+		childIndex,
+		dirtyFlags: {
+			contentDirty: isDirty(node.dirtyBits, node.dirtyEpoch, 1),
+			stylePropsDirty: isDirty(node.dirtyBits, node.dirtyEpoch, 2),
+			subtreeDirty: isDirty(node.dirtyBits, node.dirtyEpoch, 16),
+			childrenDirty: isDirty(node.dirtyBits, node.dirtyEpoch, 8)
+		},
+		layout: {
+			prevLayout: node.prevLayout,
+			boxRect: node.boxRect,
+			scrollRect: node.scrollRect,
+			layoutChanged: rectChanged(node.prevLayout, node.boxRect)
+		},
+		scroll: node.scrollState ? {
+			offset: node.scrollState.offset,
+			prevOffset: node.scrollState.prevOffset,
+			offsetChanged: node.scrollState.offset !== node.scrollState.prevOffset,
+			contentHeight: node.scrollState.contentHeight,
+			viewportHeight: node.scrollState.viewportHeight,
+			hiddenAbove: node.scrollState.hiddenAbove,
+			hiddenBelow: node.scrollState.hiddenBelow,
+			firstVisibleChild: node.scrollState.firstVisibleChild,
+			lastVisibleChild: node.scrollState.lastVisibleChild
+		} : void 0,
+		backgroundColor: props.backgroundColor,
+		childCount: node.children.length,
+		hidden: node.hidden ?? false
+	};
+}
+/**
+* Find scroll container ancestors for a node.
+*/
+function findScrollAncestors(node) {
+	const result = [];
+	let current = node.parent;
+	while (current) {
+		if (current.scrollState) result.push(current);
+		current = current.parent;
+	}
+	return result;
+}
+/**
+* Analyze why a node might have been incorrectly skipped by fast-path.
+*/
+function analyzeFastPath(node, scrollAncestors) {
+	const analysis = [];
+	if (!node) {
+		analysis.push("⚠ No node found at mismatch position - possible virtualization issue");
+		return analysis;
+	}
+	const flags = node;
+	if (!isAnyDirty(flags.dirtyBits, flags.dirtyEpoch)) analysis.push("⚠ ALL DIRTY FLAGS FALSE - fast-path likely skipped this node");
+	const scrollParent = scrollAncestors[0];
+	if (scrollParent?.scrollState) {
+		const ss = scrollParent.scrollState;
+		const childIndex = node.parent ? node.parent.children.indexOf(node) : -1;
+		const inVisibleRange = childIndex >= ss.firstVisibleChild && childIndex <= ss.lastVisibleChild;
+		if (!inVisibleRange && childIndex >= 0) {
+			analysis.push(`⚠ Node index ${childIndex} is OUTSIDE visible range [${ss.firstVisibleChild}..${ss.lastVisibleChild}]`);
+			analysis.push("  → Node should have been skipped, but mismatch suggests it should render");
+		} else if (inVisibleRange) analysis.push(`✓ Node index ${childIndex} is in visible range [${ss.firstVisibleChild}..${ss.lastVisibleChild}]`);
+		if (ss.offset === ss.prevOffset) analysis.push("✓ Scroll offset unchanged (fast-path enabled for children)");
+		else analysis.push(`⚠ Scroll offset CHANGED: ${ss.prevOffset} → ${ss.offset}`);
+		if (ss.firstVisibleChild !== 0 || ss.lastVisibleChild !== scrollParent.children.length - 1) {
+			analysis.push(`  Visible range is partial: [${ss.firstVisibleChild}..${ss.lastVisibleChild}] of ${scrollParent.children.length} children`);
+			analysis.push("  → If visible range changed, newly visible children need rendering");
+		}
+	}
+	if (!rectChanged(node.prevLayout, node.boxRect) && node.prevLayout) analysis.push("✓ Layout unchanged (prevLayout matches boxRect)");
+	else if (!node.prevLayout) analysis.push("⚠ prevLayout is NULL - node may never have been rendered before");
+	else analysis.push("⚠ Layout CHANGED but node still skipped - dirty flag not set?");
+	if (node.parent && node.parent.children.length > 1) {
+		let siblingMoved = false;
+		for (const sibling of node.parent.children) if (sibling !== node && sibling.boxRect && sibling.prevLayout) {
+			if (sibling.boxRect.x !== sibling.prevLayout.x || sibling.boxRect.y !== sibling.prevLayout.y) {
+				siblingMoved = true;
+				break;
+			}
+		}
+		if (siblingMoved) analysis.push("⚠ SIBLING POSITION CHANGED - parent should have detected this");
+	}
+	if (node.hidden) analysis.push("⚠ Node is HIDDEN (Suspense) - should not be rendered");
+	return analysis;
+}
+/**
+* Build full mismatch debug context.
+*/
+function buildMismatchContext(root, x, y, incrementalCell, freshCell, renderNum) {
+	const innermost = findNodeAtPosition(root, x, y);
+	const containing = findAllContainingNodes(root, x, y);
+	const scrollAncestorNodes = innermost ? findScrollAncestors(innermost) : [];
+	return {
+		position: {
+			x,
+			y
+		},
+		cells: {
+			incremental: incrementalCell,
+			fresh: freshCell
+		},
+		renderNum,
+		node: innermost ? getNodeDebugInfo(innermost) : null,
+		scrollAncestors: scrollAncestorNodes.map(getNodeDebugInfo),
+		containingNodes: containing.map(getNodeDebugInfo),
+		fastPathAnalysis: analyzeFastPath(innermost, scrollAncestorNodes)
+	};
+}
+/**
+* Format mismatch context as a human-readable string.
+*
+* @param ctx - The mismatch debug context (node attribution, dirty flags, scroll, fast-path)
+* @param renderPhaseStats - Optional render-phase instrumentation snapshot (auto-included by SILVERY_STRICT)
+*/
+function formatMismatchContext(ctx, renderPhaseStats) {
+	const lines = [];
+	lines.push(`SILVERY_STRICT: MISMATCH at (${ctx.position.x}, ${ctx.position.y}) on render #${ctx.renderNum}`);
+	lines.push("");
+	const { incremental, fresh } = ctx.cells;
+	lines.push("CELL VALUES:");
+	lines.push(`  incremental: char=${JSON.stringify(incremental.char)} fg=${JSON.stringify(incremental.fg)} bg=${JSON.stringify(incremental.bg)} attrs=${JSON.stringify(incremental.attrs)}`);
+	lines.push(`  fresh:       char=${JSON.stringify(fresh.char)} fg=${JSON.stringify(fresh.fg)} bg=${JSON.stringify(fresh.bg)} attrs=${JSON.stringify(fresh.attrs)}`);
+	lines.push("");
+	if (ctx.node) {
+		lines.push("INNERMOST NODE:");
+		lines.push(`  path: ${ctx.node.path}`);
+		lines.push(`  type: ${ctx.node.type}`);
+		if (ctx.node.backgroundColor) lines.push(`  backgroundColor: ${ctx.node.backgroundColor}`);
+		lines.push("");
+		const flags = ctx.node.dirtyFlags;
+		const activeFlags = Object.entries(flags).filter(([, v]) => v).map(([k]) => k);
+		lines.push("DIRTY FLAGS:");
+		if (activeFlags.length > 0) lines.push(`  active: ${activeFlags.join(", ")}`);
+		else lines.push("  active: (none - node was clean)");
+		lines.push(`  all: contentDirty=${flags.contentDirty} stylePropsDirty=${flags.stylePropsDirty} subtreeDirty=${flags.subtreeDirty} childrenDirty=${flags.childrenDirty}`);
+		lines.push("");
+		const { layout } = ctx.node;
+		lines.push("LAYOUT:");
+		if (layout.layoutChanged) {
+			lines.push("  ⚠ LAYOUT CHANGED:");
+			lines.push(`    prevLayout: ${formatRect(layout.prevLayout)}`);
+			lines.push(`    boxRect: ${formatRect(layout.boxRect)}`);
+		} else lines.push(`  boxRect: ${formatRect(layout.boxRect)}`);
+		lines.push(`  scrollRect: ${formatRect(layout.scrollRect)}`);
+		lines.push("");
+		if (ctx.node.scroll) {
+			lines.push("SCROLL STATE (this node):");
+			formatScrollState(lines, ctx.node.scroll);
+			lines.push("");
+		}
+	} else {
+		lines.push("INNERMOST NODE: (none found at this position)");
+		lines.push("");
+	}
+	if (ctx.scrollAncestors.length > 0) {
+		lines.push("SCROLL ANCESTORS:");
+		for (const ancestor of ctx.scrollAncestors) {
+			lines.push(`  ${ancestor.path}:`);
+			if (ancestor.scroll) formatScrollState(lines, ancestor.scroll, "    ");
+		}
+		lines.push("");
+	}
+	if (ctx.containingNodes.length > 1) {
+		lines.push("ALL CONTAINING NODES (outermost to innermost):");
+		for (const node of ctx.containingNodes) {
+			const flags = Object.entries(node.dirtyFlags).filter(([, v]) => v).map(([k]) => k.replace("Dirty", "")).join(",");
+			const flagStr = flags ? ` [${flags}]` : " [clean]";
+			const bgStr = node.backgroundColor ? ` bg=${node.backgroundColor}` : "";
+			const childStr = node.childIndex !== null ? ` child[${node.childIndex}]` : "";
+			lines.push(`  ${node.path}${flagStr}${bgStr}${childStr}`);
+		}
+		lines.push("");
+	}
+	if (ctx.fastPathAnalysis.length > 0) {
+		lines.push("FAST-PATH ANALYSIS:");
+		for (const line of ctx.fastPathAnalysis) lines.push(`  ${line}`);
+		lines.push("");
+	}
+	if (renderPhaseStats) {
+		const s = renderPhaseStats;
+		lines.push("RENDER PHASE STATS:");
+		lines.push(`  nodesVisited: ${s.nodesVisited}  nodesRendered: ${s.nodesRendered}  nodesSkipped: ${s.nodesSkipped}`);
+		lines.push(`  textNodes: ${s.textNodes}  boxNodes: ${s.boxNodes}  clearOps: ${s.clearOps}`);
+		const flagLines = [];
+		if (s.noPrevBuffer) flagLines.push(`noPrevBuffer=${s.noPrevBuffer}`);
+		if (s.flagContentDirty) flagLines.push(`contentDirty=${s.flagContentDirty}`);
+		if (s.flagStylePropsDirty) flagLines.push(`stylePropsDirty=${s.flagStylePropsDirty}`);
+		if (s.flagLayoutChanged) flagLines.push(`layoutChanged=${s.flagLayoutChanged}`);
+		if (s.flagSubtreeDirty) flagLines.push(`subtreeDirty=${s.flagSubtreeDirty}`);
+		if (s.flagChildrenDirty) flagLines.push(`childrenDirty=${s.flagChildrenDirty}`);
+		if (s.flagChildPositionChanged) flagLines.push(`childPositionChanged=${s.flagChildPositionChanged}`);
+		if (flagLines.length > 0) lines.push(`  render reasons: ${flagLines.join(", ")}`);
+		if (s.scrollContainerCount > 0) {
+			lines.push(`  scrollContainers: ${s.scrollContainerCount}  viewportCleared: ${s.scrollViewportCleared}`);
+			if (s.scrollClearReason) lines.push(`  scrollClearReason: ${s.scrollClearReason}`);
+		}
+		if (s.normalChildrenRepaint > 0) {
+			lines.push(`  normalChildrenRepaint: ${s.normalChildrenRepaint}`);
+			if (s.normalRepaintReason) lines.push(`  normalRepaintReason: ${s.normalRepaintReason}`);
+		}
+		if (s.cascadeMinDepth < 999) {
+			lines.push(`  cascadeMinDepth: ${s.cascadeMinDepth}`);
+			if (s.cascadeNodes) lines.push(`  cascadeNodes: ${s.cascadeNodes}`);
+		}
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+function formatRect(rect) {
+	if (!rect) return "(null)";
+	return `{x:${rect.x}, y:${rect.y}, w:${rect.width}, h:${rect.height}}`;
+}
+function formatScrollState(lines, scroll, indent = "  ") {
+	if (scroll.offsetChanged) lines.push(`${indent}⚠ SCROLL CHANGED: offset ${scroll.prevOffset} → ${scroll.offset}`);
+	else lines.push(`${indent}offset: ${scroll.offset}`);
+	lines.push(`${indent}viewport: ${scroll.viewportHeight}/${scroll.contentHeight} (hidden: ▲${scroll.hiddenAbove} ▼${scroll.hiddenBelow})`);
+	lines.push(`${indent}visibleRange: [${scroll.firstVisibleChild}..${scroll.lastVisibleChild}]`);
+}
+//#endregion
+//#region packages/ag-term/src/managed-caret.ts
+/**
+* Resolve the composited caret SHAPE from the cursor's declared shape. Only ever
+* called when a caret is shown at all — i.e. the window is FOCUSED (an unfocused
+* window composites no caret; see `composeManagedCaret`).
+*
+* - A declared `shape: "underline"` wins — an underline-shaped caret is
+*   semantically distinct and stays underline.
+* - Otherwise the default filled `"block"`.
+*/
+function caretStyle(cursor) {
+	return cursor.shape === "underline" ? "underline" : "block";
+}
+/** Map a composited-caret style to the cell attributes that render it. */
+function caretCellAttrs(style) {
+	switch (style) {
+		case "underline": return { underline: true };
+		default: return { inverse: true };
+	}
+}
+/**
+* Paint a semantic caret into a presentation buffer for managed terminal frames.
+*
+* The source buffer stays untouched. Runtime diff state stores the presentation
+* buffer so moving/hiding the caret clears the previous frame's overlay like any
+* other cell update.
+*
+* @param windowFocused - whether the terminal WINDOW is focused. An UNFOCUSED
+*   window composites NO caret (@km/code/v0.2/19702, reframed 2026-06-18: hide
+*   the cursor COMPLETELY, replacing 20082's hollow box). Defaults to `true` —
+*   a fail-safe so a single user with a focused terminal (or any caller that
+*   hasn't wired standard `?1004` focus reporting) still sees the filled block,
+*   never a vanished caret on unknown focus. For a composited caret the hardware
+*   cursor is parked-and-hidden regardless of focus (see `managedCursorSuffix`),
+*   so an unfocused pane shows nothing at all — and a dropped `?25l` cannot
+*   strand a hardware cursor. The one exception is a `cursorActive` island
+*   host-caret, shown as the real hardware cursor when the window is focused
+*   (see `computeManagedFrame` / @hab 20398).
+*/
+function composeManagedCaret(buffer, cursor, windowFocused = true) {
+	if (!windowFocused || !cursor?.visible || !buffer.inBounds(cursor.x, cursor.y)) return {
+		buffer,
+		compositorCaret: null
+	};
+	const next = buffer.clone();
+	next.markAllRowsDirty();
+	const style = caretStyle(cursor);
+	next.mergeAttrsInRect(cursor.x, cursor.y, 1, 1, caretCellAttrs(style));
+	return {
+		buffer: next,
+		compositorCaret: {
+			x: cursor.x,
+			y: cursor.y,
+			visible: true,
+			style
+		}
+	};
+}
+/** SILVERY_STRICT slug for the managed-caret overlay-residue check. */
+const CARET_OVERLAY_STRICT_SLUG = "cursor";
+function sameCaretCell(a, b) {
+	if (a === null || b === null) return a === b;
+	return a.x === b.x && a.y === b.y;
+}
+/**
+* Clear a prior frame's composited-caret overlay from a STATIC row.
+*
+* `composeManagedCaret`'s two paths are asymmetric about dirty rows: the PAINT
+* path calls `markAllRowsDirty()` (so a freshly-painted caret is always
+* diffed), but the NO-CARET early-return hands back the source buffer untouched.
+* When a caret that was painted at cell C in frame N is suppressed or moves to a
+* different cell in frame N+1, and C's ROW is otherwise static (clean in the
+* incremental buffer — the reconciler only marks rows whose content changed),
+* `diffBuffers` skips that row (`if (!next.isRowDirty(y)) continue`). The frame-N
+* `inverse` cell is then never compared against the cleared frame-N+1 buffer, so
+* the reverse-video block strands on screen with NO `?25h`/CUP — the
+* @km/code/v0.2/19702 cursor-above-composer signature.
+*
+* Fix: mark EXACTLY the prior caret's row dirty in the presentation buffer the
+* caller will diff+store, so `diffBuffers` re-scans it and emits the cleared
+* cell. We never call `markAllRowsDirty` (that would re-diff every static
+* transcript row each frame — the incremental-perf regression the dirty-row gate
+* exists to prevent). We touch one row, only when the caret actually left it.
+*
+* Buffer ownership: when the current frame composited NO caret (or composited
+* one on a DIFFERENT buffer), `presentationBuffer` may be the caller's untouched
+* source buffer (the documented `composeManagedCaret` no-clone contract). To
+* honour "the source buffer stays untouched", we clone before marking in that
+* case and return the clone. When the PAINT path already cloned, we mutate that
+* clone in place (it is already the caller's diff baseline).
+*/
+function clearPriorCaretOverlay(presentationBuffer, sourceBuffer, currentCaret, prevCaret) {
+	if (prevCaret === null) return presentationBuffer;
+	if (sameCaretCell(prevCaret, currentCaret)) return presentationBuffer;
+	if (prevCaret.y < 0 || prevCaret.y >= presentationBuffer.height) return presentationBuffer;
+	if (presentationBuffer.isRowDirty(prevCaret.y)) return presentationBuffer;
+	const buf = presentationBuffer === sourceBuffer ? presentationBuffer.clone() : presentationBuffer;
+	buf.markRowDirty(prevCaret.y);
+	return buf;
+}
+/**
+* STRICT (tier 2, slug `cursor`) — managed-caret overlay-residue invariant.
+*
+* After a frame whose composited caret left cell C (suppressed or moved), C's
+* row in the presentation buffer the caller diffs MUST be dirty — otherwise
+* `diffBuffers` skips it and the prior `inverse` overlay strands (the
+* @km/code/v0.2/19702 signature). This is the overlay-layer analogue of
+* `strict-residue.ts` (which runs BELOW the caret overlay, in the render phase,
+* and so cannot see this). Fires only under `SILVERY_STRICT=cursor` / tier ≥ 2.
+*/
+function verifyNoCaretOverlayResidue(presentationBuffer, currentCaret, prevCaret) {
+	if (!isStrictEnabled("cursor", 2)) return;
+	if (prevCaret === null) return;
+	if (sameCaretCell(prevCaret, currentCaret)) return;
+	if (prevCaret.y < 0 || prevCaret.y >= presentationBuffer.height) return;
+	if (presentationBuffer.isRowDirty(prevCaret.y)) return;
+	throw new IncrementalRenderMismatchError(`STRICT caret-overlay residue: prior composited caret at (${prevCaret.x},${prevCaret.y}) left the row, but row ${prevCaret.y} is CLEAN in the presentation buffer.\n  diffBuffers skips clean rows, so the prior frame's reverse-video (inverse)\n  overlay cell at (${prevCaret.x},${prevCaret.y}) will NOT be cleared — it strands\n  on screen with no ?25h/CUP. This is the @km/code/v0.2/19702\n  cursor-above-composer mechanism.\n  current caret: ${currentCaret ? `(${currentCaret.x},${currentCaret.y})` : "none (suppressed)"}\n  Fix: clearPriorCaretOverlay must mark the prior caret's row dirty.\n  Slug: SILVERY_STRICT=${CARET_OVERLAY_STRICT_SLUG} (tier 2+).`);
+}
+/**
+* STRICT (tier 2, slug `cursor`) — no-fallback park invariant.
+*
+* When an editable declares a `parkOffset` (resolved to `parkRect`) and no
+* visible caret owns the frame, the managed hardware cursor MUST park on that
+* declared cell — never `home(0,0)` or a box-origin fallback. This pins that the
+* @km/code/v0.2/19702 fix stays wired: a regression that re-introduces a
+* fallback overriding the declared park target throws HERE instead of silently
+* stranding the cursor above the prompt (the recurring #undead signature, where
+* a dropped `?25l` surfaces the mis-parked cursor). The undeclared-editable case
+* (an editable that declares NO park) has no generic runtime signal — it is
+* pinned by the composer park-target contract + the parkOffset mutation test.
+* Fires only under `SILVERY_STRICT=cursor` / tier ≥ 2.
+*
+* Exported for direct mutation-proof unit testing (the fault path can't arise
+* from the correct `managedCursorSuffix`, so the test simulates a fallback park).
+*/
+function verifyParkHonorsDeclaredTarget(cursor, parkRect, parkTarget) {
+	if (!isStrictEnabled("cursor", 2)) return;
+	if (cursor !== null || parkRect === null) return;
+	if (parkTarget !== null && parkTarget.x === parkRect.x && parkTarget.y === parkRect.y) return;
+	throw new IncrementalRenderMismatchError(`STRICT no-fallback park: parkOffset declared at (${parkRect.x},${parkRect.y}) and no caret owns the frame, but the hardware cursor parked at ${parkTarget ? `(${parkTarget.x},${parkTarget.y})` : "none"} instead.\n  A managed frame MUST park on the editable's declared input cell — never a\n  box-origin / home(0,0) fallback. A dropped ?25l would then strand the cursor off\n  the prompt — the @km/code/v0.2/19702 cursor-above-composer mechanism.\n  Fix: managedCursorSuffix must honor findActiveParkRect's result.\n  Slug: SILVERY_STRICT=${CARET_OVERLAY_STRICT_SLUG} (tier 2+).`);
+}
+function cursorOwnerBounds(activeNode, cursor) {
+	return {
+		promptBounds: cursor ? {
+			x: cursor.x,
+			y: cursor.y,
+			width: 1,
+			height: 1
+		} : null,
+		composerBounds: activeNode ? computeContentRect(activeNode) : null
+	};
+}
+/**
+* Compute the trailing cursor-control bytes for a managed fullscreen frame.
+*
+* The visible caret is painted into the presentation buffer by
+* `composeManagedCaret`, so the hardware cursor's only job is to stay OUT of
+* the way: every managed frame moves it to a deterministic safe cell and hides
+* it. Parking-before-hide is load-bearing because a multiplexer/terminal can
+* drop or override `?25l` (cmux re-shows the focused pane's cursor; an
+* unfocused pane renders a hollow cursor). If we hide WITHOUT moving, the
+* hardware cursor stays wherever the diff's last content write landed — the
+* bottom-most painted row — and a dropped hide leaves a visible cursor
+* stranded in transcript/activity/chrome content (the recurring
+* @km/code/v0.2/19702 signature, e.g. a block on the `Codex Done …` status
+* row). Parking pins that worst case to a benign, predictable cell instead.
+*
+* Park priority:
+*   1. The active caret cell — when a caret exists, the hardware cursor and the
+*      composited caret coincide, so a dropped hide just overlaps the caret.
+*   2. The editable's DECLARED input-cell park target (`parkOffset`, resolved by
+*      `findActiveParkRect`) — present even when the editable is unfocused/idle,
+*      so a dropped hide surfaces the cursor ON the prompt input cell.
+*   3. Home (0,0) — last resort, ONLY for a frame with no editable/park declarer
+*      at all (no input locus to be "above"). Never a dynamic transcript/chrome
+*      row.
+*
+* The earlier composer-ORIGIN fallback (the editable's box top/border row — one
+* cell ABOVE the `>` prompt) is DELETED: it was the @km/code/v0.2/19702
+* bug-masking fallback (a multiplexer dropping `?25l` surfaced the parked cursor
+* one row above the prompt). Per Fail-Loud / no-defensive-fallbacks, a present
+* editable now declares its input cell via `parkOffset` instead of relying on a
+* silent box-origin degrade.
+*/
+function managedCursorSuffix(cursor, parkRect, opts) {
+	const park = cursor !== null ? {
+		x: cursor.x,
+		y: cursor.y
+	} : parkRect !== null ? {
+		x: parkRect.x,
+		y: parkRect.y
+	} : {
+		x: 0,
+		y: 0
+	};
+	const tail = opts?.visible === true ? ANSI.CURSOR_SHOW : ANSI.CURSOR_HIDE;
+	return {
+		suffix: ANSI.moveCursor(park.x, park.y) + tail,
+		parkTarget: park
+	};
+}
+/**
+* Transport-safe managed cursor delivery.
+*
+* The semantic suffix is still "park then hide" (`managedCursorSuffix` above).
+* Output paths append this idempotent SGR reset after it so the managed cursor
+* controls are not the literal trailing run of cursor-control bytes. That keeps
+* multiplexers that drop a trailing cursor-control tail from peeling the park
+* move away from the content frame that required it.
+*/
+function protectManagedCursorSuffix(cursorSuffix) {
+	return cursorSuffix.length === 0 ? "" : cursorSuffix + ANSI.RESET;
+}
+function computeManagedFrame(sourceBuffer, root, mode, opts) {
+	if (mode !== "fullscreen") return {
+		presentationBuffer: sourceBuffer,
+		cursorSuffix: "",
+		compositorCaret: null,
+		cursorTarget: null,
+		expectedTerminal: null,
+		promptBounds: null,
+		composerBounds: null
+	};
+	const active = findActiveCursorRectWithProvenance(root);
+	const treeCursor = active?.rect ?? null;
+	const legacyCursor = treeCursor ? null : opts?.legacyCursor ?? null;
+	const cursor = treeCursor ?? legacyCursor;
+	const bounds = cursorOwnerBounds(findActiveCursorNode(root), cursor);
+	const suppressDeclarativeFallback = active?.provenance === "declarative-fallback";
+	const windowFocused = opts?.windowFocused ?? true;
+	const islandHardwareCursor = active?.provenance === "island" && windowFocused && treeCursor?.visible === true;
+	const managed = composeManagedCaret(sourceBuffer, legacyCursor !== null ? legacyCursor : islandHardwareCursor || suppressDeclarativeFallback ? null : treeCursor, windowFocused);
+	const prevCaret = opts?.prevCaret ?? null;
+	const presentationBuffer = clearPriorCaretOverlay(managed.buffer, sourceBuffer, managed.compositorCaret, prevCaret);
+	verifyNoCaretOverlayResidue(presentationBuffer, managed.compositorCaret, prevCaret);
+	const parkRect = findActiveParkRect(root);
+	const managedCursor = managedCursorSuffix(cursor, parkRect, { visible: islandHardwareCursor });
+	verifyParkHonorsDeclaredTarget(cursor, parkRect, managedCursor.parkTarget);
+	let cursorTarget = null;
+	let expectedTerminal = null;
+	if (cursor) {
+		cursorTarget = {
+			x: cursor.x,
+			y: cursor.y,
+			visible: cursor.visible,
+			shape: cursor.shape
+		};
+		expectedTerminal = {
+			...cursorTarget,
+			visible: islandHardwareCursor
+		};
+	} else if (managedCursor.parkTarget) expectedTerminal = {
+		...managedCursor.parkTarget,
+		visible: false
+	};
+	return {
+		presentationBuffer,
+		cursorSuffix: managedCursor.suffix,
+		compositorCaret: managed.compositorCaret,
+		cursorTarget,
+		expectedTerminal,
+		promptBounds: bounds.promptBounds,
+		composerBounds: bounds.composerBounds
+	};
+}
+//#endregion
+//#region packages/ag-term/src/runtime/render-trace.ts
+/**
+* render-trace.ts — Render-boundary instrumentation for the Visual Eyes epic.
+*
+* Phase 4 of the Visual Eyes epic. Each silvery render-pass becomes an
+* observable `RENDER_DISPATCHED` event annotated with WHY it rendered:
+*
+*   { ts, reason, dirtyRegions, signalDelta, fiberHash }
+*
+* A frame-trace consumer (e.g. termless's `createFrameTracer`) joins these
+* events onto its numbered frames by timestamp, so a trace frame's metadata
+* answers "what made this render happen" instead of just "the buffer changed".
+*
+* ## Design — additive instrumentation only
+*
+* This module emits an event AFTER the existing reconciler-flush + render
+* pipeline boundary in `renderer.ts`'s `doRender()`. It changes NO rendering
+* behavior, NO dirty-flag logic, NO pipeline ordering. It only reads state
+* the renderer already computed and writes it to an opt-in sink.
+*
+* ## Zero-cost when disabled
+*
+* The whole module is gated by the `SILVERY_TRACE_FRAMES` env var. When
+* unset, `isRenderTraceEnabled()` is `false`, `emitRenderDispatched()`
+* returns immediately, and the renderer's call site is a single boolean
+* check — production rendering pays nothing.
+*
+* ## Channel choice — sidecar JSONL + in-process bus
+*
+* `SILVERY_TRACE_FRAMES` names a directory (the same dir a termless
+* frame-trace writes its `index.jsonl` into). silvery appends render
+* events to `<dir>/render-events.jsonl`, one JSON object per line. termless
+* reads + joins on `ts`. This is the simplest robust channel for
+* `bun km view <vault>` — silvery and termless run in one process but are
+* separate packages with no shared module; a filesystem sidecar needs no
+* cross-package wiring and survives process boundaries too. Terminal-output
+* events are written to `<dir>/render-output-events.jsonl` with bytes,
+* changed-cell counts, dirty-row counts, and output-phase reason.
+*
+* A process-global in-memory ring buffer (`globalThis.__silvery_render_events`)
+* is also maintained so a same-process consumer can read events without
+* touching the filesystem.
+*/
+const renderLog = createLogger("silvery:render");
+const outputLog = createLogger("silvery:render:output");
+let sidecarFile = null;
+let sidecarReady = false;
+let outputSidecarFile = null;
+let outputSidecarReady = false;
+/** The configured trace directory, or `null` when `SILVERY_TRACE_FRAMES` is unset. */
+function renderTraceDir() {
+	return process.env.SILVERY_TRACE_FRAMES?.trim() || null;
+}
+/** True when sidecar or loggily render tracing is active. */
+function isRenderTraceEnabled() {
+	return renderTraceDir() !== null || renderLog.debug !== void 0 || outputLog.debug !== void 0;
+}
+const MAX_BUFFERED_EVENTS = 4096;
+function bus() {
+	const g = globalThis;
+	if (!g.__silvery_render_events) g.__silvery_render_events = {
+		events: [],
+		outputEvents: []
+	};
+	else if (!g.__silvery_render_events.outputEvents) g.__silvery_render_events.outputEvents = [];
+	return g.__silvery_render_events;
+}
+/**
+* Recent render events from the in-process bus. Consumers running in the
+* same process as silvery (e.g. a km-tui-wired termless tracer) can poll
+* this instead of reading the sidecar file.
+*/
+function recentRenderEvents() {
+	return bus().events;
+}
+/**
+* Recent output-frame events from the in-process bus. Same-process consumers
+* can join these with `recentRenderEvents()` by timestamp and frame order.
+*/
+function recentRenderOutputEvents() {
+	return bus().outputEvents;
+}
+/** Convert the buffer's per-row dirty predicate into contiguous ranges. */
+function dirtyRegionsFromBuffer(height, isRowDirty) {
+	const regions = [];
+	let runStart = -1;
+	for (let y = 0; y < height; y++) if (isRowDirty(y)) {
+		if (runStart === -1) runStart = y;
+	} else if (runStart !== -1) {
+		regions.push({
+			row: runStart,
+			height: y - runStart
+		});
+		runStart = -1;
+	}
+	if (runStart !== -1) regions.push({
+		row: runStart,
+		height: height - runStart
+	});
+	return regions;
+}
+/**
+* Emit a `RENDER_DISPATCHED` event for the just-completed render pass.
+*
+* No-op when `SILVERY_TRACE_FRAMES` is unset. Called from `renderer.ts`'s
+* `doRender()` at the flush boundary — AFTER reconciliation + the render
+* pipeline, just before the buffer is returned. Purely additive: reads
+* already-computed state, writes to the opt-in sink, never throws into the
+* render path.
+*/
+function emitRenderDispatched(input) {
+	const traceDir = renderTraceDir();
+	const logEnabled = renderLog.debug !== void 0;
+	if (traceDir === null && !logEnabled) return;
+	try {
+		const reasonParts = [...input.dirtyReasons];
+		if (input.dimsChanged) reasonParts.push("dims-changed");
+		const event = {
+			type: "RENDER_DISPATCHED",
+			ts: Date.now(),
+			renderCount: input.renderCount,
+			reason: reasonParts.length > 0 ? reasonParts.join(",") : "initial",
+			dirtyRegions: dirtyRegionsFromBuffer(input.bufferHeight, input.isRowDirty),
+			signalDelta: input.signalDelta,
+			fiberHash: `${input.rootNodeCount}:${input.rootDirtyEpoch}`
+		};
+		const b = bus();
+		b.events.push(event);
+		if (b.events.length > MAX_BUFFERED_EVENTS) b.events.splice(0, b.events.length - MAX_BUFFERED_EVENTS);
+		renderLog.debug?.("render dispatched", { ...event });
+		if (traceDir !== null && !sidecarReady) {
+			if (!existsSync(traceDir)) mkdirSync(traceDir, { recursive: true });
+			sidecarFile = join(traceDir, "render-events.jsonl");
+			appendFileSync(sidecarFile, "", { flag: "w" });
+			sidecarReady = true;
+		}
+		if (traceDir !== null && sidecarFile) appendFileSync(sidecarFile, JSON.stringify(event) + "\n");
+	} catch {}
+}
+/**
+* Emit a `RENDER_OUTPUT` event for bytes actually written to the terminal.
+*
+* No-op when `SILVERY_TRACE_FRAMES` is unset. This is intentionally separate
+* from `emitRenderDispatched`: the render pipeline produces dirty regions,
+* while the output phase later decides which cells/bytes were emitted.
+*/
+function emitRenderOutputFrame(input) {
+	const traceDir = renderTraceDir();
+	const logEnabled = renderLog.debug !== void 0 || outputLog.debug !== void 0;
+	if (traceDir === null && !logEnabled) return;
+	try {
+		const event = {
+			type: "RENDER_OUTPUT",
+			ts: Date.now(),
+			renderCount: input.renderCount,
+			outputFrame: input.outputFrame,
+			bytes: input.bytes,
+			diagnostics: input.diagnostics ? { ...input.diagnostics } : {}
+		};
+		const b = bus();
+		b.outputEvents.push(event);
+		if (b.outputEvents.length > MAX_BUFFERED_EVENTS) b.outputEvents.splice(0, b.outputEvents.length - MAX_BUFFERED_EVENTS);
+		outputLog.debug?.("render output", { ...event });
+		if (traceDir !== null && !outputSidecarReady) {
+			if (!existsSync(traceDir)) mkdirSync(traceDir, { recursive: true });
+			outputSidecarFile = join(traceDir, "render-output-events.jsonl");
+			appendFileSync(outputSidecarFile, "", { flag: "w" });
+			outputSidecarReady = true;
+		}
+		if (traceDir !== null && outputSidecarFile) appendFileSync(outputSidecarFile, JSON.stringify(event) + "\n");
+	} catch {}
+}
+//#endregion
+//#region packages/ag-term/src/scheduler.ts
+/**
+* Silvery Render Scheduler
+*
+* Batches rapid state updates to prevent flicker and improve performance.
+* Uses queueMicrotask for coalescing multiple synchronous state changes
+* into a single render pass.
+*
+* Features:
+* - Microtask-based batching (coalesces synchronous updates)
+* - Frame batching to prevent flicker
+* - Resize handling with debounce
+* - Clean shutdown
+*/
+const log$1 = createLogger("silvery:scheduler");
+/**
+* Whether synchronized update mode (DEC 2026) is enabled.
+*
+* Disabled by default due to a Ghostty rendering bug where incremental
+* cursor-positioned updates inside a sync region cause progressive visual
+* corruption. Works correctly in Kitty. Full renders (bufferToAnsi) work
+* fine with sync — only incremental diff output (changesToAnsi) triggers it.
+*
+* Set SILVERY_SYNC_UPDATE=1 to force-enable (e.g., for testing in Kitty).
+* TODO: Re-enable by default once the Ghostty bug is fixed.
+* See: https://github.com/ghostty-org/ghostty/discussions/11002
+*/
+const SYNC_UPDATE_ENABLED = process.env.SILVERY_SYNC_UPDATE === "1" || process.env.SILVERY_SYNC_UPDATE === "true";
+/**
+* Schedules and batches render operations.
+*
+* Usage:
+* ```ts
+* const scheduler = new RenderScheduler({
+*   stdout: process.stdout,
+*   root: rootNode,
+* });
+*
+* // Schedule renders (automatically batched)
+* scheduler.scheduleRender();
+* scheduler.scheduleRender(); // This won't cause duplicate render
+*
+* // Force immediate render
+* scheduler.forceRender();
+*
+* // Clean shutdown
+* scheduler.dispose();
+* ```
+*/
+var RenderScheduler = class {
+	stdout;
+	size;
+	root;
+	debugMode;
+	minFrameTime;
+	slowFrameThreshold;
+	mode;
+	pipelineConfig;
+	getCursorState;
+	/**
+	* Read the terminal WINDOW focus state (@km/code/v0.2/19702). Threaded into
+	* `computeManagedFrame` each frame: focused → filled block, unfocused → NO
+	* caret (hidden). Defaults to `() => true` (the fail-safe focused default)
+	* when no reader is supplied.
+	*/
+	getWindowFocused;
+	nonTTYMode;
+	outputTransformer;
+	writeOutput;
+	/**
+	* Render-output throughput monitor — backs `SILVERY_STRICT=bytes_out`.
+	* Constructed lazily, only when the slug is active, so the no-op path
+	* has zero overhead. See `bytes-out-monitor.ts` +
+	* `docs/lessons/cmux-pty-buffer-firehose.md`.
+	*/
+	bytesOutMonitor = null;
+	/**
+	* Repaint-storm monitor — backs `SILVERY_STRICT=flicker`. Sibling of
+	* `bytesOutMonitor`; scans the SAME terminal-output bytes for destructive
+	* full-screen clears / scroll-region resets and PANICs when they repeat fast
+	* enough to constitute flicker (the `@ag/code/20297-pane-flicker-on-resize`
+	* class). Lazily constructed only when the slug is active. See
+	* `flicker-monitor.ts`.
+	*/
+	flickerMonitor = null;
+	/**
+	* In-process heap-poll monitor — backs `SILVERY_STRICT=mem`. Sibling of
+	* `bytesOutMonitor`; samples `process.memoryUsage()` on its own 30s
+	* interval. See `mem-monitor.ts`.
+	*/
+	memMonitor = null;
+	log;
+	/** Previous buffer for diffing */
+	prevBuffer = null;
+	/**
+	* Previous presentation buffer for terminal output diffing, bundled with the
+	* composited caret painted into it.
+	*
+	* The caret is threaded back into `computeManagedFrame` so a caret that moves
+	* off / is suppressed on a static row gets that row marked dirty and the stale
+	* `inverse` overlay cleared — the @km/code/v0.2/19702 overlay-residue fix.
+	* Buffer and caret live in one struct so they cannot desync: every write sets
+	* both in a single assignment, so the buffer baseline can never advance
+	* without the caret it was composited with (see `PrevPresentation`).
+	*/
+	prevPresentation = null;
+	/**
+	* Cross-frame post-state carrier (outline snapshots, etc.).
+	*
+	* Held at the scheduler level — not on `Ag` — because each `doRender()`
+	* creates a fresh `Ag` per frame, so an Ag-internal `_postState` would be
+	* empty every time and `clearPreviousOutlines` would never find prior
+	* snapshots to restore. Mirrors the `prevBuffer` lifecycle: invalidated
+	* together on resize / pause / clear so the snapshot coordinates always
+	* match the buffer they reference.
+	*/
+	postState = createRenderPostState();
+	/** Line count of previous render (for non-TTY modes) */
+	prevLineCount = 0;
+	/** Monotonic terminal-output frame counter for render traces. */
+	outputFrameCount = 0;
+	/** Cached trace gate so disabled output frames do not read env per render. */
+	renderTraceEnabled = false;
+	/** Accumulated output for static mode */
+	staticOutput = "";
+	/** Is a render currently scheduled? */
+	renderScheduled = false;
+	/** Last render timestamp */
+	lastRenderTime = 0;
+	/** Pending frame timeout (for frame rate limiting) */
+	frameTimeout = null;
+	/** Resize listener cleanup */
+	resizeCleanup = null;
+	/**
+	* Cursor-state listener cleanup.
+	*
+	* The scheduler subscribes to cursor-state changes so a re-render is
+	* triggered whenever `useCursor` (mounts / unmounts / moves) changes the
+	* store. Without this subscription, `setCursorState` calls that happen
+	* AFTER a render completes (e.g. on the second commit of a parent Box,
+	* when `NodeContext` finally propagates a non-null AgNode) leave the
+	* scheduler holding a stale (`null`) cursor state — the previous
+	* render emitted `CURSOR_HIDE` and no further render is triggered to
+	* emit `moveCursor + CURSOR_SHOW`. Result: the hardware cursor stays
+	* parked at the prior frame's last buffer write. See bead
+	* `km-silvercode.cursor-startup-position`.
+	*/
+	cursorCleanup = null;
+	/** Render statistics */
+	stats = {
+		renderCount: 0,
+		skippedCount: 0,
+		lastRenderTime: 0,
+		avgRenderTime: 0
+	};
+	/** Is the scheduler disposed? */
+	disposed = false;
+	/** Is the scheduler paused? When paused, renders are deferred until resume. */
+	paused = false;
+	/** Was a render requested while paused? */
+	pendingWhilePaused = false;
+	/**
+	* Lines written to stdout between renders (inline mode only).
+	* When useScrollback or other code writes to stdout, those lines
+	* displace the terminal cursor. This offset is consumed on the next render.
+	*/
+	scrollbackOffset = 0;
+	constructor(options) {
+		this.stdout = options.stdout;
+		this.size = options.size;
+		this.root = options.root;
+		this.debugMode = options.debug ?? false;
+		this.minFrameTime = options.minFrameTime ?? 16;
+		this.slowFrameThreshold = options.slowFrameThreshold ?? 50;
+		this.mode = options.mode ?? "fullscreen";
+		this.pipelineConfig = options.pipelineConfig;
+		this.getCursorState = options.cursorAccessors?.getCursorState ?? (() => null);
+		this.getWindowFocused = options.windowFocused ?? (() => true);
+		if (options.cursorAccessors) this.cursorCleanup = options.cursorAccessors.subscribeCursor(() => {
+			this.scheduleRender();
+		});
+		this.writeOutput = options.writeOutput ?? ((data) => options.stdout.write(data));
+		if (isStrictEnabled("bytes_out", 1)) this.bytesOutMonitor = createBytesOutMonitor();
+		if (isStrictEnabled("flicker", 1)) this.flickerMonitor = createFlickerMonitor();
+		if (isStrictEnabled("mem", 1)) this.memMonitor = createMemMonitor();
+		this.renderTraceEnabled = isRenderTraceEnabled();
+		this.log = createLogger("silvery:scheduler");
+		this.nonTTYMode = resolveNonTTYMode({
+			mode: options.nonTTYMode,
+			stdout: this.stdout
+		});
+		this.outputTransformer = createOutputTransformer(this.nonTTYMode);
+		log$1.debug?.(`non-TTY mode resolved to: ${this.nonTTYMode}`);
+		if (this.nonTTYMode === "tty") this.setupResizeListener();
+	}
+	/**
+	* Get the resolved non-TTY mode.
+	*/
+	getNonTTYMode() {
+		return this.nonTTYMode;
+	}
+	/**
+	* Schedule a render on the next microtask.
+	*
+	* Multiple calls within the same synchronous execution will be
+	* coalesced into a single render.
+	*/
+	scheduleRender() {
+		if (this.disposed) return;
+		if (this.paused) {
+			this.pendingWhilePaused = true;
+			return;
+		}
+		if (this.renderScheduled) {
+			this.stats.skippedCount++;
+			log$1.debug?.(`render skipped (batched), total: ${this.stats.skippedCount}`);
+			return;
+		}
+		this.renderScheduled = true;
+		log$1.debug?.("render scheduled");
+		queueMicrotask(() => {
+			this.renderScheduled = false;
+			if (this.disposed) return;
+			const timeSinceLastRender = Date.now() - this.lastRenderTime;
+			if (timeSinceLastRender < this.minFrameTime) {
+				log$1.debug?.(`frame limited, delay: ${this.minFrameTime - timeSinceLastRender}ms`);
+				this.scheduleNextFrame(this.minFrameTime - timeSinceLastRender);
+			} else this.doRender();
+		});
+	}
+	/**
+	* Force an immediate render, bypassing batching.
+	*/
+	forceRender() {
+		if (this.disposed) return;
+		if (this.paused) {
+			this.pendingWhilePaused = true;
+			return;
+		}
+		this.renderScheduled = false;
+		if (this.frameTimeout) {
+			clearTimeout(this.frameTimeout);
+			this.frameTimeout = null;
+		}
+		this.doRender();
+	}
+	/**
+	* Get render statistics.
+	*/
+	getStats() {
+		return { ...this.stats };
+	}
+	/**
+	* Report lines written to stdout between renders (inline mode only).
+	* This adjusts cursor position tracking so the next render accounts
+	* for the extra lines. Used by useScrollback to notify the scheduler
+	* when it writes frozen items to stdout.
+	*/
+	addScrollbackLines(lines) {
+		if (this.mode !== "inline" || lines <= 0) return;
+		this.scrollbackOffset += lines;
+	}
+	/**
+	* Copy text to the system clipboard via OSC 52.
+	* Works across SSH sessions in terminals that support it.
+	*/
+	copyToClipboard(text) {
+		if (this.disposed) return;
+		createOsc52Backend({ write: (data) => this.writeOutput(data) }).write({ text });
+	}
+	/**
+	* Pause rendering. While paused, scheduled and forced renders are deferred.
+	* Input handling continues normally. Call resume() to unpause and force a
+	* full redraw. Used for screen-switching (alt screen ↔ normal screen).
+	*/
+	pause() {
+		if (this.disposed || this.paused) return;
+		this.paused = true;
+		this.pendingWhilePaused = false;
+		log$1.debug?.("scheduler paused");
+	}
+	/**
+	* Resume rendering after pause. Resets the previous buffer so the next
+	* render outputs everything (full redraw), then forces an immediate render.
+	*/
+	resume() {
+		if (this.disposed || !this.paused) return;
+		this.paused = false;
+		log$1.debug?.("scheduler resumed");
+		this.prevBuffer = null;
+		this.prevPresentation = null;
+		this.postState = createRenderPostState();
+		if (this.pendingWhilePaused) {
+			this.pendingWhilePaused = false;
+			this.doRender();
+		}
+	}
+	/**
+	* Whether the scheduler is currently paused.
+	*/
+	isPaused() {
+		return this.paused;
+	}
+	/**
+	* Clear the terminal and reset buffer.
+	*/
+	clear() {
+		if (this.disposed) return;
+		this.writeOutput("\x1B[2J\x1B[H\x1B[?25l");
+		this.prevBuffer = null;
+		this.prevPresentation = null;
+		this.postState = createRenderPostState();
+	}
+	/**
+	* Dispose the scheduler and clean up resources.
+	*/
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	dispose() {
+		if (this.disposed) return;
+		log$1.debug?.(`dispose: renders=${this.stats.renderCount}, skipped=${this.stats.skippedCount}, avg=${Math.round(this.stats.avgRenderTime)}ms`);
+		this.disposed = true;
+		this.renderScheduled = false;
+		if (this.frameTimeout) {
+			clearTimeout(this.frameTimeout);
+			this.frameTimeout = null;
+		}
+		if (this.resizeCleanup) {
+			this.resizeCleanup();
+			this.resizeCleanup = null;
+		}
+		if (this.cursorCleanup) {
+			this.cursorCleanup();
+			this.cursorCleanup = null;
+		}
+		if (this.bytesOutMonitor) {
+			this.bytesOutMonitor.dispose();
+			this.bytesOutMonitor = null;
+		}
+		if (this.flickerMonitor) {
+			this.flickerMonitor.dispose();
+			this.flickerMonitor = null;
+		}
+		if (this.memMonitor) {
+			this.memMonitor.dispose();
+			this.memMonitor = null;
+		}
+		if (this.nonTTYMode === "static" && this.staticOutput) {
+			this.writeOutput(this.staticOutput);
+			this.writeOutput("\n");
+		}
+	}
+	/**
+	* Get the last rendered output (for static mode).
+	* Returns the plain text output that would be written on dispose.
+	*/
+	getStaticOutput() {
+		return this.staticOutput;
+	}
+	/**
+	* Schedule render for next frame (frame rate limiting).
+	*/
+	scheduleNextFrame(delay) {
+		if (this.frameTimeout) return;
+		this.frameTimeout = setTimeout(() => {
+			this.frameTimeout = null;
+			if (!this.disposed) this.doRender();
+		}, delay);
+	}
+	/**
+	* Resolve the active cursor for this frame.
+	*
+	* Priority:
+	*   1. Layout-output cursor (BoxProps.cursorOffset → LayoutSignals.cursorRect).
+	*      Set synchronously by the layout phase, so available on the very first
+	*      frame after mount — no React-effect-chain stale read.
+	*   2. Cursor store (legacy useCursor() / Ink-compat setCursorPosition()).
+	*      Falls back here when no node declares a layout-output cursor.
+	*
+	* Returns null when no active cursor in either path.
+	*
+	* The shape is identical between paths so callers (cursor suffix emission,
+	* inline-mode pipeline cursor) treat them uniformly.
+	*/
+	resolveActiveCursor() {
+		const layoutCursor = findActiveCursorRect(this.root);
+		if (layoutCursor) return layoutCursor;
+		return this.getStoreCursor();
+	}
+	/**
+	* The legacy/store cursor (useCursor() / Ink-compat setCursorPosition()),
+	* projected into CursorRect shape, or null. This is the cursor source that
+	* has NO owning AgNode — `computeManagedFrame` composites it unconditionally
+	* (it is an explicit imperative request, not a focus-gated declarative
+	* fallback). Layout-output cursors are resolved by `findActiveCursorRect`
+	* inside `computeManagedFrame`, so this helper intentionally does NOT consult
+	* the tree.
+	*/
+	getStoreCursor() {
+		const storeCursor = this.getCursorState();
+		if (!storeCursor) return null;
+		return {
+			x: storeCursor.x,
+			y: storeCursor.y,
+			visible: storeCursor.visible !== false,
+			shape: storeCursor.shape
+		};
+	}
+	/**
+	* Execute the actual render.
+	*/
+	doRender() {
+		using render = this.log.span?.("render");
+		const startTime = Date.now();
+		try {
+			const width = this.size?.cols() ?? this.stdout.columns ?? 80;
+			const height = this.mode === "inline" ? NaN : this.size?.rows() ?? this.stdout.rows ?? 24;
+			log$1.debug?.(`render #${this.stats.renderCount + 1}: ${width}x${height}, nonTTYMode=${this.nonTTYMode}`);
+			const scrollbackOffset = this.scrollbackOffset;
+			this.scrollbackOffset = 0;
+			const measurer = this.pipelineConfig?.measurer;
+			let inlineCursor;
+			const doRender = () => {
+				const ag = createAg(this.root, { measurer });
+				ag.layout({
+					cols: width,
+					rows: height
+				});
+				if (this.mode === "inline") inlineCursor = this.resolveActiveCursor();
+				const { buffer, overlay } = ag.render({
+					prevBuffer: this.prevBuffer,
+					postState: this.postState
+				});
+				const managed = computeManagedFrame(buffer, this.root, this.mode, {
+					legacyCursor: this.mode === "fullscreen" ? this.getStoreCursor() : null,
+					prevCaret: this.prevPresentation?.caret ?? null,
+					windowFocused: this.getWindowFocused()
+				});
+				const fullscreenCursor = managed.cursorTarget;
+				const outputBuffer = managed.presentationBuffer;
+				const start = performance.now();
+				const outputFn = this.pipelineConfig?.outputPhaseFn ?? outputPhase;
+				let ansiOutput;
+				try {
+					clearLastOutputPhaseDiagnostics();
+					ansiOutput = outputFn(this.prevPresentation?.buffer ?? null, outputBuffer, this.mode, scrollbackOffset, this.mode === "inline" ? this.size?.rows() ?? this.stdout.rows ?? 24 : void 0, inlineCursor ?? void 0);
+				} catch (e) {
+					if (e instanceof Error) e.__silvery_buffer = buffer;
+					throw e;
+				}
+				if (overlay) ansiOutput += overlay;
+				const tOutput = performance.now() - start;
+				const acc = globalThis.__silvery_bench_phases;
+				if (acc) {
+					acc.output += tOutput;
+					acc.pipelineCalls += 1;
+				}
+				return {
+					output: ansiOutput,
+					buffer,
+					outputBuffer,
+					overlay,
+					cursor: fullscreenCursor,
+					compositorCaret: managed.compositorCaret,
+					managed
+				};
+			};
+			const { output, buffer, outputBuffer, overlay: incrementalOverlay, compositorCaret, managed: managedFrame } = measurer ? runWithMeasurer(measurer, doRender) : doRender();
+			let transformedOutput;
+			if (this.nonTTYMode === "tty") transformedOutput = output;
+			else if (this.nonTTYMode === "static") {
+				this.staticOutput = stripAnsi(output);
+				transformedOutput = "";
+			} else {
+				transformedOutput = this.outputTransformer(output, this.prevLineCount);
+				this.prevLineCount = countLines(output);
+			}
+			let cursorSuffix = "";
+			let cursorTarget = null;
+			let expectedTerminal = null;
+			let promptBounds = null;
+			let composerBounds = null;
+			if (this.nonTTYMode === "tty") {
+				cursorSuffix = managedFrame.cursorSuffix;
+				cursorTarget = managedFrame.cursorTarget;
+				expectedTerminal = managedFrame.expectedTerminal;
+				promptBounds = managedFrame.promptBounds;
+				composerBounds = managedFrame.composerBounds;
+			}
+			const cursorDelivery = protectManagedCursorSuffix(cursorSuffix);
+			if (transformedOutput.length > 0 || cursorDelivery.length > 0) {
+				const cursorDeliveryNeedsSync = this.nonTTYMode === "tty" && cursorSuffix.length > 0 && expectedTerminal !== null && (expectedTerminal.x !== 0 || expectedTerminal.y !== 0);
+				const fullOutput = this.nonTTYMode === "tty" && (SYNC_UPDATE_ENABLED || cursorDeliveryNeedsSync) ? `${ANSI.SYNC_BEGIN}${transformedOutput}${cursorDelivery}${ANSI.SYNC_END}` : transformedOutput + cursorDelivery;
+				if (log$1.debug) {
+					const bytes = Buffer.byteLength(fullOutput);
+					log$1.debug?.(`stdout.write: ${bytes} bytes (${transformedOutput.length} chars output + ${cursorSuffix.length} chars cursor)`);
+					if (bytes > 16384) log$1.debug?.(`large output: ${bytes} bytes may exceed pipe buffer (16KB on macOS), risk of mid-sequence split`);
+				}
+				const captureFile = process.env.SILVERY_CAPTURE_OUTPUT;
+				if (captureFile) {
+					const fs = process.getBuiltinModule("node:fs");
+					fs.appendFileSync(captureFile, `--- FRAME ${this.stats.renderCount + 1} (${Buffer.byteLength(fullOutput)} bytes) ---\n`);
+					fs.appendFileSync(captureFile, fullOutput);
+					fs.appendFileSync(captureFile, "\n");
+				}
+				recordOutputCursorDiagnostics({
+					reason: "scheduler-render",
+					mode: "fullscreen",
+					width,
+					height,
+					output: fullOutput,
+					target: cursorTarget,
+					expectedTerminal,
+					compositorCaret,
+					promptBounds,
+					composerBounds
+				});
+				this.writeOutput(fullOutput);
+				if (this.flickerMonitor) {
+					const renderNumber = this.stats.renderCount + 1;
+					this.flickerMonitor.recordFrame(renderNumber, fullOutput);
+				}
+				const traceOutputEnabled = this.renderTraceEnabled || isRenderTraceEnabled();
+				if (this.bytesOutMonitor || traceOutputEnabled) {
+					const outputDiagnostics = getLastOutputPhaseDiagnostics();
+					const bytes = Buffer.byteLength(fullOutput);
+					const diagnostics = {
+						...outputDiagnostics,
+						outputChars: transformedOutput.length,
+						cursorChars: cursorDelivery.length,
+						syncWrapped: this.nonTTYMode === "tty" && (SYNC_UPDATE_ENABLED || cursorDeliveryNeedsSync)
+					};
+					const renderNumber = this.stats.renderCount + 1;
+					this.bytesOutMonitor?.recordWrite(renderNumber, bytes, diagnostics);
+					if (traceOutputEnabled) {
+						this.outputFrameCount += 1;
+						emitRenderOutputFrame({
+							renderCount: renderNumber,
+							outputFrame: this.outputFrameCount,
+							bytes,
+							diagnostics
+						});
+					}
+				}
+			}
+			this.prevBuffer = buffer;
+			this.prevPresentation = {
+				buffer: outputBuffer,
+				caret: compositorCaret
+			};
+			commitLayoutSnapshot(this.root);
+			const freshLayout = isStrictEnabled(FRESH_LAYOUT_STRICT_SLUG, 2);
+			if ((isStrictEnabled("incremental", 1) || freshLayout) && this.stats.renderCount > 0) {
+				const renderNum = this.stats.renderCount + 1;
+				const doFreshRender = () => {
+					const freshAg = createAg(this.root, { measurer });
+					if (freshLayout) markLayoutTreeDirty(this.root);
+					freshAg.layout({
+						cols: width,
+						rows: height
+					}, {
+						skipLayoutNotifications: true,
+						forceFullPropagate: freshLayout
+					});
+					return freshAg.render({ fresh: true });
+				};
+				const { buffer: freshBuffer, overlay: freshOverlay } = measurer ? runWithMeasurer(measurer, doFreshRender) : doFreshRender();
+				if (incrementalOverlay !== freshOverlay) {
+					const msg = formatOverlayMismatch(incrementalOverlay, freshOverlay, renderNum);
+					if (process.env.DEBUG_LOG) appendFileSync(process.env.DEBUG_LOG, msg + "\n");
+					log$1.error?.(msg);
+					throw new IncrementalRenderMismatchError(msg);
+				}
+				let found = false;
+				for (let y = 0; y < buffer.height && !found; y++) for (let x = 0; x < buffer.width && !found; x++) {
+					const a = buffer.getCell(x, y);
+					const b = freshBuffer.getCell(x, y);
+					if (!cellEquals(a, b)) {
+						found = true;
+						const ctx = buildMismatchContext(this.root, x, y, a, b, renderNum);
+						const renderPhaseStats = globalThis.__silvery_content_detail ? structuredClone(globalThis.__silvery_content_detail) : void 0;
+						const msg = formatMismatchContext(ctx, renderPhaseStats) + `--- incremental ---\n${bufferToText(buffer)}\n--- fresh ---\n${bufferToText(freshBuffer)}`;
+						if (process.env.DEBUG_LOG) appendFileSync(process.env.DEBUG_LOG, msg + "\n");
+						log$1.error?.(msg);
+						throw new IncrementalRenderMismatchError(msg, {
+							renderPhaseStats,
+							mismatchContext: ctx
+						});
+					}
+				}
+				if (!found && process.env.DEBUG_LOG) appendFileSync(process.env.DEBUG_LOG, `SILVERY_STRICT: render #${renderNum} OK\n`);
+			}
+			const renderTime = Date.now() - startTime;
+			this.stats.renderCount++;
+			this.stats.lastRenderTime = renderTime;
+			this.stats.avgRenderTime = (this.stats.avgRenderTime * (this.stats.renderCount - 1) + renderTime) / this.stats.renderCount;
+			this.lastRenderTime = Date.now();
+			if (render) {
+				render.spanData.renderCount = this.stats.renderCount;
+				render.spanData.renderTime = renderTime;
+				render.spanData.bytes = transformedOutput.length;
+			}
+			log$1.debug?.(`render #${this.stats.renderCount} complete: ${renderTime}ms, output: ${transformedOutput.length} bytes`);
+			const threshold = this.stats.renderCount <= 1 ? this.slowFrameThreshold * 5 : this.slowFrameThreshold;
+			if (threshold > 0 && renderTime > threshold) log$1.debug?.(`slow frame: render #${this.stats.renderCount} took ${renderTime}ms (threshold: ${this.slowFrameThreshold}ms, bytes: ${transformedOutput.length})`);
+			if (this.debugMode) this.logDebug(`Render #${this.stats.renderCount} took ${renderTime}ms`);
+		} catch (error) {
+			log$1.error?.(`render error: ${error}`);
+			this.logError("Render error:", error);
+			throw error;
+		}
+	}
+	/**
+	* Set up terminal resize listener.
+	*/
+	setupResizeListener() {
+		let resizeTimeout = null;
+		const handleResize = () => {
+			if (resizeTimeout) clearTimeout(resizeTimeout);
+			resizeTimeout = setTimeout(() => {
+				resizeTimeout = null;
+				this.prevBuffer = null;
+				this.prevPresentation = null;
+				this.postState = createRenderPostState();
+				this.scheduleRender();
+			}, 50);
+		};
+		this.stdout.on("resize", handleResize);
+		this.resizeCleanup = () => {
+			this.stdout.off("resize", handleResize);
+			if (resizeTimeout) clearTimeout(resizeTimeout);
+		};
+	}
+	/**
+	* Log debug message (via loggily, not stderr — stderr corrupts alt screen).
+	*/
+	logDebug(message) {
+		log$1.debug?.(message);
+	}
+	/**
+	* Log error message (via loggily, not stderr — stderr corrupts alt screen).
+	*/
+	logError(message, error) {
+		if (error instanceof Error) log$1.error?.(`${message} ${error.stack ?? error.message}`);
+		else log$1.error?.(`${message} ${String(error)}`);
+	}
+};
+/**
+* Format a human-readable diff when the incremental and fresh Kitty overlays
+* disagree. The overlays are Kitty graphics protocol escape sequences that
+* place translucent "scrim" images over emoji cells inside faded regions
+* (see `pipeline/backdrop/`). They MUST be byte-identical across fresh and
+* incremental paths — any drift is a determinism bug in:
+*
+* - `collectBackdropMarkers` (tree walk order)
+* - `collectEmojiCellsInFadeRegion` (rect iteration)
+* - `backdropPlacementId` (per-cell ID derivation)
+* - `assertSingleAmount` (amount selection when markers disagree)
+*
+* The diff surfaces the placement IDs that differ — the Kitty protocol uses
+* `p=<id>` in each placement command, so grep-friendly IDs are the
+* quickest path from "test failed" to "which cell drifted".
+*/
+function formatOverlayMismatch(incremental, fresh, renderNum) {
+	const incPlacements = extractPlacementIds(incremental);
+	const freshPlacements = extractPlacementIds(fresh);
+	const incSet = new Set(incPlacements);
+	const freshSet = new Set(freshPlacements);
+	const onlyIncremental = incPlacements.filter((id) => !freshSet.has(id));
+	const onlyFresh = freshPlacements.filter((id) => !incSet.has(id));
+	const lines = [
+		`[SILVERY_STRICT] Kitty overlay mismatch at render #${renderNum}`,
+		`  incremental length: ${incremental.length} bytes, placements: ${incPlacements.length}`,
+		`  fresh       length: ${fresh.length} bytes, placements: ${freshPlacements.length}`
+	];
+	if (onlyIncremental.length > 0) lines.push(`  only in incremental (moved/appeared): ${onlyIncremental.join(", ")}`);
+	if (onlyFresh.length > 0) lines.push(`  only in fresh       (missing/disappeared): ${onlyFresh.join(", ")}`);
+	if (onlyIncremental.length === 0 && onlyFresh.length === 0) lines.push(`  placements match — drift is in scrim-image payload or ordering`);
+	const cap = 400;
+	lines.push(`  incremental[0..${cap}]: ${JSON.stringify(incremental.slice(0, cap))}`, `  fresh      [0..${cap}]: ${JSON.stringify(fresh.slice(0, cap))}`);
+	return lines.join("\n");
+}
+/**
+* Extract the list of `p=<id>` placement IDs from a Kitty overlay string, in
+* emission order. Used by the STRICT diagnostic to show which placements
+* moved/appeared/disappeared.
+*/
+function extractPlacementIds(overlay) {
+	const ids = [];
+	const re = /p=(\d+)/g;
+	let m;
+	while ((m = re.exec(overlay)) !== null) ids.push(m[1]);
+	return ids;
+}
+//#endregion
+//#region packages/create/src/runtime/with-paste-chain.ts
+/**
+* Install the paste router plugin.
+*
+* On `term:paste` ops:
+*   - Call `routeToFocused(text)` first (if provided). If it returns
+*     true, we short-circuit: handled by focus tree, no fallback.
+*   - Otherwise invoke every registered global handler in order.
+*   - Always emit `[{type:"render"}]` when handled, so the runner
+*     knows to paint the post-paste state.
+*/
+function withPasteChain(options = {}) {
+	return (app) => {
+		const handlers = [];
+		const store = {
+			handlers,
+			register(handler) {
+				handlers.push(handler);
+				return () => {
+					const i = handlers.indexOf(handler);
+					if (i >= 0) handlers.splice(i, 1);
+				};
+			},
+			unregister(handler) {
+				for (let i = handlers.length - 1; i >= 0; i--) if (handlers[i] === handler) handlers.splice(i, 1);
+			}
+		};
+		const prev = app.apply;
+		app.apply = (op) => {
+			if (op.type !== "term:paste") return prev(op);
+			const text = op.text ?? "";
+			let consumed = false;
+			if (options.routeToFocused) try {
+				consumed = !!options.routeToFocused(text);
+			} catch (err) {
+				console.error("[withPasteChain] routeToFocused threw", err);
+			}
+			if (!consumed && handlers.length > 0) {
+				for (const handler of handlers) try {
+					handler(text);
+				} catch (err) {
+					console.error("[withPasteChain] handler threw", err);
+				}
+				consumed = true;
+			}
+			if (!consumed) return prev(op);
+			return [{ type: "render" }];
+		};
+		return Object.assign(app, { paste: store });
+	};
+}
+//#endregion
+//#region packages/create/src/runtime/with-input-chain.ts
+function isModifierOnly(_input, key) {
+	return key?.isModifierOnly === true;
+}
+/**
+* Install the fallback useInput store plugin.
+*
+* Pipe order note: place this plugin so it runs AFTER withFocusChain.
+* Because the last plugin in `pipe()` wraps the outermost layer, the
+* chain reads left-to-right with the base on the left:
+*
+*   pipe(create(), withTerminalChain(), withInputChain(), withFocusChain())
+*
+* => apply order: focusChain -> inputChain -> terminalChain -> base
+*
+* => focused components consume before useInput, which is what we want.
+*/
+function withInputChain(app) {
+	const entries = [];
+	const store = {
+		handlers: entries,
+		register(handler, active = true) {
+			const entry = {
+				handler,
+				active
+			};
+			entries.push(entry);
+			return () => {
+				const i = entries.indexOf(entry);
+				if (i >= 0) entries.splice(i, 1);
+			};
+		},
+		setActive(handler, active) {
+			for (const entry of entries) if (entry.handler === handler) entry.active = active;
+		},
+		unregister(handler) {
+			for (let i = entries.length - 1; i >= 0; i--) if (entries[i].handler === handler) entries.splice(i, 1);
+		}
+	};
+	const prev = app.apply;
+	app.apply = (op) => {
+		if (op.type !== "input:key") return prev(op);
+		const input = op.input ?? "";
+		const key = op.key;
+		const isRelease = key?.eventType === "release";
+		const modOnly = isModifierOnly(input, key);
+		if (isRelease || modOnly) return prev(op);
+		let hasActive = false;
+		const effects = [];
+		for (const entry of entries) {
+			if (!entry.active) continue;
+			hasActive = true;
+			try {
+				if (entry.handler(input, key ?? {}) === "exit") {
+					effects.push({ type: "exit" });
+					return effects;
+				}
+			} catch (err) {
+				console.error("[withInputChain] handler threw", err);
+			}
+		}
+		if (hasActive) return effects;
+		return prev(op);
+	};
+	return Object.assign(app, { input: store });
+}
+//#endregion
+//#region packages/create/src/runtime/with-custom-events.ts
+/**
+* Install the custom-events plugin.
+*
+* Exposes the event bus at `app.events`. The plugin is observer-only —
+* it does not touch the op stream; every op passes straight through to
+* downstream plugins.
+*/
+function withCustomEvents(app) {
+	const channels = /* @__PURE__ */ new Map();
+	const store = {
+		on(channel, handler) {
+			let handlers = channels.get(channel);
+			if (!handlers) {
+				handlers = [];
+				channels.set(channel, handlers);
+			}
+			handlers.push(handler);
+			return () => {
+				const list = channels.get(channel);
+				if (!list) return;
+				const i = list.indexOf(handler);
+				if (i >= 0) list.splice(i, 1);
+			};
+		},
+		emit(channel, ...args) {
+			const handlers = channels.get(channel);
+			if (!handlers || handlers.length === 0) return;
+			for (const handler of handlers.slice()) try {
+				handler(...args);
+			} catch (err) {
+				console.error(`[withCustomEvents] handler for "${channel}" threw`, err);
+			}
+		},
+		off(channel, handler) {
+			const handlers = channels.get(channel);
+			if (!handlers) return;
+			for (let i = handlers.length - 1; i >= 0; i--) if (handlers[i] === handler) handlers.splice(i, 1);
+		}
+	};
+	const prev = app.apply;
+	app.apply = (op) => prev(op);
+	return Object.assign(app, { events: store });
+}
+//#endregion
+//#region packages/ag-term/src/runtime/wrap-measurer-registration.ts
+/**
+* Wrap-measurer registration for `@silvery/ag-term`.
+*
+* `@silvery/ag` exposes a process-level wrap-measurer registry
+* (`setWrapMeasurer` / `getWrapMeasurer`) so geometry helpers like
+* `computeSelectionFragments` can ask the active terminal runtime for
+* grapheme-correct soft-wrap slices. Without registration, the geometry
+* layer falls back to `\n`-only line splitting — fine for pure-framework
+* unit tests, wrong for real apps where a 60-char paragraph at width 20
+* needs to emit 3 fragments.
+*
+* **Registration shape (Option B per `hub/silvery/design/overlay-anchor-system.md`
+* § 8)**: terminal-side `wrapTextWithOffsets` adapts to the registry's
+* `wrapText(text, maxWidth) → readonly WrapSlice[]` contract. The slice
+* shape is structurally identical (`text` + `startOffset` + `endOffset`),
+* so the adapter is a passthrough — no allocation, no reformatting.
+*
+* **Lifecycle**: registration happens at module load — see the side-effect
+* call below. The adapter reads the active scoped measurer (terminal caps,
+* wide-emoji heuristics, text-sizing) at call time, so caps changes during
+* a session (e.g., post-DA1 width-detection toggling `maybeWideEmojis`)
+* are picked up automatically.
+*
+* **Test isolation**: tests that need the `\n`-only fallback (pure-`ag`
+* pathway) call `setWrapMeasurer(null)` in `beforeEach`/`afterEach` and
+* `restoreDefaultWrapMeasurer()` in `afterAll`. Tests that exercise the
+* registered path do nothing — the import-time side effect already wired
+* it up.
+*
+* **Multi-Term**: v1 is module-level singleton — see `@silvery/ag/wrap-measurer.ts`
+* file header for the upgrade path. Single Term-per-process is the
+* production reality; multi-Term scenarios are research / future work.
+*
+* Tracking: bead `km-silvery.softwrap-selection-fragments` (closes Phase
+* 4b deferred wrap-spanning).
+*/
+/**
+* The terminal-runtime adapter — a thin passthrough that converts
+* `wrapTextWithOffsets`'s return type to `readonly WrapSlice[]`. The
+* shapes are identical so this is a re-tag, but going through a typed
+* conversion lets us tighten or widen either side without breaking the
+* other.
+*/
+const terminalWrapMeasurer = { wrapText(text, maxWidth) {
+	return wrapTextWithOffsets(text, maxWidth);
+} };
+/**
+* Install the terminal-runtime wrap measurer into `@silvery/ag`'s registry.
+*
+* Reads the live registry (`getWrapMeasurer()`) — not a local boolean — to
+* decide whether to install. This makes the function safe to call after a
+* `setWrapMeasurer(null)` teardown that bypassed `uninstallTerminalWrapMeasurer`
+* (e.g. tests that drop the registration through `@silvery/ag`'s own API).
+*
+* Idempotent: when our adapter is already the registered measurer, this
+* is a no-op. When a foreign measurer is registered (rare — only seen if
+* a test or alternate runtime registered its own), this overwrites it
+* with our adapter, matching v1's "single Term-per-process" assumption.
+*
+* Called automatically at module load (see side-effect below); exported
+* for tests that want to re-arm after a `setWrapMeasurer(null)` teardown.
+*/
+function installTerminalWrapMeasurer() {
+	if (getWrapMeasurer() === terminalWrapMeasurer) return;
+	setWrapMeasurer(terminalWrapMeasurer);
+}
+/**
+* Reset registration when our adapter is the active measurer. After
+* calling this, the `@silvery/ag` registry is empty (`getWrapMeasurer()`
+* returns null) and `computeSelectionFragments` falls back to `\n`-only
+* splitting. Tests use this to exercise the fallback path; runtime
+* teardown uses it on Term dispose.
+*
+* No-op when a foreign measurer is registered — clearing it would surprise
+* whoever installed it. Call `setWrapMeasurer(null)` directly if the goal
+* is to clear unconditionally.
+*/
+function uninstallTerminalWrapMeasurer() {
+	if (getWrapMeasurer() !== terminalWrapMeasurer) return;
+	setWrapMeasurer(null);
+}
+/**
+* Test helper: restore the registry to its post-import-time default
+* state. Equivalent to `installTerminalWrapMeasurer()` but reads more
+* naturally in `afterEach` / `afterAll` blocks.
+*/
+function restoreDefaultWrapMeasurer() {
+	installTerminalWrapMeasurer();
+}
+/**
+* Read whether the terminal measurer is currently the active registration.
+* Sources truth from the live registry so a concurrent test that called
+* `setWrapMeasurer(null)` is observed correctly.
+*/
+function isTerminalWrapMeasurerInstalled() {
+	return getWrapMeasurer() === terminalWrapMeasurer;
+}
+installTerminalWrapMeasurer();
+//#endregion
+//#region packages/ag-react/src/scope-context.ts
+/**
+* ScopeContext — plumbs `Scope` down the React tree.
+*
+* Two contexts intentionally:
+*
+* - `ScopeContext` carries the *current* enclosing scope. Nested
+*   `<ScopeProvider scope={...}>` elements shadow it. `useScope()` reads this.
+*
+* - `AppScopeContext` carries the *root app scope*. It is set exactly once,
+*   at the app root, by `withScope()` (wired into `createApp()` in a later
+*   phase) or by `<ScopeProvider scope={root} appScope={root}>` in tests.
+*   `useAppScope()` reads this so whole-app shutdown paths always reach the
+*   root even from deeply nested components.
+*
+* Separating them matters: nesting a `<ScopeProvider>` must not change what
+* `useAppScope()` returns — only `useScope()`.
+*/
+/** Current enclosing scope. `null` when no provider is above the component. */
+const ScopeContext = createContext(null);
+/** Root app scope. Set once by `withScope()` (or in tests). */
+const AppScopeContext = createContext(null);
+//#endregion
+//#region packages/ag-react/src/ScopeProvider.tsx
+function ScopeProvider({ scope, appScope, children }) {
+	let tree = /* @__PURE__ */ jsx(Fragment, { children });
+	if (scope !== void 0) tree = /* @__PURE__ */ jsx(ScopeContext.Provider, {
+		value: scope,
+		children: tree
+	});
+	if (appScope !== void 0) tree = /* @__PURE__ */ jsx(AppScopeContext.Provider, {
+		value: appScope,
+		children: tree
+	});
+	return tree;
+}
+//#endregion
+//#region packages/ag/src/cls.ts
+/**
+* CLS — Cumulative Layout Shift instrumentation for silvery.
+*
+* Analogous to Core Web Vitals CLS: a layout shift is the same block
+* rendering at a different rect in successive frames during a single
+* user-action window. Score = sum(area × distance) over all shifts.
+*
+* This module is pure: it defines the data shape + diff math. The runtime
+* ClsMonitor (ag-term/runtime/cls-monitor) calls these helpers per render
+* commit; the strict-mode check (ag-term/strict-cls) consumes the CLSReport.
+* The termless capture API (ag-term/app) drives begin/end of the capture
+* window via ClsMonitor.
+*
+* Bead: km-silvery.cls-instrumentation-primitive
+*/
+/**
+* Default reflow-reason classifier — every shift is "unexpected". Tests
+* + close-gates use this to surface every shift; apps with legitimate
+* reflow events (streaming chat, animation) pass a custom classifier.
+*/
+const defaultClassifier = () => "unexpected";
+/**
+* Compute the "impact" of a single shift: max(prev-area, curr-area) ×
+* euclidean-distance-moved between top-left corners. Returns 0 when the
+* rect is unchanged.
+*
+* Area is in cells (cols × rows); distance is in cells. Web CLS uses
+* "impact fraction" relative to viewport — we use raw area × distance
+* because terminal viewports are small and per-block context matters more
+* than viewport-relative weighting. Score is comparable across runs in the
+* same terminal-size + content envelope; not directly comparable across
+* different sizes.
+*/
+function computeShiftScore(from, to) {
+	if (rectEqual(from, to)) return 0;
+	const dx = to.x - from.x;
+	const dy = to.y - from.y;
+	const distance = Math.sqrt(dx * dx + dy * dy);
+	const fromArea = from.width * from.height;
+	const toArea = to.width * to.height;
+	return Math.max(fromArea, toArea) * distance;
+}
+/**
+* Build a LayoutShift record from a rect transition. Returns null when the
+* rects are equal (no shift — caller can skip without branching).
+*/
+function makeShift(blockId, fromRect, toRect, frameTimestamp, reflowReason) {
+	if (rectEqual(fromRect, toRect)) return null;
+	return {
+		blockId,
+		fromRect,
+		toRect,
+		frameTimestamp,
+		reflowReason
+	};
+}
+/**
+* Aggregate a list of shifts into a CLSReport. Pure: callers can stash
+* the shifts array however they like (per-frame, per-capture, per-test)
+* and call this once when building the report.
+*
+* cumulativeScore sums every shift, regardless of reflowReason — the
+* intent is "how much did the layout move?" — not "how much surprise?".
+* For surprise, callers check unexpectedShifts.length or
+* aggregateUnexpectedScore().
+*/
+function aggregateReport(shifts) {
+	let cumulativeScore = 0;
+	const unexpectedShifts = [];
+	for (const s of shifts) {
+		cumulativeScore += computeShiftScore(s.fromRect, s.toRect);
+		if (s.reflowReason === "unexpected") unexpectedShifts.push(s);
+	}
+	return {
+		shifts,
+		cumulativeScore,
+		unexpectedShifts
+	};
+}
+/**
+* Sum of impact scores for the unexpected subset only. Strict-mode checks
+* use this; "all shifts including content-arrival" is too noisy for an
+* assertion threshold.
+*/
+function aggregateUnexpectedScore(shifts) {
+	let score = 0;
+	for (const s of shifts) {
+		if (s.reflowReason !== "unexpected") continue;
+		score += computeShiftScore(s.fromRect, s.toRect);
+	}
+	return score;
+}
+//#endregion
+//#region packages/ag-term/src/strict-cls.ts
+/**
+* STRICT cls — assert no unexpected layout shifts in a CLS capture window.
+*
+* Bead: km-silvery.cls-instrumentation-primitive (Phase 4/7, 2026-05-13).
+*
+* The CLS instrumentation primitive (packages/ag/src/cls.ts) measures
+* layout shifts per frame, classifies each as user-action / animation /
+* content-arrival / unexpected, and aggregates into a CLSReport. Most
+* apps want shifts of the first three reasons to be allowed (they
+* correspond to legitimate reflow events). The "unexpected" reason is
+* the actionable subset — it's the bug class CLS is designed to catch
+* (a code fence resizing mid-stream, a status line bouncing, a card
+* flashing flush-left before snapping to its real position).
+*
+* SILVERY_STRICT=cls flips this from "consumers decide" to "assert that
+* the active capture observed no unexpected shifts." Termless tests can
+* then ship a green close-gate via the umbrella env var rather than
+* hand-rolled assertions in every test.
+*
+* Tier 2 (paranoid). `SILVERY_STRICT=2` includes it; `SILVERY_STRICT=1`
+* does NOT — the default fast pass leaves CLS to consumer-side checks
+* so that pre-existing unfixed shift offenders don't fail every test
+* run before they're fixed.
+*
+* Why ag-term/src/ and not pipeline/strict-cls.ts: this check fires at
+* capture-end (termless `endCLSCapture()`), not per-frame in the pipeline.
+* It has no coupling to render-phase / layout-phase internals — it
+* consumes a CLSReport and decides via the SILVERY_STRICT contract. The
+* placement parallels `strict-bordered-rect.ts` (another pure assertion
+* helper that sits outside `pipeline/`).
+*/
+/** SILVERY_STRICT slug for the CLS check. Tier 2 by design. */
+const CLS_STRICT_SLUG = "cls";
+const CLS_STRICT_MIN_TIER = 2;
+/** Returns true when SILVERY_STRICT=cls (or =2 / =3 / etc.) is enabled. */
+function isClsStrictEnabled() {
+	return isStrictEnabled("cls", 2);
+}
+/**
+* Thrown when SILVERY_STRICT=cls is enabled and a capture window saw at
+* least one shift with reflowReason="unexpected".
+*
+* Carries the offending shifts AND the cumulative unexpected-only score
+* so failing tests can point at the worst offenders without rerunning.
+* `.message` is human-readable; `.shifts` + `.score` are for programmatic
+* inspection.
+*/
+var UnexpectedLayoutShiftError = class extends Error {
+	shifts;
+	score;
+	constructor(shifts, score) {
+		const summary = shifts.slice(0, 5).map((s) => `  ${s.blockId}: (${s.fromRect.x},${s.fromRect.y} ${s.fromRect.width}×${s.fromRect.height}) → (${s.toRect.x},${s.toRect.y} ${s.toRect.width}×${s.toRect.height})`).join("\n");
+		const tail = shifts.length > 5 ? `\n  ... and ${shifts.length - 5} more` : "";
+		super(`[SILVERY_STRICT=cls] CLSReport contains ${shifts.length} unexpected layout shift(s), cumulative score ${score.toFixed(2)}:\n${summary}${tail}`);
+		this.name = "UnexpectedLayoutShiftError";
+		this.shifts = shifts;
+		this.score = score;
+	}
+};
+/**
+* Throws `UnexpectedLayoutShiftError` if the report contains any
+* `reflowReason="unexpected"` shifts AND `SILVERY_STRICT=cls` (or a
+* stricter tier) is enabled. Otherwise a no-op.
+*
+* Callers (termless `endCLSCapture`, test harnesses, app-level
+* close-gate hooks) should invoke this immediately after producing a
+* CLSReport — the error names the offending blocks so the failure
+* message points at the bug.
+*/
+function assertNoUnexpectedShifts(report) {
+	if (!isClsStrictEnabled()) return;
+	if (report.unexpectedShifts.length === 0) return;
+	const score = aggregateUnexpectedScore(report.shifts);
+	throw new UnexpectedLayoutShiftError(report.unexpectedShifts, score);
+}
+//#endregion
+//#region packages/ag-term/src/runtime/cls-monitor.ts
+/**
+* Layout-shift (CLS) monitor — post-commit instrumentation.
+*
+* Detects two classes of layout instability:
+*
+*  1. **Layout shifts** — an AgNode's `screenRect` changes between
+*     consecutive render commits with no scroll/resize cause. Logged as
+*     per-commit counts under `DEBUG=silvery:cls`; quick-reflow storms (the
+*     same path shifting many times in a short window) escalate to a
+*     `warn` summary. Full per-node shift logs live under the narrower
+*     `DEBUG=silvery:cls-detail` namespace so instrumentation does not create
+*     the scroll jank it is meant to diagnose.
+*
+*  2. **Unreasonable sizes** — degenerate or oversized rects detected
+*     during the same walk: `width=0` / `height=0` with visible content
+*     underneath, negative coords, rect exceeding the terminal bounds.
+*     Logged at `warn` regardless of `DEBUG`.
+*
+* Inspired by Web Vitals' Cumulative Layout Shift. The DOM equivalent
+* fires on visible content moving; in terminals the same shape produces
+* the "first centered, then shifts left" symptom the user reported
+* 2026-05-11 12:42 + 13:05.
+*
+* Bead: @km/silvery/layout-shift-instrumentation-cls.
+*
+* ## Activation
+*
+* The walk runs every commit but does nothing when no logger method is
+* armed. Activation:
+*
+*  - `DEBUG=silvery:cls` — summary instrumentation, per-commit shift
+*    counts + storm `warn` logs + size-violation `warn` logs.
+*  - `DEBUG=silvery:cls-detail` — full per-node shift `debug` logs.
+*  - `LOG_LEVEL=warn` only — storm + size-violation `warn` logs (no
+*    per-shift spam). Useful in CI / smoke tests.
+*
+* In both modes, the per-commit walk is O(visible-tree-nodes); the
+* dominant cost is the tree traversal, not the comparison. When
+* disabled, only the `if (!log.debug && !log.warn) return` guard runs.
+*/
+const log = createLogger("silvery:cls");
+const shiftLog = createLogger("silvery:cls-detail");
+/**
+* Opt-in gate. CLS instrumentation runs ONLY when one of these
+* env vars is set:
+*
+*   - `DEBUG=silvery:cls` / `DEBUG=silvery:cls-detail` (or `DEBUG=silvery:*` / `DEBUG=*`)
+*   - `SILVERY_INSTRUMENT=cls`
+*
+* Without the gate, even `warn`-level output stays silent — the
+* instrumentation produces too much noise in synthetic test
+* harnesses (createRenderer fixtures often have transient
+* zero-rect frames during initial measurement) to be safely
+* always-on. Phase 2 of the bead will tier specific checks back
+* to always-on once their false-positive rate is characterised.
+*
+* Bead: @km/silvery/layout-shift-instrumentation-cls.
+*/
+function clsEnabled() {
+	if (process.env.SILVERY_INSTRUMENT === "cls") return true;
+	const debug = process.env.DEBUG ?? "";
+	if (!debug) return false;
+	return /(^|,)\s*(silvery:cls|silvery:cls-detail|silvery:\*|\*)\s*(,|$)/.test(debug);
+}
+const STORM_PATH_WINDOW_MS = 500;
+const STORM_PATH_THRESHOLD = 3;
+const STORM_COMMIT_THRESHOLD = 5;
+/** Data-* attributes treated as identity tokens for CLS path resolution.
+*  Any component carrying one of these in its props is named in the
+*  layout-shift log even without an explicit `id` / `data-testid`. The
+*  list is intentionally broad so anonymous app-level boxes (cards,
+*  chat blocks, code containers, table grids) show up by role instead
+*  of collapsing to a generic "box" entry. */
+const IDENTITY_DATA_KEYS = [
+	"data-view",
+	"data-block",
+	"data-component",
+	"data-card-id",
+	"data-pane",
+	"data-role"
+];
+function createClsMonitor() {
+	const envEnabled = clsEnabled();
+	const pathHistory = /* @__PURE__ */ new Map();
+	let prevCols = 0;
+	let prevRows = 0;
+	let capturing = false;
+	let activeClassifier = defaultClassifier;
+	let sessionShifts = [];
+	function ensureHistory(path) {
+		let h = pathHistory.get(path);
+		if (h === void 0) {
+			h = {
+				ts: [],
+				firedKinds: /* @__PURE__ */ new Set(),
+				lastShiftAt: null,
+				inStorm: false
+			};
+			pathHistory.set(path, h);
+		}
+		return h;
+	}
+	function rectEqual(a, b) {
+		if (a === b) return true;
+		if (a === null || b === null) return false;
+		return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+	}
+	function nodePath(node) {
+		const parts = [];
+		let n = node;
+		let depth = 0;
+		let isLeaf = true;
+		while (n && depth < 20) {
+			const tag = identityTag(n);
+			if (tag !== null) {
+				const typeTag = n.type === "silvery-box" ? "" : `${typeShort(n.type)}`;
+				parts.push(`${typeTag}${tag}`);
+			} else if (isLeaf) parts.push(typeShort(n.type));
+			isLeaf = false;
+			n = n.parent;
+			depth++;
+		}
+		return parts.reverse().join(" > ");
+	}
+	/** Resolve a node's identity tag for CLS paths. Returns null when no
+	*  recognised identity prop is set — the node is then treated as a
+	*  transparent wrapper. */
+	function identityTag(node) {
+		const props = node.props;
+		const id = props.id;
+		if (typeof id === "string" && id.length > 0) return `#${id}`;
+		const testid = props["data-testid"];
+		if (typeof testid === "string" && testid.length > 0) return `#${testid}`;
+		for (const key of IDENTITY_DATA_KEYS) {
+			const v = props[key];
+			if (typeof v === "string" && v.length > 0) return `[${key}=${v}]`;
+		}
+		return null;
+	}
+	function typeShort(type) {
+		return type.startsWith("silvery-") ? type.slice(8) : type;
+	}
+	function recordShift(rec, now) {
+		const h = ensureHistory(rec.path);
+		rec.dtMs = h.lastShiftAt === null ? null : now - h.lastShiftAt;
+		h.lastShiftAt = now;
+		h.ts.push(now);
+		while (h.ts.length > 0 && h.ts[0] < now - STORM_PATH_WINDOW_MS) h.ts.shift();
+		const inStorm = h.ts.length >= STORM_PATH_THRESHOLD;
+		const justEnteredStorm = inStorm && !h.inStorm;
+		h.inStorm = inStorm;
+		return justEnteredStorm;
+	}
+	function fireOnce(path, key) {
+		const h = ensureHistory(path);
+		if (h.firedKinds.has(key)) return false;
+		h.firedKinds.add(key);
+		return true;
+	}
+	function checkSizeInvariants(node, cols, rows) {
+		const rect = node.screenRect;
+		if (!rect) return;
+		if (node.type === "silvery-text") return;
+		const path = nodePath(node);
+		if (rect.x < 0 || rect.y < 0 || rect.width < 0 || rect.height < 0) {
+			if (fireOnce(path, "negative")) log.warn?.("negative-rect", {
+				path,
+				rect
+			});
+		}
+		if (rect.width > cols || rect.height > rows) {
+			if (fireOnce(path, "overflow")) log.warn?.("rect-overflows-terminal", {
+				path,
+				rect,
+				cols,
+				rows
+			});
+		}
+		if ((rect.width === 0 || rect.height === 0) && hasVisibleContent(node)) {
+			if (fireOnce(path, "zero-area-with-content")) log.warn?.("zero-area-with-content", {
+				path,
+				rect
+			});
+		}
+	}
+	function hasVisibleContent(node) {
+		if (node.type === "silvery-text") return true;
+		const props = node.props;
+		if (props.backgroundColor !== void 0 || props.borderStyle !== void 0) return true;
+		for (const child of node.children) if (hasVisibleContent(child)) return true;
+		return false;
+	}
+	function walk(node, cols, rows, suppressShift, commitShifts) {
+		if (!node.screenRect) {
+			for (const child of node.children) walk(child, cols, rows, suppressShift, commitShifts);
+			return;
+		}
+		if (envEnabled) checkSizeInvariants(node, cols, rows);
+		if (!suppressShift) {
+			const prev = node.prevScreenRect;
+			const next = node.screenRect;
+			if (prev !== null && !rectEqual(prev, next)) {
+				const isFirstMeasure = prev.width === 0 && prev.height === 0 && next.width > 0 && next.height > 0;
+				const isInlineTextNoise = node.type === "silvery-text" && (prev.width === 0 || prev.height === 0) && (next.width === 0 || next.height === 0);
+				if (!isFirstMeasure && !isInlineTextNoise) commitShifts.push({
+					path: nodePath(node),
+					prev,
+					next,
+					dtMs: null
+				});
+			}
+		}
+		for (const child of node.children) walk(child, cols, rows, suppressShift, commitShifts);
+	}
+	function onCommit(root, cols, rows, scrollOrResize) {
+		const suppressShift = scrollOrResize || cols !== prevCols || rows !== prevRows || prevCols === 0 || prevRows === 0;
+		prevCols = cols;
+		prevRows = rows;
+		if (!envEnabled && !capturing) return;
+		if (!root) return;
+		const commitShifts = [];
+		walk(root, cols, rows, suppressShift, commitShifts);
+		if (capturing && !suppressShift && commitShifts.length > 0) {
+			const ts = Date.now();
+			for (const rec of commitShifts) {
+				if (rec.prev === null || rec.next === null) continue;
+				const reason = activeClassifier(rec.path, rec.prev, rec.next, ts);
+				const shift = makeShift(rec.path, rec.prev, rec.next, ts, reason);
+				if (shift !== null) sessionShifts.push(shift);
+			}
+		}
+		if (!envEnabled) return;
+		if (commitShifts.length === 0) return;
+		const now = performance.now();
+		let stormPaths = 0;
+		for (const rec of commitShifts) {
+			if (recordShift(rec, now)) stormPaths++;
+			shiftLog.debug?.("shift", {
+				path: rec.path,
+				prev: rec.prev,
+				next: rec.next,
+				dtMs: rec.dtMs
+			});
+		}
+		log.debug?.("shift-count", {
+			shifts: commitShifts.length,
+			firstPaths: commitShifts.slice(0, 5).map((r) => r.path)
+		});
+		if (stormPaths > 0) log.warn?.("reflow-storm-per-path", {
+			stormPaths,
+			windowMs: STORM_PATH_WINDOW_MS,
+			threshold: STORM_PATH_THRESHOLD
+		});
+		if (commitShifts.length >= STORM_COMMIT_THRESHOLD) log.warn?.("reflow-storm-per-commit", {
+			shifts: commitShifts.length,
+			threshold: STORM_COMMIT_THRESHOLD,
+			firstPaths: commitShifts.slice(0, 5).map((r) => r.path)
+		});
+	}
+	function reset() {
+		pathHistory.clear();
+		prevCols = 0;
+		prevRows = 0;
+	}
+	function beginCapture(classifier) {
+		if (capturing) throw new Error("ClsMonitor.beginCapture: already capturing. Call endCapture() or cancelCapture() before starting a new window.");
+		capturing = true;
+		activeClassifier = classifier ?? defaultClassifier;
+		sessionShifts = [];
+	}
+	function endCapture() {
+		if (!capturing) throw new Error("ClsMonitor.endCapture: not capturing. Call beginCapture() first.");
+		const report = aggregateReport(sessionShifts);
+		capturing = false;
+		activeClassifier = defaultClassifier;
+		sessionShifts = [];
+		assertNoUnexpectedShifts(report);
+		return report;
+	}
+	function cancelCapture() {
+		capturing = false;
+		activeClassifier = defaultClassifier;
+		sessionShifts = [];
+	}
+	return {
+		onCommit,
+		reset,
+		beginCapture,
+		endCapture,
+		cancelCapture
+	};
+}
+//#endregion
+//#region packages/ag-react/src/chain-bridge.ts
+/**
+* Build a non-root BaseApp with the canonical plugin chain.
+*
+* The returned app is self-contained: ops dispatched through it don't
+* reach the root runtime. Callers own the lifecycle — there's no exit /
+* render effect handler wired up; effects are drained and discarded.
+*/
+function createChildApp() {
+	const base = createBaseApp();
+	const terminal = withTerminalChain()(base);
+	const input = withInputChain(withPasteChain()(terminal));
+	const events = withCustomEvents(withFocusChain({
+		dispatchKey: () => false,
+		hasActiveFocus: () => false
+	})(input));
+	const rawKeyListeners = [];
+	const rawKeys = {
+		register(handler) {
+			rawKeyListeners.push(handler);
+			return () => {
+				const i = rawKeyListeners.indexOf(handler);
+				if (i >= 0) rawKeyListeners.splice(i, 1);
+			};
+		},
+		notify(input, key) {
+			for (const h of rawKeyListeners) h(input, key);
+		}
+	};
+	const focusListeners = [];
+	return Object.assign(events, {
+		rawKeys,
+		focusEvents: {
+			register(handler) {
+				focusListeners.push(handler);
+				return () => {
+					const i = focusListeners.indexOf(handler);
+					if (i >= 0) focusListeners.splice(i, 1);
+				};
+			},
+			notify(focused) {
+				for (const h of focusListeners) h(focused);
+			}
+		}
+	});
+}
+/**
+* Project a {@link ChildApp} to the surface exposed on
+* {@link ChainAppContextValue}.
+*/
+function toChainAppContextValue(app) {
+	return {
+		input: app.input,
+		paste: app.paste,
+		focusEvents: app.focusEvents,
+		rawKeys: app.rawKeys,
+		events: app.events
+	};
+}
+//#endregion
+export { createBytesOutMonitor as A, withTerminalChain as B, recentRenderOutputEvents as C, buildMismatchContext as D, protectManagedCursorSuffix as E, compareBuffers as F, pipe as G, DRAG_CAPABILITY as H, formatMismatch as I, dispatchFocusEvent as J, createFocusEvent as K, withKeybindings as L, withRender as M, VirtualTerminal as N, formatMismatchContext as O, withDiagnostics as P, withCommands as R, recentRenderEvents as S, computeManagedFrame as T, SELECTION_CAPABILITY as U, createSelectionBridge as V, createCapabilityRegistry as W, dispatchKeyEvent as Y, withPasteChain as _, CLS_STRICT_SLUG as a, emitRenderOutputFrame as b, ScopeProvider as c, installTerminalWrapMeasurer as d, isTerminalWrapMeasurerInstalled as f, withInputChain as g, withCustomEvents as h, CLS_STRICT_MIN_TIER as i, createBaseApp as j, createMemMonitor as k, AppScopeContext as l, uninstallTerminalWrapMeasurer as m, toChainAppContextValue as n, UnexpectedLayoutShiftError as o, restoreDefaultWrapMeasurer as p, createKeyEvent as q, createClsMonitor as r, isClsStrictEnabled as s, createChildApp as t, ScopeContext as u, RenderScheduler as v, renderTraceDir as w, isRenderTraceEnabled as x, emitRenderDispatched as y, withFocusChain as z };
+
+//# sourceMappingURL=chain-bridge-CkYcMxlq.mjs.map