@silvery/examples 0.17.3 → 0.17.5

package/dist/plugins-CT0DdV_E.mjs

@@ -0,0 +1,3056 @@
+import { a as __toCommonJS, i as __require } from "./chunk-BSw8zbkd.mjs";
+import { A as buffer_exports, C as detectTextSizingSupport, F as enableFocusReporting, I as isModifierOnlyEvent, L as keyToAnsi, N as init_buffer, O as bufferToStyledText, P as createTermProvider, R as keyToKittyAnsi, T as isTextSizingLikelySupported, a as IncrementalRenderMismatchError, i as outputPhase, k as bufferToText, n as createTerm, r as createOutputPhase, t as createOutputGuard, w as getCachedProbeResult, z as parseKey } from "./ansi-0VXlUmNn.mjs";
+import { a as init_ThemeContext, m as createColorSchemeDetector, r as init_detect } from "./src-CUUOuRH6.mjs";
+import { A as createFocusManager, B as isAnyDirty, C as enterAlternateScreen, D as getAncestorPath, E as createPipeline, F as reconciler, G as FocusManagerContext, H as isLayoutEngineInitialized, I as setOnNodeRemoved, J as StdoutContext, K as RuntimeContext, L as executeRender, M as createContainer, N as createFiberRoot, O as CursorProvider, P as getContainerRoot, R as createAg, S as enableMouse, T as resetCursorStyle, U as CacheBackendContext, V as ensureDefaultLayoutEngine, W as CapabilityRegistryContext, Y as TermContext, _ as detectKittyFromStdio, a as renderSelectionOverlay, b as disableMouse, c as terminalSelectionUpdate, d as hitTest, f as processMouseEvent, g as createWidthDetector, h as applyWidthConfig, i as createVirtualScrollback, j as findByTestID, k as createCursorStore, l as createMouseEventProcessor, m as updateKeyboardModifiers, n as renderSearchBar, o as createTerminalSelectionState, p as selectionHitTest, q as StderrContext, r as searchUpdate, s as extractText, t as createSearchState, u as findContainBoundary, v as KittyFlags, w as leaveAlternateScreen, x as enableKittyKeyboard, y as disableKittyKeyboard, z as signal } from "./src-jO3Zuzjj.mjs";
+import { t as _usingCtx } from "./usingCtx-CsEf0xO3.mjs";
+import React, { Component, createContext, useContext, useEffect, useRef } from "react";
+import { createLogger } from "loggily";
+import * as fs from "node:fs";
+import { writeSync } from "node:fs";
+import "node:path";
+import process$1 from "node:process";
+import { jsx } from "react/jsx-runtime";
+//#region ../packages/ag-term/src/runtime/layout.ts
+init_buffer();
+/**
+* Ensure layout engine is initialized.
+* Must be called before layout() in async contexts.
+*/
+async function ensureLayoutEngine() {
+	if (!isLayoutEngineInitialized()) await ensureDefaultLayoutEngine();
+}
+//#endregion
+//#region ../packages/ag-term/src/runtime/diff.ts
+/**
+* Pure diff function for silvery-loop.
+*
+* Takes prev and next buffers, returns minimal ANSI patch.
+* This is an internal function used by the runtime.
+*/
+/**
+* Compute the minimal ANSI diff between two buffers.
+*
+* @param prev Previous buffer (null on first render)
+* @param next Current buffer
+* @param mode Render mode (fullscreen or inline)
+* @returns ANSI escape sequence string to transform prev into next
+*
+* @example
+* ```typescript
+* import { diff, layout } from '@silvery/ag-term/runtime'
+*
+* const prev = layout(<Text>Hello</Text>, dims)
+* const next = layout(<Text>World</Text>, dims)
+* const patch = diff(prev, next)
+* process.stdout.write(patch)
+* ```
+*/
+function diff(prev, next, mode = "fullscreen", scrollbackOffset = 0, termRows) {
+	const prevBuffer = prev?._buffer ?? null;
+	const nextBuffer = next._buffer;
+	return outputPhase(prevBuffer, nextBuffer, mode, scrollbackOffset, termRows);
+}
+//#endregion
+//#region ../packages/ag-term/src/runtime/create-buffer.ts
+init_buffer();
+function createBuffer(termBuffer, nodes) {
+	let _text;
+	let _ansi;
+	return {
+		get text() {
+			return _text ??= bufferToText(termBuffer);
+		},
+		get ansi() {
+			return _ansi ??= bufferToStyledText(termBuffer);
+		},
+		nodes,
+		_buffer: termBuffer
+	};
+}
+//#endregion
+//#region ../packages/create/src/streams/index.ts
+/**
+* AsyncIterable stream helpers for event-driven TUI architecture.
+*
+* These are pure functions over AsyncIterables - no EventEmitters, no callbacks.
+* All helpers properly handle cleanup via return() on early break.
+*
+* @example
+* ```typescript
+* const keys = term.keys()
+* const resizes = term.resizes()
+*
+* // Merge multiple sources
+* const events = merge(
+*   map(keys, k => ({ type: 'key', ...k })),
+*   map(resizes, r => ({ type: 'resize', ...r }))
+* )
+*
+* // Consume until ctrl+c
+* for await (const event of events) {
+*   if (event.type === 'key' && event.key === 'ctrl+c') break
+* }
+* ```
+*/
+/**
+* Merge multiple AsyncIterables into one.
+*
+* Values are emitted in arrival order (first-come). When all sources complete,
+* the merged iterable completes. If any source throws, the error propagates
+* and remaining sources are cleaned up.
+*
+* IMPORTANT: Each call to merge() creates a fresh iterable. Don't share
+* the same merged iterable between multiple consumers.
+*
+* @example
+* ```typescript
+* const merged = merge(keys, resizes, ticks)
+* for await (const event of merged) {
+*   // Process events from any source
+* }
+* ```
+*/
+async function* merge(...sources) {
+	if (sources.length === 0) return;
+	const iterators = sources.map((source) => source[Symbol.asyncIterator]());
+	const pending = /* @__PURE__ */ new Map();
+	async function nextWithIndex(idx) {
+		const iterator = iterators[idx];
+		if (!iterator) throw new Error(`No iterator at index ${idx}`);
+		return {
+			index: idx,
+			result: await iterator.next()
+		};
+	}
+	for (let i = 0; i < iterators.length; i++) pending.set(i, nextWithIndex(i));
+	try {
+		while (pending.size > 0) {
+			const { index, result } = await Promise.race(pending.values());
+			if (result.done) pending.delete(index);
+			else {
+				yield result.value;
+				pending.set(index, nextWithIndex(index));
+			}
+		}
+	} finally {
+		await Promise.all(iterators.map((it) => it.return ? it.return() : Promise.resolve()));
+	}
+}
+/**
+* Transform each value from an AsyncIterable.
+*
+* @example
+* ```typescript
+* const keyEvents = map(keys, k => ({ type: 'key' as const, key: k }))
+* ```
+*/
+async function* map(source, fn) {
+	const iterator = source[Symbol.asyncIterator]();
+	try {
+		for await (const value of { [Symbol.asyncIterator]: () => iterator }) yield fn(value);
+	} finally {
+		if (iterator.return) await iterator.return();
+	}
+}
+/**
+* Take values until an AbortSignal fires.
+*
+* When the signal aborts, the iterator completes gracefully (no error thrown).
+* The source iterator is properly cleaned up.
+*
+* @example
+* ```typescript
+* const controller = new AbortController()
+* const events = takeUntil(allEvents, controller.signal)
+*
+* // Later: controller.abort() will end the iteration
+* ```
+*/
+async function* takeUntil(source, signal) {
+	if (signal.aborted) return;
+	const iterator = source[Symbol.asyncIterator]();
+	let abortResolve;
+	const abortPromise = new Promise((resolve) => {
+		abortResolve = resolve;
+	});
+	const onAbort = () => abortResolve();
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		while (!signal.aborted) {
+			const result = await Promise.race([iterator.next(), abortPromise.then(() => ({
+				done: true,
+				value: void 0
+			}))]);
+			if (result.done) break;
+			yield result.value;
+		}
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+		if (iterator.return) await iterator.return();
+	}
+}
+//#endregion
+//#region ../packages/ag-term/src/runtime/create-runtime.ts
+/**
+* Create the silvery-loop runtime kernel.
+*
+* The runtime owns the event loop, diffing, and output. Users interact via:
+* - events() - AsyncIterable of all events (keys, resize, effects)
+* - schedule() - Queue effects for async execution
+* - render() - Output a buffer (diffing handled internally)
+*
+* NOTE: This runtime is designed for single-consumer use. Calling events()
+* multiple times concurrently will cause events to be split between consumers.
+* Each call returns a fresh AsyncIterable, but they share the underlying queue.
+*
+* @example
+* ```typescript
+* using runtime = createRuntime({ target: termTarget })
+*
+* for await (const event of runtime.events()) {
+*   state = reducer(state, event)
+*   runtime.render(layout(view(state), runtime.getDims()))
+* }
+* ```
+*/
+/**
+* Create an event channel that bridges callbacks to AsyncIterable.
+*
+* This is the single point where callbacks (resize, effect completion)
+* are converted to the async iterable pattern. External sources like
+* keyboard events are already AsyncIterable and merged at a higher level.
+*/
+function createEventChannel(signal) {
+	const queue = [];
+	let pendingResolve;
+	let disposed = false;
+	const onAbort = () => {
+		if (pendingResolve) {
+			pendingResolve(null);
+			pendingResolve = void 0;
+		}
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	return {
+		push(event) {
+			if (disposed || signal.aborted) return;
+			if (pendingResolve) {
+				const r = pendingResolve;
+				pendingResolve = void 0;
+				r(event);
+			} else queue.push(event);
+		},
+		events() {
+			return { [Symbol.asyncIterator]() {
+				return { async next() {
+					if (disposed || signal.aborted) return {
+						done: true,
+						value: void 0
+					};
+					if (queue.length > 0) return {
+						done: false,
+						value: queue.shift()
+					};
+					const event = await new Promise((resolve) => {
+						pendingResolve = resolve;
+					});
+					if (event === null || disposed || signal.aborted) return {
+						done: true,
+						value: void 0
+					};
+					return {
+						done: false,
+						value: event
+					};
+				} };
+			} };
+		},
+		dispose() {
+			disposed = true;
+			signal.removeEventListener("abort", onAbort);
+			if (pendingResolve) {
+				pendingResolve(null);
+				pendingResolve = void 0;
+			}
+		}
+	};
+}
+/**
+* Create a runtime kernel.
+*
+* @param options Runtime configuration
+* @returns Runtime instance implementing Symbol.dispose
+*/
+function createRuntime(options) {
+	const { target, signal: externalSignal, mode = "fullscreen" } = options;
+	const fallbackOutputPhase = mode === "inline" ? createOutputPhase({}) : void 0;
+	let outputPhaseFn = options.outputPhaseFn ?? fallbackOutputPhase;
+	const controller = new AbortController();
+	const signal = controller.signal;
+	let externalAbortHandler;
+	if (externalSignal) if (externalSignal.aborted) controller.abort();
+	else {
+		externalAbortHandler = () => controller.abort();
+		externalSignal.addEventListener("abort", externalAbortHandler, { once: true });
+	}
+	let prevBuffer = null;
+	let scrollbackOffset = 0;
+	let disposed = false;
+	const eventChannel = createEventChannel(signal);
+	let unsubscribeResize;
+	if (target.onResize) unsubscribeResize = target.onResize((dims) => {
+		eventChannel.push({
+			type: "resize",
+			cols: dims.cols,
+			rows: dims.rows
+		});
+	});
+	let effectId = 0;
+	return {
+		events() {
+			return takeUntil(eventChannel.events(), signal);
+		},
+		schedule(effect, opts) {
+			if (disposed) return;
+			const id = `effect-${effectId++}`;
+			const effectSignal = opts?.signal;
+			if (effectSignal?.aborted) return;
+			const execute = async () => {
+				let abortHandler;
+				try {
+					if (effectSignal) {
+						const aborted = new Promise((_resolve, reject) => {
+							abortHandler = () => reject(/* @__PURE__ */ new Error("Effect aborted"));
+							effectSignal.addEventListener("abort", abortHandler, { once: true });
+						});
+						const result = await Promise.race([effect(), aborted]);
+						if (abortHandler) effectSignal.removeEventListener("abort", abortHandler);
+						eventChannel.push({
+							type: "effect",
+							id,
+							result
+						});
+					} else {
+						const result = await effect();
+						eventChannel.push({
+							type: "effect",
+							id,
+							result
+						});
+					}
+				} catch (error) {
+					if (abortHandler && effectSignal) effectSignal.removeEventListener("abort", abortHandler);
+					if (error instanceof Error && (error.message === "Effect aborted" || error.name === "AbortError")) return;
+					eventChannel.push({
+						type: "error",
+						error: error instanceof Error ? error : new Error(String(error))
+					});
+				}
+			};
+			queueMicrotask(() => {
+				execute();
+			});
+		},
+		render(buffer) {
+			if (disposed) return;
+			const offset = scrollbackOffset;
+			scrollbackOffset = 0;
+			const termRows = target.getDims().rows;
+			let patch;
+			if (outputPhaseFn) {
+				const prevBuf = prevBuffer?._buffer ?? null;
+				const nextBuf = buffer._buffer;
+				patch = outputPhaseFn(prevBuf, nextBuf, mode, offset, termRows);
+			} else patch = diff(prevBuffer, buffer, mode, offset, termRows);
+			prevBuffer = buffer;
+			if (process.env.SILVERY_CAPTURE_RAW) try {
+				__require("fs").appendFileSync("/tmp/silvery-runtime-raw.ansi", patch);
+			} catch {}
+			target.write(patch);
+		},
+		addScrollbackLines(lines) {
+			if (mode !== "inline" || lines <= 0) return;
+			scrollbackOffset += lines;
+		},
+		invalidate() {
+			prevBuffer = null;
+		},
+		setOutputPhaseFn(fn) {
+			if (fn) outputPhaseFn = fn;
+		},
+		resetInlineCursor() {
+			outputPhaseFn?.resetInlineState?.();
+		},
+		getInlineCursorRow() {
+			return outputPhaseFn?.getInlineCursorRow?.() ?? -1;
+		},
+		promoteScrollback(content, lines) {
+			outputPhaseFn?.promoteScrollback?.(content, lines);
+		},
+		getDims() {
+			return target.getDims();
+		},
+		[Symbol.dispose]() {
+			if (disposed) return;
+			disposed = true;
+			controller.abort();
+			if (externalAbortHandler && externalSignal) externalSignal.removeEventListener("abort", externalAbortHandler);
+			if (unsubscribeResize) unsubscribeResize();
+			eventChannel.dispose();
+		}
+	};
+}
+//#endregion
+//#region ../packages/create/src/signal-store.ts
+/**
+* Signal Store — Zustand StoreApi-compatible store backed by alien-signals.
+*
+* Drop-in replacement for Zustand's createStore(). Provides the same
+* StoreApi<T> interface so useApp()/StoreContext keep working unchanged.
+*
+* Also re-exports StateCreator for backward compatibility with code
+* that imported it from "zustand".
+*/
+function createStore(factory) {
+	const listeners = /* @__PURE__ */ new Set();
+	const state$ = signal(void 0);
+	let initialState;
+	const setState = (partial, replace) => {
+		const prev = state$();
+		const raw = typeof partial === "function" ? partial(prev) : partial;
+		let next;
+		if (!replace && raw !== null && typeof raw === "object" && !Array.isArray(raw)) next = {
+			...prev,
+			...raw
+		};
+		else next = raw;
+		if (Object.is(prev, next)) return;
+		state$(next);
+		for (const listener of listeners) listener(next, prev);
+	};
+	const getState = () => state$();
+	const getInitialState = () => initialState;
+	const subscribe = (listener) => {
+		listeners.add(listener);
+		return () => {
+			listeners.delete(listener);
+		};
+	};
+	const api = {
+		setState,
+		getState,
+		getInitialState,
+		subscribe
+	};
+	const created = factory(setState, getState, api);
+	state$(created);
+	initialState = created;
+	return api;
+}
+//#endregion
+//#region ../packages/ag-react/src/error-boundary.tsx
+/**
+* ErrorBoundary — Built-in error boundary for silvery apps.
+*
+* Catches render errors in the component tree and displays a rich
+* error message with source location, code excerpt, and stack trace
+* using low-level silvery host elements (no dependency on Box/Text
+* from @silvery/ag-react/ui). This is the default root wrapper for all
+* silvery apps — createApp() and run() wrap the element tree with it
+* automatically.
+*
+* Uses `silvery-box` and `silvery-text` host elements directly to
+* avoid circular deps with higher-level component libraries.
+*
+* @packageDocumentation
+*/
+/**
+* Parse a stack line to extract function name, file, line, column.
+* Handles both `at Foo (file:line:col)` and `at file:line:col` formats.
+*/
+function parseStackLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("at ")) return null;
+	const rest = trimmed.slice(3);
+	const match1 = rest.match(/^(.+?)\s+\((.+?):(\d+):(\d+)\)$/);
+	if (match1) return {
+		function: match1[1],
+		file: match1[2],
+		line: Number(match1[3]),
+		column: Number(match1[4])
+	};
+	const match2 = rest.match(/^(.+?):(\d+):(\d+)$/);
+	if (match2) return {
+		file: match2[1],
+		line: Number(match2[2]),
+		column: Number(match2[3])
+	};
+	return null;
+}
+/**
+* Clean up file path by removing cwd prefix and file:// protocol.
+*/
+function cleanupPath(filePath) {
+	if (!filePath) return filePath;
+	let p = filePath;
+	const cwdPath = process.cwd();
+	p = p.replace(/^file:\/\//, "");
+	for (const prefix of [cwdPath, `/private${cwdPath}`]) if (p.startsWith(`${prefix}/`)) {
+		p = p.slice(prefix.length + 1);
+		break;
+	}
+	return p;
+}
+/**
+* Get source code excerpt around a line number (±3 lines).
+*/
+function getCodeExcerpt(filePath, line) {
+	try {
+		if (!fs.existsSync(filePath)) return null;
+		const lines = fs.readFileSync(filePath, "utf8").split("\n");
+		const start = Math.max(0, line - 4);
+		const end = Math.min(lines.length, line + 3);
+		const result = [];
+		for (let i = start; i < end; i++) result.push({
+			line: i + 1,
+			value: (lines[i] ?? "").replace(/\t/g, "  ")
+		});
+		return result;
+	} catch {
+		return null;
+	}
+}
+/**
+* Rich error boundary for silvery's runtime layer.
+*
+* Must be a class component (React limitation for error boundaries).
+* Renders error info using silvery-box/silvery-text host elements — no Box/Text dependency.
+* Shows: ERROR label, error message, file location, source code excerpt, and stack trace.
+*/
+var SilveryErrorBoundary = class extends Component {
+	state = { error: null };
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	componentDidCatch(error) {
+		this.props.onError?.(error);
+	}
+	render() {
+		if (this.state.error) {
+			const err = this.state.error;
+			const stack = err.stack ? err.stack.split("\n").slice(1) : [];
+			const origin = stack.length > 0 ? parseStackLine(stack[0]) : null;
+			const filePath = cleanupPath(origin?.file);
+			let excerpt = null;
+			let lineWidth = 0;
+			if (filePath && origin?.line) {
+				excerpt = getCodeExcerpt(filePath, origin.line);
+				if (excerpt) for (const { line } of excerpt) lineWidth = Math.max(lineWidth, String(line).length);
+			}
+			const children = [];
+			children.push(React.createElement("silvery-box", { key: "header" }, React.createElement("silvery-text", {
+				backgroundColor: "red",
+				color: "white"
+			}, " ERROR "), React.createElement("silvery-text", {}, ` ${err.message}`)));
+			if (filePath && origin) children.push(React.createElement("silvery-box", {
+				key: "location",
+				marginTop: 1
+			}, React.createElement("silvery-text", { dimColor: true }, `${filePath}:${origin.line}:${origin.column}`)));
+			if (excerpt && origin) {
+				const codeLines = excerpt.map(({ line, value }) => {
+					const lineNum = String(line).padStart(lineWidth, " ");
+					return React.createElement("silvery-box", { key: `code-${line}` }, React.createElement("silvery-text", {
+						dimColor: line !== origin.line,
+						backgroundColor: line === origin.line ? "red" : void 0,
+						color: line === origin.line ? "white" : void 0
+					}, `${lineNum}:`), React.createElement("silvery-text", {
+						backgroundColor: line === origin.line ? "red" : void 0,
+						color: line === origin.line ? "white" : void 0
+					}, ` ${value}`));
+				});
+				children.push(React.createElement("silvery-box", {
+					key: "code",
+					marginTop: 1,
+					flexDirection: "column"
+				}, ...codeLines));
+			}
+			if (stack.length > 0) {
+				const stackLines = stack.map((line, i) => {
+					const parsed = parseStackLine(line);
+					if (!parsed) return React.createElement("silvery-box", { key: `stack-${i}` }, React.createElement("silvery-text", { dimColor: true }, `- ${line.trim()}`));
+					const cleanFile = cleanupPath(parsed.file);
+					return React.createElement("silvery-box", { key: `stack-${i}` }, React.createElement("silvery-text", { dimColor: true }, "- "), React.createElement("silvery-text", {
+						dimColor: true,
+						bold: true
+					}, parsed.function ?? ""), React.createElement("silvery-text", {
+						dimColor: true,
+						color: "gray"
+					}, ` (${cleanFile ?? ""}:${parsed.line}:${parsed.column})`));
+				});
+				children.push(React.createElement("silvery-box", {
+					key: "stack",
+					marginTop: 1,
+					flexDirection: "column"
+				}, ...stackLines));
+			}
+			return React.createElement("silvery-box", {
+				flexDirection: "column",
+				padding: 1
+			}, ...children);
+		}
+		return this.props.children;
+	}
+};
+//#endregion
+//#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/ag-term/src/scheduler.ts
+init_buffer();
+createLogger("silvery:scheduler");
+process.env.SILVERY_SYNC_UPDATE === "1" || process.env.SILVERY_SYNC_UPDATE;
+//#endregion
+//#region ../packages/ag-term/src/runtime/event-handlers.ts
+/**
+* Build the EventHandlerContext passed to user-defined event handlers.
+* Shared by runEventHandler() and press().
+*
+* When the store was created with `tea()` middleware, `dispatch` is
+* automatically wired from the store state.
+*/
+function createHandlerContext(store, focusManager, container) {
+	const state = store.getState();
+	const teaDispatch = typeof state.dispatch === "function" ? state.dispatch : void 0;
+	return {
+		set: store.setState,
+		get: store.getState,
+		focusManager,
+		focus(testID) {
+			const root = getContainerRoot(container);
+			focusManager.focusById(testID, root, "programmatic");
+		},
+		activateScope(scopeId) {
+			const root = getContainerRoot(container);
+			focusManager.activateScope(scopeId, root);
+		},
+		getFocusPath() {
+			const root = getContainerRoot(container);
+			return focusManager.getFocusPath(root);
+		},
+		dispatch: teaDispatch,
+		hitTest(x, y) {
+			return hitTest(getContainerRoot(container), x, y);
+		}
+	};
+}
+/**
+* Dispatch a key event through the focus system and handle default
+* focus navigation (Tab, Shift+Tab, Enter scope, Escape scope).
+*
+* Returns "consumed" if the focus system handled the event (caller should
+* render and return), or "continue" if the event should proceed to app handlers.
+*/
+function handleFocusNavigation(input, parsedKey, focusManager, container) {
+	if (focusManager.activeElement) {
+		const keyEvent = createKeyEvent(input, parsedKey, focusManager.activeElement);
+		dispatchKeyEvent(keyEvent);
+		if (keyEvent.propagationStopped || keyEvent.defaultPrevented) return "consumed";
+	}
+	const root = getContainerRoot(container);
+	if (parsedKey.tab && !parsedKey.shift) {
+		focusManager.focusNext(root);
+		return "consumed";
+	}
+	if (parsedKey.tab && parsedKey.shift) {
+		focusManager.focusPrev(root);
+		return "consumed";
+	}
+	if (parsedKey.return && focusManager.activeElement) {
+		const activeEl = focusManager.activeElement;
+		const props = activeEl.props;
+		const testID = typeof props.testID === "string" ? props.testID : null;
+		if (props.focusScope && testID) {
+			focusManager.enterScope(testID);
+			focusManager.focusNext(root, activeEl);
+			return "consumed";
+		}
+	}
+	if (parsedKey.escape) {
+		if (focusManager.scopeStack.length > 0) {
+			const scopeId = focusManager.scopeStack[focusManager.scopeStack.length - 1];
+			focusManager.exitScope();
+			const scopeNode = findByTestID(root, scopeId);
+			if (scopeNode) focusManager.focus(scopeNode, "keyboard");
+			return "consumed";
+		}
+	}
+	return "continue";
+}
+/**
+* Dispatch a DOM-level mouse event to the node tree.
+* Called from runEventHandler for mouse events.
+*/
+function dispatchMouseEventToTree(event, mouseEventState, root) {
+	if (event.event !== "mouse" || !event.data) return false;
+	const mouseData = event.data;
+	return processMouseEvent(mouseEventState, {
+		button: mouseData.button,
+		x: mouseData.x,
+		y: mouseData.y,
+		action: mouseData.action,
+		delta: mouseData.delta,
+		shift: mouseData.shift,
+		meta: mouseData.meta,
+		ctrl: mouseData.ctrl
+	}, root);
+}
+/**
+* Invoke the namespaced handler for a single event (state mutation only, no render).
+* Returns true to continue, false to exit, or "flush" for a render barrier.
+*
+* Also dispatches DOM-level mouse events when applicable.
+*/
+function invokeEventHandler(event, handlers, ctx, mouseEventState, container) {
+	if (dispatchMouseEventToTree(event, mouseEventState, getContainerRoot(container))) return true;
+	const namespacedHandler = handlers?.[event.type];
+	if (namespacedHandler && typeof namespacedHandler === "function") {
+		const result = namespacedHandler(event.data, ctx);
+		if (result === "exit") return false;
+		if (result === "flush") return "flush";
+	}
+	return true;
+}
+/**
+* Dispatch a term:key event to app handlers (namespaced + legacy).
+* Returns "exit" if the handler signaled exit, undefined otherwise.
+*/
+function dispatchKeyToHandlers(input, parsedKey, handlers, ctx) {
+	const namespacedHandler = handlers?.["term:key"];
+	if (namespacedHandler && typeof namespacedHandler === "function") {
+		if (namespacedHandler({
+			input,
+			key: parsedKey
+		}, ctx) === "exit") return "exit";
+	}
+	if (handlers?.key) {
+		if (handlers.key(input, parsedKey, ctx) === "exit") return "exit";
+	}
+}
+//#endregion
+//#region ../packages/ag-term/src/runtime/terminal-lifecycle.ts
+/**
+* Terminal Lifecycle Events
+*
+* Handles suspend/resume (Ctrl+Z/SIGCONT) and interrupt (Ctrl+C) for TUI apps.
+* When stdin is in raw mode, the terminal does not generate SIGTSTP/SIGINT for
+* Ctrl+Z/Ctrl+C. This module intercepts the raw bytes and manages the full
+* terminal state save/restore cycle.
+*
+* Inspired by ncurses (endwin/refresh), bubbletea, and Textual.
+*
+* Protocols managed:
+* - Raw mode (stdin)
+* - Alternate screen buffer (DEC private mode 1049)
+* - Cursor visibility (DEC private mode 25)
+* - Mouse tracking (modes 1000, 1002, 1006)
+* - Kitty keyboard protocol (CSI > flags u / CSI < u)
+* - Bracketed paste (DEC private mode 2004)
+* - SGR attributes (reset via CSI 0 m)
+*/
+/**
+* Capture the current terminal protocol state.
+*
+* This builds a TerminalState from the options passed to run()/createApp(),
+* since terminal state is not directly queryable from the OS.
+*/
+function captureTerminalState(opts) {
+	return {
+		rawMode: opts.rawMode ?? true,
+		alternateScreen: opts.alternateScreen ?? false,
+		cursorHidden: opts.cursorHidden ?? true,
+		mouseEnabled: opts.mouse ?? false,
+		kittyEnabled: opts.kitty ?? false,
+		kittyFlags: opts.kittyFlags ?? 11,
+		bracketedPaste: opts.bracketedPaste ?? false,
+		focusReporting: opts.focusReporting ?? false
+	};
+}
+/**
+* Restore terminal to normal state before suspending or exiting.
+*
+* Uses writeSync for reliability during signal handling (async write
+* may not complete before the process suspends).
+*
+* Order matters: disable protocols first, then show cursor, then exit
+* alternate screen, then disable raw mode.
+*/
+function restoreTerminalState(stdout, stdin) {
+	try {
+		stdin.removeAllListeners("data");
+		stdin.pause();
+	} catch {}
+	const sequences = [
+		"\x1B[0m",
+		"\x1B[?1004l",
+		disableMouse(),
+		disableKittyKeyboard(),
+		"\x1B[?2004l",
+		resetCursorStyle(),
+		"\x1B[?25h",
+		"\x1B[?1049l"
+	].join("");
+	if (stdout === process.stdout) try {
+		writeSync(stdout.fd, sequences);
+	} catch {
+		try {
+			stdout.write(sequences);
+		} catch {}
+	}
+	else try {
+		stdout.write(sequences);
+	} catch {}
+	try {
+		stdin.resume();
+		while (stdin.read() !== null);
+		stdin.pause();
+	} catch {}
+	if (stdin.isTTY && stdin.isRaw) try {
+		stdin.setRawMode(false);
+	} catch {}
+}
+/**
+* Re-enter TUI mode after resuming from suspend (SIGCONT).
+*
+* Restores all protocols that were active before suspend, in the correct
+* order: raw mode first, then alternate screen, then protocols, then
+* trigger a full redraw via synthetic resize.
+*/
+function resumeTerminalState(state, stdout, stdin) {
+	if (state.rawMode && stdin.isTTY) try {
+		stdin.setRawMode(true);
+		stdin.resume();
+	} catch {}
+	const sequences = [];
+	if (state.alternateScreen) sequences.push("\x1B[?1049h");
+	sequences.push("\x1B[2J\x1B[H");
+	if (state.cursorHidden) sequences.push("\x1B[?25l");
+	if (state.kittyEnabled) sequences.push(enableKittyKeyboard(state.kittyFlags));
+	if (state.mouseEnabled) sequences.push(enableMouse());
+	if (state.bracketedPaste) sequences.push("\x1B[?2004h");
+	if (state.focusReporting) sequences.push("\x1B[?1004h");
+	const joined = sequences.join("");
+	if (stdout === process.stdout) try {
+		writeSync(stdout.fd, joined);
+	} catch {
+		try {
+			stdout.write(joined);
+		} catch {}
+	}
+	else try {
+		stdout.write(joined);
+	} catch {}
+	stdout.emit("resize");
+}
+/**
+* Execute the full suspend flow: save state, restore terminal, SIGTSTP,
+* and set up SIGCONT handler to resume.
+*
+* @param state - Terminal state snapshot to restore on resume
+* @param stdout - Output stream
+* @param stdin - Input stream
+* @param onResume - Optional callback after resume
+*/
+function performSuspend(state, stdout, stdin, onResume) {
+	restoreTerminalState(stdout, stdin);
+	process.once("SIGCONT", () => {
+		resumeTerminalState(state, stdout, stdin);
+		onResume?.();
+	});
+	process.kill(process.pid, "SIGTSTP");
+}
+//#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();
+		},
+		dispose() {}
+	};
+}
+//#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");
+/** Clipboard feature: copy/paste via OSC 52 or other backends. */
+const CLIPBOARD_CAPABILITY = Symbol.for("silvery.clipboard");
+/** Input router: priority-based event dispatch for interaction features. */
+const INPUT_ROUTER = Symbol.for("silvery.input-router");
+//#endregion
+//#region ../packages/ag-term/src/runtime/perf.ts
+/**
+* Keypress performance instrumentation.
+*
+* Zero-overhead when TRACE is not set — all logging uses optional chaining.
+* When TRACE=silvery:perf is set, emits span timing for each keypress cycle
+* and a summary on exit.
+*
+* @example
+* ```bash
+* TRACE=silvery:perf bun km view ~/vault
+* # → SPAN silvery:perf:keypress (5ms) {key: "j"}
+* # → on exit: keypress summary: 42 presses, mean=4.2ms, p95=12.1ms, max=18.3ms, overruns=2
+* ```
+*/
+/** Exported for ?.  chaining in hot paths: `perfLog.span?.("keypress", { key })` */
+const perfLog = createLogger("silvery:perf");
+let samples = null;
+let budgetOverruns = 0;
+/**
+* Record a completed keypress and check budget.
+* Only records when tracing is active (samples array initialized by startTracking).
+* Call after the keypress cycle completes (render done).
+*/
+function checkBudget(key, durationMs, budgetMs = 16) {
+	if (samples) samples.push({
+		key,
+		durationMs
+	});
+	if (durationMs > budgetMs) {
+		budgetOverruns++;
+		perfLog.warn?.(`keypress over budget: ${key} took ${durationMs.toFixed(1)}ms (budget: ${budgetMs}ms)`);
+	}
+}
+/** Call once when first span is created to start accumulating samples. */
+function startTracking() {
+	if (!samples) samples = [];
+}
+/**
+* Log a summary of all recorded keypress spans.
+*
+* Call when the app unmounts/exits. Only produces output when TRACE is
+* enabled and at least one span was recorded.
+*/
+function logExitSummary() {
+	if (!samples || samples.length === 0) return;
+	const durations = samples.map((s) => s.durationMs).sort((a, b) => a - b);
+	const total = samples.length;
+	const mean = durations.reduce((sum, d) => sum + d, 0) / total;
+	const p95 = durations[Math.min(Math.floor(total * .95), total - 1)];
+	const max = durations[total - 1];
+	perfLog.info?.(`keypress summary: ${total} presses, mean=${mean.toFixed(1)}ms, p95=${p95.toFixed(1)}ms, max=${max.toFixed(1)}ms, overruns=${budgetOverruns}`);
+	samples = null;
+	budgetOverruns = 0;
+}
+//#endregion
+//#region ../packages/ag-term/src/runtime/create-app.tsx
+/**
+* createApp() - Layer 3 entry point for silvery-loop
+*
+* Provides signal-backed store integration with unified providers.
+* Providers are stores (getState/subscribe) + event sources (events()).
+*
+* @example
+* ```tsx
+* import { createApp, useApp } from '@silvery/create/create-app'
+* import { createTermProvider } from '@silvery/ag-term/runtime'
+*
+* const app = createApp(
+*   // Store factory
+*   ({ term }) => (set, get) => ({
+*     count: 0,
+*     increment: () => set(s => ({ count: s.count + 1 })),
+*   }),
+*   // Event handlers - namespaced as 'provider:event'
+*   {
+*     'term:key': ({ input, key }, { set }) => {
+*       if (input === 'j') set(s => ({ count: s.count + 1 }))
+*       if (input === 'q') return 'exit'
+*     },
+*     'term:resize': ({ cols, rows }, { set }) => {
+*       // handle resize
+*     },
+*   }
+* )
+*
+* function Counter() {
+*   const count = useApp(s => s.count)
+*   return <Text>Count: {count}</Text>
+* }
+*
+* const term = createTermProvider(process.stdin, process.stdout)
+* await app.run(<Counter />, { term })
+*
+* // Frame iteration:
+* for await (const frame of app.run(<Counter />, { term })) {
+*   expect(frame.text).toContain('Count:')
+* }
+* ```
+*/
+const log = createLogger("silvery:app");
+const ENV = typeof process$1 !== "undefined" ? process$1.env : void 0;
+const NO_INCREMENTAL = ENV?.SILVERY_NO_INCREMENTAL === "1";
+const STRICT_MODE = (() => {
+	const v = ENV?.SILVERY_STRICT;
+	return !!v && v !== "0" && v !== "false";
+})();
+const CELL_DEBUG = (() => {
+	const v = ENV?.SILVERY_CELL_DEBUG;
+	if (!v || !v.includes(",")) return null;
+	const [cx, cy] = v.split(",").map(Number);
+	if (!Number.isFinite(cx) || !Number.isFinite(cy)) return null;
+	return {
+		x: cx,
+		y: cy
+	};
+})();
+const INSTRUMENTED = STRICT_MODE || CELL_DEBUG !== null;
+/**
+* Check if value is a Provider with events (full interface).
+*/
+function isFullProvider(value) {
+	if (value === null || value === void 0) return false;
+	if (typeof value !== "object" && typeof value !== "function") return false;
+	return "getState" in value && "subscribe" in value && "events" in value && typeof value.getState === "function" && typeof value.subscribe === "function" && typeof value.events === "function";
+}
+/**
+* Check if value is a basic Provider (just getState/subscribe, Zustand-compatible).
+*/
+function isBasicProvider(value) {
+	if (value === null || value === void 0) return false;
+	if (typeof value !== "object" && typeof value !== "function") return false;
+	return "getState" in value && "subscribe" in value && typeof value.getState === "function" && typeof value.subscribe === "function";
+}
+const StoreContext = createContext(null);
+/**
+* Hook for accessing app state with selectors.
+*
+* @example
+* ```tsx
+* const count = useApp(s => s.count)
+* const { count, increment } = useApp(s => ({ count: s.count, increment: s.increment }))
+* ```
+*/
+function useApp(selector) {
+	const store = useContext(StoreContext);
+	if (!store) throw new Error("useApp must be used within createApp().run()");
+	const [state, setState] = React.useState(() => selector(store.getState()));
+	const selectorRef = useRef(selector);
+	selectorRef.current = selector;
+	useEffect(() => {
+		return store.subscribe((newState) => {
+			const next = selectorRef.current(newState);
+			setState((prev) => Object.is(prev, next) ? prev : next);
+		});
+	}, [store]);
+	return state;
+}
+/**
+* Create an app with Zustand store and provider integration.
+*
+* This is Layer 3 - it provides:
+* - Zustand store with fine-grained subscriptions
+* - Providers as unified stores + event sources
+* - Event handlers namespaced as 'provider:event'
+*
+* @param factory Store factory function that receives providers
+* @param handlers Optional event handlers (namespaced as 'provider:event')
+*/
+function createApp(factory, handlers) {
+	return { run(element, options = {}) {
+		let handlePromise = null;
+		const init = () => {
+			if (handlePromise) return handlePromise;
+			handlePromise = initApp(factory, handlers, element, options);
+			return handlePromise;
+		};
+		return {
+			then(onfulfilled, onrejected) {
+				return init().then(onfulfilled, onrejected);
+			},
+			[Symbol.asyncIterator]() {
+				let handle = null;
+				let iterator = null;
+				let started = false;
+				return {
+					async next() {
+						if (!started) {
+							started = true;
+							handle = await init();
+							iterator = handle[Symbol.asyncIterator]();
+						}
+						return iterator.next();
+					},
+					async return() {
+						if (handle) handle.unmount();
+						return {
+							done: true,
+							value: void 0
+						};
+					}
+				};
+			}
+		};
+	} };
+}
+/**
+* Initialize the app — extracted from run() for clarity.
+*/
+async function initApp(factory, handlers, element, options) {
+	const { cols: explicitCols, rows: explicitRows, stdout: explicitStdout, stdin = process$1.stdin, signal: externalSignal, alternateScreen = false, kittyMode: explicitKittyMode, kitty: kittyOption, mouse: mouseOption = false, virtualInline: virtualInlineOption = false, suspendOnCtrlZ: suspendOption = true, exitOnCtrlC: exitOnCtrlCOption = true, onSuspend: onSuspendHook, onResume: onResumeHook, onInterrupt: onInterruptHook, textSizing: textSizingOption, widthDetection: widthDetectionOption, focusReporting: focusReportingOption = false, selection: selectionOption, caps: capsOption, guardOutput: guardOutputOption, Root: RootComponent, capabilityRegistry: capabilityRegistryOption, writable: explicitWritable, onResize: explicitOnResize, ...injectValues } = options;
+	const useKittyMode = explicitKittyMode ?? !!kittyOption;
+	const headless = explicitCols != null && explicitRows != null && !explicitStdout || explicitWritable != null;
+	const cols = explicitCols ?? process$1.stdout.columns ?? 80;
+	const rows = explicitRows ?? process$1.stdout.rows ?? 24;
+	const stdout = explicitStdout ?? process$1.stdout;
+	const isRealStdout = stdout === process$1.stdout;
+	const shouldGuardOutput = guardOutputOption ?? (alternateScreen && !headless && isRealStdout);
+	let outputGuard = null;
+	await ensureLayoutEngine();
+	const controller = new AbortController();
+	const signal = controller.signal;
+	if (externalSignal) if (externalSignal.aborted) controller.abort();
+	else externalSignal.addEventListener("abort", () => controller.abort(), { once: true });
+	const providers = {};
+	const plainValues = {};
+	const providerCleanups = [];
+	let termProvider = null;
+	if (!("term" in injectValues) || !isFullProvider(injectValues.term)) {
+		const resizeListeners = /* @__PURE__ */ new Set();
+		const termStdout = headless ? {
+			columns: cols,
+			rows,
+			write: () => true,
+			isTTY: false,
+			on(event, handler) {
+				if (event === "resize") resizeListeners.add(handler);
+				return termStdout;
+			},
+			off(event, handler) {
+				if (event === "resize") resizeListeners.delete(handler);
+				return termStdout;
+			}
+		} : stdout;
+		const termStdin = headless ? {
+			isTTY: false,
+			on: () => termStdin,
+			off: () => termStdin,
+			setRawMode: () => {},
+			resume: () => {},
+			pause: () => {},
+			setEncoding: () => {}
+		} : stdin;
+		termProvider = createTermProvider(termStdin, termStdout, {
+			cols,
+			rows
+		});
+		providers.term = termProvider;
+		providerCleanups.push(() => termProvider[Symbol.dispose]());
+		if (headless && explicitOnResize) {
+			const unsub = explicitOnResize((dims) => {
+				currentDims = dims;
+				termStdout.columns = dims.cols;
+				termStdout.rows = dims.rows;
+				for (const listener of resizeListeners) listener();
+			});
+			providerCleanups.push(unsub);
+		}
+	}
+	for (const [name, value] of Object.entries(injectValues)) if (isFullProvider(value)) providers[name] = value;
+	else plainValues[name] = value;
+	const inject = {
+		...providers,
+		...plainValues
+	};
+	const stateUnsubscribes = [];
+	const store = createStore((set, get, api) => {
+		const mergedState = { ...factory(inject)(set, get, api) };
+		for (const [name, provider] of Object.entries(providers)) {
+			mergedState[name] = provider;
+			if (isBasicProvider(provider)) {
+				const unsub = provider.subscribe((_providerState) => {});
+				stateUnsubscribes.push(unsub);
+			}
+		}
+		for (const [name, value] of Object.entries(plainValues)) mergedState[name] = value;
+		return mergedState;
+	});
+	let currentDims = {
+		cols,
+		rows
+	};
+	if (!headless) {
+		const onStdoutResize = () => {
+			currentDims = {
+				cols: stdout.columns || 80,
+				rows: stdout.rows || 24
+			};
+			for (const listener of mockTermSubscribers) listener(currentDims);
+		};
+		stdout.on("resize", onStdoutResize);
+		providerCleanups.push(() => stdout.off("resize", onStdoutResize));
+	}
+	let shouldExit = false;
+	let renderPaused = false;
+	let isRendering = false;
+	let inEventHandler = false;
+	let pendingRerender = false;
+	const _ansiTrace = !headless && process$1.env?.SILVERY_TRACE === "1";
+	let _traceSeq = 0;
+	const _traceStart = performance.now();
+	let _origStdoutWrite;
+	if (_ansiTrace) {
+		const fs = __require("node:fs");
+		fs.writeFileSync("/tmp/silvery-trace.log", `=== SILVERY TRACE START ===\n`);
+		_origStdoutWrite = stdout.write.bind(stdout);
+		const symbolize = (s) => s.replace(/\x1b\[\?1049h/g, "⟨ALT_ON⟩").replace(/\x1b\[\?1049l/g, "⟨ALT_OFF⟩").replace(/\x1b\[2J/g, "⟨CLEAR⟩").replace(/\x1b\[H/g, "⟨HOME⟩").replace(/\x1b\[\?25l/g, "⟨CUR_HIDE⟩").replace(/\x1b\[\?25h/g, "⟨CUR_SHOW⟩").replace(/\x1b\[\?2026h/g, "⟨SYNC_ON⟩").replace(/\x1b\[\?2026l/g, "⟨SYNC_OFF⟩").replace(/\x1b\[\?2004h/g, "⟨BPASTE_ON⟩").replace(/\x1b\[\?2004l/g, "⟨BPASTE_OFF⟩").replace(/\x1b\[0m/g, "⟨RST⟩").replace(/\x1b\[(\d+);(\d+)H/g, "⟨GO $1,$2⟩").replace(/\x1b\[38;5;(\d+)m/g, "⟨F$1⟩").replace(/\x1b\[48;5;(\d+)m/g, "⟨B$1⟩").replace(/\x1b\[38;2;(\d+);(\d+);(\d+)m/g, "⟨FR$1,$2,$3⟩").replace(/\x1b\[48;2;(\d+);(\d+);(\d+)m/g, "⟨BR$1,$2,$3⟩").replace(/\x1b\[1m/g, "⟨BOLD⟩").replace(/\x1b\[2m/g, "⟨DIM⟩").replace(/\x1b\[3m/g, "⟨ITAL⟩").replace(/\x1b\[4m/g, "⟨UL⟩").replace(/\x1b\[7m/g, "⟨INV⟩").replace(/\x1b\[22m/g, "⟨/BOLD⟩").replace(/\x1b\[23m/g, "⟨/ITAL⟩").replace(/\x1b\[24m/g, "⟨/UL⟩").replace(/\x1b\[27m/g, "⟨/INV⟩").replace(/\x1b\[39m/g, "⟨/FG⟩").replace(/\x1b\[49m/g, "⟨/BG⟩").replace(/\x1b\[([0-9;]*)([A-Za-z])/g, "⟨CSI $1$2⟩").replace(/\x1b([^\[])/, "⟨ESC $1⟩");
+		const traceWrite = function(chunk, ...args) {
+			const str = typeof chunk === "string" ? chunk : String(chunk);
+			const seq = ++_traceSeq;
+			const ms = (performance.now() - _traceStart).toFixed(0);
+			const decoded = symbolize(str);
+			const preview = decoded.length > 400 ? decoded.slice(0, 200) + ` ...[${decoded.length}ch]... ` + decoded.slice(-100) : decoded;
+			fs.appendFileSync("/tmp/silvery-trace.log", `[${String(seq).padStart(4, "0")}] +${ms}ms (${str.length}b): ${preview}\n`);
+			return _origStdoutWrite.call(this, chunk, ...args);
+		};
+		stdout.write = traceWrite;
+		providerCleanups.push(() => {
+			if (_origStdoutWrite) stdout.write = _origStdoutWrite;
+		});
+	}
+	const target = headless ? {
+		write(frame) {
+			if (explicitWritable) explicitWritable.write(frame);
+		},
+		getDims: () => currentDims
+	} : {
+		write(frame) {
+			if (_perfLog) __require("node:fs").appendFileSync("/tmp/silvery-perf.log", `TARGET.write: ${frame.length} bytes (paused=${renderPaused})\n`);
+			if (!renderPaused) if (outputGuard) outputGuard.writeStdout(frame);
+			else stdout.write(frame);
+		},
+		getDims() {
+			return currentDims;
+		},
+		onResize(handler) {
+			const onResize = () => {
+				currentDims = {
+					cols: stdout.columns || 80,
+					rows: stdout.rows || 24
+				};
+				handler(currentDims);
+			};
+			stdout.on("resize", onResize);
+			return () => stdout.off("resize", onResize);
+		}
+	};
+	const heuristicSupported = capsOption?.textSizingSupported ?? isTextSizingLikelySupported();
+	const shouldProbe = textSizingOption === "probe" || textSizingOption === "auto" && heuristicSupported;
+	const cachedProbe = shouldProbe ? getCachedProbeResult() : void 0;
+	let textSizingEnabled;
+	if (textSizingOption === true) textSizingEnabled = true;
+	else if (textSizingOption === "probe") textSizingEnabled = cachedProbe?.supported ?? false;
+	else if (textSizingOption === "auto") if (cachedProbe !== void 0) textSizingEnabled = cachedProbe.supported;
+	else textSizingEnabled = heuristicSupported;
+	else textSizingEnabled = false;
+	const needsProbe = shouldProbe && cachedProbe === void 0 && !headless;
+	const needsWidthDetection = !headless && (widthDetectionOption === true || widthDetectionOption === "auto" && capsOption != null);
+	let effectiveCaps = capsOption ? {
+		...capsOption,
+		textSizingSupported: textSizingEnabled
+	} : void 0;
+	let pipelineConfig = effectiveCaps ? createPipeline({ caps: effectiveCaps }) : void 0;
+	const runtime = createRuntime({
+		target,
+		signal,
+		mode: alternateScreen ? "fullscreen" : "inline",
+		outputPhaseFn: pipelineConfig?.outputPhaseFn
+	});
+	let cleanedUp = false;
+	let storeUnsubscribeFn = null;
+	let kittyEnabled = false;
+	const defaultKittyFlags = KittyFlags.DISAMBIGUATE | KittyFlags.REPORT_EVENTS | KittyFlags.REPORT_ALL_KEYS;
+	let kittyFlags = defaultKittyFlags;
+	let mouseEnabled = false;
+	let focusReportingEnabled = false;
+	const selectionEnabled = selectionOption ?? false;
+	let selectionState = createTerminalSelectionState();
+	const selectionListeners = /* @__PURE__ */ new Set();
+	/** Notify useSelection() subscribers that selection state changed. */
+	function notifySelectionListeners() {
+		for (const listener of selectionListeners) listener();
+	}
+	const capabilityRegistry = capabilityRegistryOption ?? createCapabilityRegistry();
+	let selectionBridge;
+	if (selectionEnabled) {
+		selectionBridge = createSelectionBridge({
+			getState: () => selectionState,
+			subscribe: (listener) => {
+				selectionListeners.add(listener);
+				return () => {
+					selectionListeners.delete(listener);
+				};
+			},
+			setRange: (range) => {
+				if (range === null) {
+					const [next] = terminalSelectionUpdate({ type: "clear" }, selectionState);
+					selectionState = next;
+				} else {
+					const [s1] = terminalSelectionUpdate({
+						type: "start",
+						col: range.anchor.col,
+						row: range.anchor.row,
+						source: "keyboard"
+					}, selectionState);
+					const [s2] = terminalSelectionUpdate({
+						type: "extend",
+						col: range.head.col,
+						row: range.head.row
+					}, s1);
+					const [s3] = terminalSelectionUpdate({ type: "finish" }, s2);
+					selectionState = s3;
+				}
+				notifySelectionListeners();
+				if (currentBuffer) runtime.invalidate();
+			},
+			clear: () => {
+				const [next] = terminalSelectionUpdate({ type: "clear" }, selectionState);
+				selectionState = next;
+				notifySelectionListeners();
+				if (currentBuffer) runtime.invalidate();
+			}
+		});
+		capabilityRegistry.register(SELECTION_CAPABILITY, selectionBridge);
+	}
+	const scrollback = virtualInlineOption ? createVirtualScrollback() : null;
+	let virtualScrollOffset = 0;
+	let searchState = createSearchState();
+	const focusManager = createFocusManager({ onFocusChange(oldNode, newNode, _origin) {
+		if (oldNode) dispatchFocusEvent(createFocusEvent("blur", oldNode, newNode));
+		if (newNode) dispatchFocusEvent(createFocusEvent("focus", newNode, oldNode));
+	} });
+	setOnNodeRemoved((removedNode) => focusManager.handleSubtreeRemoved(removedNode));
+	const cursorStore = createCursorStore();
+	const mouseEventState = createMouseEventProcessor({ focusManager });
+	const cleanup = () => {
+		if (cleanedUp) return;
+		cleanedUp = true;
+		logExitSummary();
+		try {
+			reconciler.updateContainerSync(null, fiberRoot, null, () => {});
+			reconciler.flushSyncWork();
+		} catch {}
+		setOnNodeRemoved(null);
+		if (storeUnsubscribeFn) storeUnsubscribeFn();
+		stateUnsubscribes.forEach((unsub) => {
+			try {
+				unsub();
+			} catch {}
+		});
+		if (outputGuard) {
+			outputGuard.dispose();
+			outputGuard = null;
+		}
+		if (!headless && stdin.isTTY) {
+			stdin.removeAllListeners("data");
+			stdin.pause();
+			const sequences = [
+				"\x1B[?1004l",
+				disableMouse(),
+				disableKittyKeyboard(),
+				"\x1B[?2004l",
+				"\x1B[0m",
+				resetCursorStyle(),
+				"\x1B[?25h",
+				alternateScreen ? "\x1B[?1049l" : ""
+			].join("");
+			if (stdout === process$1.stdout) {
+				try {
+					writeSync(stdout.fd, sequences);
+				} catch {
+					try {
+						stdout.write(sequences);
+					} catch {}
+				}
+				try {
+					stdin.resume();
+					while (stdin.read() !== null);
+					stdin.pause();
+				} catch {}
+			} else try {
+				stdout.write(sequences);
+			} catch {}
+			try {
+				stdin.setRawMode(false);
+			} catch {}
+		} else if (!headless) {
+			const sequences = [
+				"\x1B[?1004l",
+				disableMouse(),
+				disableKittyKeyboard(),
+				"\x1B[?2004l",
+				"\x1B[0m",
+				resetCursorStyle(),
+				"\x1B[?25h",
+				alternateScreen ? "\x1B[?1049l" : ""
+			].join("");
+			try {
+				stdout.write(sequences);
+			} catch {}
+		}
+		providerCleanups.forEach((fn) => {
+			try {
+				fn();
+			} catch {}
+		});
+		runtime[Symbol.dispose]();
+	};
+	let exit;
+	const container = createContainer(() => {
+		if (shouldExit) return;
+		if (inEventHandler) {
+			pendingRerender = true;
+			return;
+		}
+		if (!pendingRerender) {
+			pendingRerender = true;
+			queueMicrotask(() => {
+				if (!pendingRerender) return;
+				pendingRerender = false;
+				if (!shouldExit && !isRendering) {
+					isRendering = true;
+					try {
+						currentBuffer = doRender();
+						runtime.render(currentBuffer);
+					} finally {
+						isRendering = false;
+					}
+				}
+			});
+		}
+	});
+	const fiberRoot = createFiberRoot(container);
+	let currentBuffer;
+	const mockStdout = {
+		columns: cols,
+		rows,
+		write: () => true,
+		isTTY: false,
+		on: () => mockStdout,
+		off: () => mockStdout,
+		once: () => mockStdout,
+		removeListener: () => mockStdout,
+		addListener: () => mockStdout
+	};
+	const baseMockTerm = createTerm({ color: "truecolor" });
+	const mockTermSubscribers = /* @__PURE__ */ new Set();
+	const mockTerm = Object.create(baseMockTerm, {
+		getState: { value: () => currentDims },
+		subscribe: { value: (listener) => {
+			mockTermSubscribers.add(listener);
+			return () => mockTermSubscribers.delete(listener);
+		} }
+	});
+	const runtimeInputListeners = [];
+	const runtimePasteListeners = [];
+	const runtimeFocusListeners = [];
+	const runtimeEventListeners = /* @__PURE__ */ new Map();
+	runtimeEventListeners.set("input", runtimeInputListeners);
+	runtimeEventListeners.set("paste", runtimePasteListeners);
+	runtimeEventListeners.set("focus", runtimeFocusListeners);
+	const runtimeContextValue = {
+		on(event, handler) {
+			let listeners = runtimeEventListeners.get(event);
+			if (!listeners) {
+				listeners = [];
+				runtimeEventListeners.set(event, listeners);
+			}
+			listeners.push(handler);
+			return () => {
+				const idx = listeners.indexOf(handler);
+				if (idx >= 0) listeners.splice(idx, 1);
+			};
+		},
+		emit(event, ...args) {
+			const listeners = runtimeEventListeners.get(event);
+			if (listeners) for (const listener of listeners) listener(...args);
+		},
+		exit: () => exit()
+	};
+	const Root = RootComponent ?? React.Fragment;
+	const cacheBackend = !alternateScreen ? "terminal" : virtualInlineOption ? "virtual" : "retain";
+	const wrappedElement = /* @__PURE__ */ jsx(SilveryErrorBoundary, { children: /* @__PURE__ */ jsx(CursorProvider, {
+		store: cursorStore,
+		children: /* @__PURE__ */ jsx(CacheBackendContext.Provider, {
+			value: cacheBackend,
+			children: /* @__PURE__ */ jsx(TermContext.Provider, {
+				value: mockTerm,
+				children: /* @__PURE__ */ jsx(StdoutContext.Provider, {
+					value: {
+						stdout: mockStdout,
+						write: () => {},
+						notifyScrollback: (lines) => runtime.addScrollbackLines(lines),
+						promoteScrollback: (content, lines) => runtime.promoteScrollback(content, lines),
+						resetInlineCursor: () => runtime.resetInlineCursor(),
+						getInlineCursorRow: () => runtime.getInlineCursorRow()
+					},
+					children: /* @__PURE__ */ jsx(StderrContext.Provider, {
+						value: {
+							stderr: process$1.stderr,
+							write: (data) => {
+								process$1.stderr.write(data);
+							}
+						},
+						children: /* @__PURE__ */ jsx(FocusManagerContext.Provider, {
+							value: focusManager,
+							children: /* @__PURE__ */ jsx(RuntimeContext.Provider, {
+								value: runtimeContextValue,
+								children: /* @__PURE__ */ jsx(CapabilityRegistryContext.Provider, {
+									value: capabilityRegistry,
+									children: /* @__PURE__ */ jsx(Root, { children: /* @__PURE__ */ jsx(StoreContext.Provider, {
+										value: store,
+										children: element
+									}) })
+								})
+							})
+						})
+					})
+				})
+			})
+		})
+	}) });
+	let _renderCount = 0;
+	let _eventStart = 0;
+	const _perfLog = typeof process$1 !== "undefined" && process$1.env?.DEBUG?.includes("silvery:perf");
+	const _noIncremental = NO_INCREMENTAL;
+	let _ag = null;
+	let _lastTermBuffer = null;
+	function doRender() {
+		_renderCount++;
+		if (_ansiTrace) __require("node:fs").appendFileSync("/tmp/silvery-trace.log", `--- doRender #${_renderCount} (ag=${_ag ? "reuse" : "create"}, incremental=${!_noIncremental}) ---\n`);
+		const renderStart = performance.now();
+		reconciler.updateContainerSync(wrappedElement, fiberRoot, null, () => {});
+		reconciler.flushSyncWork();
+		const reconcileMs = performance.now() - renderStart;
+		{
+			const acc = globalThis.__silvery_bench_phases;
+			if (acc) acc.reconcile += reconcileMs;
+		}
+		const pipelineStart = performance.now();
+		const rootNode = getContainerRoot(container);
+		const dims = runtime.getDims();
+		const isInline = !alternateScreen;
+		if (!_ag) _ag = createAg(rootNode, { measurer: pipelineConfig?.measurer });
+		if (_ag) {
+			const lastBuffer = _lastTermBuffer;
+			if (lastBuffer) {
+				const widthChanged = dims.cols !== lastBuffer.width;
+				const heightChanged = !isInline && dims.rows !== lastBuffer.height;
+				if (widthChanged || heightChanged) {
+					_ag.resetBuffer();
+					runtime.invalidate();
+				}
+			}
+		}
+		if (INSTRUMENTED) {
+			globalThis.__silvery_content_all = void 0;
+			globalThis.__silvery_node_trace = void 0;
+			globalThis.__silvery_cell_debug = CELL_DEBUG !== null ? {
+				x: CELL_DEBUG.x,
+				y: CELL_DEBUG.y,
+				log: []
+			} : void 0;
+		}
+		const rootHasDirty = rootNode.layoutDirty || isAnyDirty(rootNode.dirtyBits, rootNode.dirtyEpoch);
+		const dimsChanged = _lastTermBuffer != null && (dims.cols !== _lastTermBuffer.width || dims.rows !== _lastTermBuffer.height);
+		if (!rootHasDirty && !dimsChanged && _lastTermBuffer && currentBuffer) return currentBuffer;
+		if (_noIncremental) _ag.resetBuffer();
+		_ag.layout(dims);
+		const { buffer: termBuffer, prevBuffer: agPrevBuffer } = _ag.render();
+		_lastTermBuffer = termBuffer;
+		const wasIncremental = !_noIncremental && agPrevBuffer !== null;
+		const pipelineMs = performance.now() - pipelineStart;
+		globalThis.__silvery_last_pipeline = {
+			layout: pipelineMs,
+			output: 0,
+			total: pipelineMs,
+			incremental: wasIncremental
+		};
+		globalThis.__silvery_render_count = (globalThis.__silvery_render_count ?? 0) + 1;
+		{
+			const acc = globalThis.__silvery_bench_phases;
+			if (acc) {
+				acc.total += pipelineMs;
+				acc.pipelineCalls += 1;
+			}
+		}
+		if (STRICT_MODE && wasIncremental) {
+			const { buffer: freshBuffer } = executeRender(rootNode, dims.cols, dims.rows, null, {
+				skipLayoutNotifications: true,
+				skipScrollStateUpdates: true
+			}, pipelineConfig);
+			const { cellEquals, bufferToText } = (init_buffer(), __toCommonJS(buffer_exports));
+			for (let y = 0; y < termBuffer.height; y++) for (let x = 0; x < termBuffer.width; x++) {
+				const a = termBuffer.getCell(x, y);
+				const b = freshBuffer.getCell(x, y);
+				if (!cellEquals(a, b)) {
+					let cellDebugInfo = "";
+					const savedCellDbg = globalThis.__silvery_cell_debug;
+					if (savedCellDbg && savedCellDbg.x === x && savedCellDbg.y === y && savedCellDbg.log.length > 0) cellDebugInfo = `\nCELL DEBUG (${savedCellDbg.log.length} entries for (${x},${y})):\n${savedCellDbg.log.join("\n")}\n`;
+					else if (savedCellDbg && savedCellDbg.x === x && savedCellDbg.y === y) cellDebugInfo = `\nCELL DEBUG: No nodes cover (${x},${y}) during incremental render\n`;
+					else cellDebugInfo = `\nCELL DEBUG: Target cell (${x},${y}) differs from debug cell (${savedCellDbg?.x},${savedCellDbg?.y})\n`;
+					let trapInfo = "";
+					const trap = {
+						x,
+						y,
+						log: []
+					};
+					globalThis.__silvery_write_trap = trap;
+					try {
+						executeRender(rootNode, dims.cols, dims.rows, null, {
+							skipLayoutNotifications: true,
+							skipScrollStateUpdates: true
+						}, pipelineConfig);
+					} catch {}
+					globalThis.__silvery_write_trap = null;
+					if (trap.log.length > 0) trapInfo = `\nWRITE TRAP (${trap.log.length} writes to (${x},${y})):\n${trap.log.join("\n")}\n`;
+					else trapInfo = `\nWRITE TRAP: NO WRITES to (${x},${y})\n`;
+					const incText = bufferToText(termBuffer);
+					const freshText = bufferToText(freshBuffer);
+					const cellStr = (c) => `char=${JSON.stringify(c.char)} fg=${c.fg} bg=${c.bg} ulColor=${c.underlineColor} wide=${c.wide} cont=${c.continuation} attrs={bold=${c.attrs.bold},dim=${c.attrs.dim},italic=${c.attrs.italic},ul=${c.attrs.underline},ulStyle=${c.attrs.underlineStyle},blink=${c.attrs.blink},inv=${c.attrs.inverse},hidden=${c.attrs.hidden},strike=${c.attrs.strikethrough}}`;
+					const contentAll = globalThis.__silvery_content_all;
+					const statsStr = contentAll ? `\n--- render phase stats (${contentAll.length} calls) ---\n` + contentAll.map((s, i) => `  #${i}: visited=${s.nodesVisited} rendered=${s.nodesRendered} skipped=${s.nodesSkipped} clearOps=${s.clearOps} cascade="${s.cascadeNodes}" flags={C=${s.flagContentDirty} P=${s.flagStylePropsDirty} L=${s.flagLayoutChanged} S=${s.flagSubtreeDirty} Ch=${s.flagChildrenDirty} CP=${s.flagChildPositionChanged} AL=${s.flagAncestorLayoutChanged} noPrev=${s.noPrevBuffer}} scroll={containers=${s.scrollContainerCount} cleared=${s.scrollViewportCleared} reason="${s.scrollClearReason}"} normalRepaint="${s.normalRepaintReason}" prevBuf={null=${s._prevBufferNull} dimMismatch=${s._prevBufferDimMismatch} hasPrev=${s._hasPrevBuffer} layout=${s._layoutW}x${s._layoutH} prev=${s._prevW}x${s._prevH}}`).join("\n") : "";
+					const msg = `SILVERY_STRICT (createApp): MISMATCH at (${x}, ${y}) on render #${_renderCount}\n  incremental: ${cellStr(a)}\n  fresh:       ${cellStr(b)}` + statsStr + (() => {
+						const traces = globalThis.__silvery_node_trace;
+						if (!traces || traces.length === 0) return "";
+						let out = "\n--- node trace ---";
+						for (let ti = 0; ti < traces.length; ti++) {
+							out += `\n  renderPhase #${ti}:`;
+							for (const t of traces[ti]) {
+								out += `\n    ${t.decision} ${t.id}(${t.type})@${t.depth} rect=${t.rect} prev=${t.prevLayout}`;
+								out += ` hasPrev=${t.hasPrev} ancClr=${t.ancestorCleared} flags=[${t.flags}] layout∆=${t.layoutChanged}`;
+								if (t.decision === "RENDER") {
+									out += ` caa=${t.contentAreaAffected} crc=${t.contentRegionCleared} cnfr=${t.childrenNeedFreshRender}`;
+									out += ` childPrev=${t.childHasPrev} childAnc=${t.childAncestorCleared} skipBg=${t.skipBgFill} bg=${t.bgColor ?? "none"}`;
+								}
+							}
+						}
+						return out;
+					})() + cellDebugInfo + trapInfo + `\n--- incremental ---\n${incText}\n--- fresh ---\n${freshText}`;
+					__require("node:fs").appendFileSync("/tmp/silvery-perf.log", msg + "\n");
+					throw new IncrementalRenderMismatchError(msg);
+				}
+			}
+			if (_perfLog) __require("node:fs").appendFileSync("/tmp/silvery-perf.log", `SILVERY_STRICT (createApp): render #${_renderCount} OK\n`);
+		}
+		const buf = createBuffer(termBuffer, rootNode);
+		if (_perfLog) {
+			const renderDuration = performance.now() - renderStart;
+			const phases = globalThis.__silvery_last_pipeline;
+			const detail = globalThis.__silvery_content_detail;
+			const phaseStr = phases ? ` [measure=${phases.measure.toFixed(1)} layout=${phases.layout.toFixed(1)} content=${phases.content.toFixed(1)} output=${phases.output.toFixed(1)}]` : "";
+			const detailStr = detail ? ` {visited=${detail.nodesVisited} rendered=${detail.nodesRendered} skipped=${detail.nodesSkipped} noPrev=${detail.noPrevBuffer ?? 0} dirty=${detail.flagContentDirty ?? 0} paint=${detail.flagStylePropsDirty ?? 0} layoutChg=${detail.flagLayoutChanged ?? 0} subtree=${detail.flagSubtreeDirty ?? 0} children=${detail.flagChildrenDirty ?? 0} childPos=${detail.flagChildPositionChanged ?? 0} scroll=${detail.scrollContainerCount ?? 0}/${detail.scrollViewportCleared ?? 0}${detail.scrollClearReason ? `(${detail.scrollClearReason})` : ""}}${detail.cascadeNodes ? ` CASCADE[minDepth=${detail.cascadeMinDepth} ${detail.cascadeNodes}]` : ""}` : "";
+			__require("node:fs").appendFileSync("/tmp/silvery-perf.log", `doRender #${_renderCount}: ${renderDuration.toFixed(1)}ms (reconcile=${reconcileMs.toFixed(1)}ms pipeline=${pipelineMs.toFixed(1)}ms ${dims.cols}x${dims.rows})${phaseStr}${detailStr}\n`);
+		}
+		return buf;
+	}
+	if (_ansiTrace) __require("node:fs").appendFileSync("/tmp/silvery-trace.log", "=== INITIAL RENDER ===\n");
+	currentBuffer = doRender();
+	if (!headless) {
+		if (_ansiTrace) __require("node:fs").appendFileSync("/tmp/silvery-trace.log", "=== ALT SCREEN + CLEAR ===\n");
+		if (alternateScreen) {
+			stdout.write("\x1B[?1049h");
+			stdout.write("\x1B[2J\x1B[H");
+		}
+		stdout.write("\x1B[?25l");
+		if (kittyOption != null && kittyOption !== false) if (kittyOption === true) {
+			if ((await detectKittyFromStdio(stdout, stdin)).supported) {
+				stdout.write(enableKittyKeyboard(defaultKittyFlags));
+				kittyEnabled = true;
+				kittyFlags = defaultKittyFlags;
+			}
+		} else {
+			stdout.write(enableKittyKeyboard(kittyOption));
+			kittyEnabled = true;
+			kittyFlags = kittyOption;
+		}
+		else if (kittyOption == null) {
+			stdout.write(enableKittyKeyboard(defaultKittyFlags));
+			kittyEnabled = true;
+			kittyFlags = defaultKittyFlags;
+		}
+		if (mouseOption) {
+			stdout.write(enableMouse());
+			mouseEnabled = true;
+		}
+	}
+	if (_ansiTrace) __require("node:fs").appendFileSync("/tmp/silvery-trace.log", "=== RUNTIME.RENDER (initial) ===\n");
+	runtime.render(currentBuffer);
+	if (_perfLog) __require("node:fs").appendFileSync("/tmp/silvery-perf.log", `STARTUP: initial render done (render #${_renderCount}, incremental=${!_noIncremental})\n`);
+	if (shouldGuardOutput) outputGuard = createOutputGuard();
+	if (!headless) {
+		runtimeContextValue.pause = () => {
+			renderPaused = true;
+			if (outputGuard) {
+				outputGuard.dispose();
+				outputGuard = null;
+			}
+			if (alternateScreen) stdout.write(leaveAlternateScreen());
+		};
+		runtimeContextValue.resume = () => {
+			if (alternateScreen) stdout.write(enterAlternateScreen());
+			renderPaused = false;
+			if (shouldGuardOutput && !outputGuard) outputGuard = createOutputGuard();
+			runtime.invalidate();
+			_ag?.resetBuffer();
+			if (!isRendering) {
+				currentBuffer = doRender();
+				runtime.render(currentBuffer);
+			}
+		};
+	}
+	let exitResolve;
+	let exitResolved = false;
+	const exitPromise = new Promise((resolve) => {
+		exitResolve = () => {
+			if (!exitResolved) {
+				exitResolved = true;
+				resolve();
+			}
+		};
+	});
+	exit = () => {
+		if (shouldExit) return;
+		shouldExit = true;
+		if (!headless && stdout.isTTY) {
+			const earlyDisable = [
+				disableKittyKeyboard(),
+				disableMouse(),
+				"\x1B[?1004l"
+			].join("");
+			try {
+				writeSync(stdout.fd, earlyDisable);
+			} catch {
+				try {
+					stdout.write(earlyDisable);
+				} catch {}
+			}
+		}
+		controller.abort();
+		if (!inEventHandler) {
+			cleanup();
+			exitResolve();
+		}
+	};
+	runtimeContextValue.exit = exit;
+	let frameResolve = null;
+	let framesDone = false;
+	function emitFrame(buf) {
+		if (frameResolve) {
+			const resolve = frameResolve;
+			frameResolve = null;
+			resolve(buf);
+		}
+	}
+	storeUnsubscribeFn = store.subscribe(() => {
+		if (shouldExit) return;
+		if (_ansiTrace) {
+			const _case = inEventHandler ? "1:event" : isRendering ? "2:rendering" : "3:standalone";
+			const stack = (/* @__PURE__ */ new Error()).stack?.split("\n").slice(1, 5).join("\n") ?? "";
+			__require("node:fs").appendFileSync("/tmp/silvery-trace.log", `=== SUBSCRIPTION (case ${_case}, render #${_renderCount + 1}) ===\n${stack}\n`);
+		}
+		if (inEventHandler) {
+			pendingRerender = true;
+			return;
+		}
+		if (isRendering) {
+			if (!pendingRerender) {
+				pendingRerender = true;
+				queueMicrotask(() => {
+					if (!pendingRerender) return;
+					pendingRerender = false;
+					if (!shouldExit && !isRendering) {
+						if (_perfLog) __require("node:fs").appendFileSync("/tmp/silvery-perf.log", `SUBSCRIPTION: deferred microtask render (case 2, render #${_renderCount + 1})\n`);
+						isRendering = true;
+						try {
+							currentBuffer = doRender();
+							runtime.render(currentBuffer);
+						} finally {
+							isRendering = false;
+						}
+					}
+				});
+			}
+			return;
+		}
+		if (_perfLog) __require("node:fs").appendFileSync("/tmp/silvery-perf.log", `SUBSCRIPTION: immediate render (case 3, render #${_renderCount + 1})\n`);
+		isRendering = true;
+		try {
+			currentBuffer = doRender();
+			runtime.render(currentBuffer);
+		} finally {
+			isRendering = false;
+		}
+	});
+	function createProviderEventStream(name, provider) {
+		return map(provider.events(), (event) => ({
+			type: `${name}:${String(event.type)}`,
+			provider: name,
+			event: String(event.type),
+			data: event.data
+		}));
+	}
+	/**
+	* Write selection overlay to stdout after a render.
+	* Appends inverse-video ANSI sequences over selected cells.
+	*/
+	function writeSelectionOverlay() {
+		if (!selectionEnabled || !selectionState.range || !currentBuffer) return;
+		const mode = alternateScreen ? "fullscreen" : "inline";
+		const overlay = renderSelectionOverlay(selectionState.range, currentBuffer._buffer, mode, selectionState.scope);
+		if (overlay) target.write(overlay);
+	}
+	/**
+	* Push the current rendered frame to the virtual scrollback buffer.
+	*/
+	function pushToScrollback() {
+		if (!scrollback || !currentBuffer) return;
+		const lines = currentBuffer.text.split("\n");
+		scrollback.push(lines);
+	}
+	/**
+	* Render the virtual scrollback view (historical content) to the terminal.
+	* When scrolled up, replaces the live app content with historical rows.
+	*/
+	function renderVirtualScrollbackView() {
+		if (!scrollback || virtualScrollOffset <= 0) return;
+		const dims = target.getDims();
+		const rows = scrollback.getVisibleRows(virtualScrollOffset, dims.rows);
+		let out = "";
+		for (let row = 0; row < rows.length; row++) out += `\x1b[${row + 1};1H\x1b[2K${rows[row] ?? ""}`;
+		const indicator = ` ↑ ${virtualScrollOffset} lines `;
+		const indicatorCol = Math.max(1, dims.cols - indicator.length + 1);
+		out += `\x1b[1;${indicatorCol}H\x1b[7m${indicator}\x1b[27m`;
+		target.write(out);
+	}
+	/**
+	* Render search highlights for the current match with inverse video.
+	*/
+	function renderSearchHighlights() {
+		if (!searchState.active || searchState.currentMatch < 0) return;
+		const match = searchState.matches[searchState.currentMatch];
+		if (!match) return;
+		const dims = target.getDims();
+		let screenRow;
+		if (scrollback && virtualScrollOffset > 0) {
+			const firstVisibleLine = scrollback.totalLines - virtualScrollOffset - dims.rows;
+			screenRow = match.row - firstVisibleLine;
+		} else screenRow = match.row;
+		if (screenRow < 0 || screenRow >= dims.rows) return;
+		let out = `\x1b[${screenRow + 1};${match.startCol + 1}H\x1b[7m`;
+		for (let col = match.startCol; col <= match.endCol; col++) if (currentBuffer && virtualScrollOffset <= 0) out += currentBuffer._buffer.getCell(col, screenRow).char;
+		else out += searchState.query[col - match.startCol] ?? " ";
+		out += "\x1B[27m";
+		target.write(out);
+	}
+	/**
+	* Render the search bar at the bottom of the screen.
+	*/
+	function renderSearchBarOverlay() {
+		if (!searchState.active) return;
+		const dims = target.getDims();
+		const bar = renderSearchBar(searchState, dims.cols);
+		target.write(`\x1b[${dims.rows};1H${bar}`);
+	}
+	/**
+	* Search function for virtual scrollback — converts line matches to SearchMatch[].
+	*/
+	function searchScrollback(query) {
+		if (!scrollback || !query) return [];
+		const matchingLines = scrollback.search(query);
+		const lowerQuery = query.toLowerCase();
+		const matches = [];
+		for (const lineIdx of matchingLines) {
+			const plain = (scrollback.getVisibleRows(scrollback.totalLines - lineIdx - 1, 1)[0] ?? "").replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+			let col = plain.toLowerCase().indexOf(lowerQuery);
+			while (col !== -1) {
+				matches.push({
+					row: lineIdx,
+					startCol: col,
+					endCol: col + query.length - 1
+				});
+				col = plain.toLowerCase().indexOf(lowerQuery, col + 1);
+			}
+		}
+		return matches;
+	}
+	/**
+	* Run a single event's handler (state mutation only, no render).
+	* Returns true if processing should continue, false if app should exit.
+	*
+	* Intercepts mouse events for selection and virtual inline mode.
+	*/
+	function runEventHandler(event) {
+		if (scrollback && searchState.active && event.type === "term:key") {
+			const data = event.data;
+			if (data.key.escape) {
+				const [next] = searchUpdate({ type: "close" }, searchState);
+				searchState = next;
+				virtualScrollOffset = 0;
+				return true;
+			}
+			if (data.key.return && !data.key.shift) {
+				const [next, effects] = searchUpdate({ type: "nextMatch" }, searchState, searchScrollback);
+				searchState = next;
+				for (const eff of effects) if (eff.type === "scrollTo") virtualScrollOffset = Math.max(0, scrollback.totalLines - eff.row - target.getDims().rows);
+				return true;
+			}
+			if (data.key.return && data.key.shift) {
+				const [next, effects] = searchUpdate({ type: "prevMatch" }, searchState, searchScrollback);
+				searchState = next;
+				for (const eff of effects) if (eff.type === "scrollTo") virtualScrollOffset = Math.max(0, scrollback.totalLines - eff.row - target.getDims().rows);
+				return true;
+			}
+			if (data.key.backspace) {
+				const [next, effects] = searchUpdate({ type: "backspace" }, searchState, searchScrollback);
+				searchState = next;
+				for (const eff of effects) if (eff.type === "scrollTo") virtualScrollOffset = Math.max(0, scrollback.totalLines - eff.row - target.getDims().rows);
+				return true;
+			}
+			if (data.key.leftArrow) {
+				const [next] = searchUpdate({ type: "cursorLeft" }, searchState);
+				searchState = next;
+				return true;
+			}
+			if (data.key.rightArrow) {
+				const [next] = searchUpdate({ type: "cursorRight" }, searchState);
+				searchState = next;
+				return true;
+			}
+			if (data.input && !data.key.ctrl && !data.key.meta) {
+				const [next, effects] = searchUpdate({
+					type: "input",
+					char: data.input
+				}, searchState, searchScrollback);
+				searchState = next;
+				for (const eff of effects) if (eff.type === "scrollTo") virtualScrollOffset = Math.max(0, scrollback.totalLines - eff.row - target.getDims().rows);
+				return true;
+			}
+		}
+		if (scrollback && event.type === "term:key") {
+			const data = event.data;
+			if (data.input === "f" && data.key.ctrl) {
+				const [next] = searchUpdate({ type: "open" }, searchState);
+				searchState = next;
+				return true;
+			}
+		}
+		if (scrollback && event.event === "mouse" && event.data) {
+			const mouseData = event.data;
+			if (mouseData.action === "wheel") {
+				const scrollLines = 3;
+				if (mouseData.delta && mouseData.delta < 0) virtualScrollOffset = Math.min(virtualScrollOffset + scrollLines, Math.max(0, scrollback.totalLines - target.getDims().rows));
+				else virtualScrollOffset = Math.max(0, virtualScrollOffset - scrollLines);
+				return true;
+			}
+		}
+		if (selectionEnabled && event.event === "mouse" && event.data) {
+			const mouseData = event.data;
+			if (mouseData.button === 0) {
+				if (mouseData.action === "down") {
+					if (selectionState.range) {
+						const [cleared] = terminalSelectionUpdate({ type: "clear" }, selectionState);
+						selectionState = cleared;
+					}
+					const agRoot = getContainerRoot(container);
+					const hit = agRoot ? selectionHitTest(agRoot, mouseData.x, mouseData.y) : null;
+					const scope = hit ? findContainBoundary(hit) : null;
+					const [next] = terminalSelectionUpdate({
+						type: "start",
+						col: mouseData.x,
+						row: mouseData.y,
+						scope
+					}, selectionState);
+					selectionState = next;
+					notifySelectionListeners();
+					if (currentBuffer) {
+						runtime.invalidate();
+						currentBuffer = doRender();
+						runtime.render(currentBuffer);
+						writeSelectionOverlay();
+					}
+				} else if (mouseData.action === "move" && selectionState.selecting) {
+					const [next] = terminalSelectionUpdate({
+						type: "extend",
+						col: mouseData.x,
+						row: mouseData.y
+					}, selectionState);
+					selectionState = next;
+					notifySelectionListeners();
+					if (currentBuffer) {
+						runtime.render(currentBuffer);
+						writeSelectionOverlay();
+					}
+					return true;
+				} else if (mouseData.action === "up" && selectionState.selecting) {
+					const [next] = terminalSelectionUpdate({ type: "finish" }, selectionState);
+					selectionState = next;
+					notifySelectionListeners();
+					if (next.range && currentBuffer) {
+						const text = extractText(currentBuffer._buffer, next.range, { scope: next.scope });
+						if (text.length > 0) {
+							const base64 = globalThis.Buffer.from(text).toString("base64");
+							target.write(`\x1b]52;c;${base64}\x07`);
+						}
+					}
+					if (currentBuffer) {
+						runtime.render(currentBuffer);
+						writeSelectionOverlay();
+					}
+				}
+			}
+		}
+		if (selectionEnabled && event.type === "term:key" && selectionState.range) {
+			const [next] = terminalSelectionUpdate({ type: "clear" }, selectionState);
+			selectionState = next;
+			notifySelectionListeners();
+			if (currentBuffer) {
+				runtime.invalidate();
+				currentBuffer = doRender();
+				runtime.render(currentBuffer);
+			}
+		}
+		if (scrollback && virtualScrollOffset > 0 && event.type === "term:key") {
+			virtualScrollOffset = 0;
+			return true;
+		}
+		return invokeEventHandler(event, handlers, createHandlerContext(store, focusManager, container), mouseEventState, container);
+	}
+	/**
+	* Process a batch of events — run all handlers, then render once.
+	*
+	* This is the key optimization for press-and-hold / auto-repeat keys.
+	* When events arrive faster than renders (e.g., 30/sec auto-repeat vs
+	* 50ms renders), we batch all pending handlers into a single render pass.
+	*
+	* For a batch of 3 'j' presses: handler1 → handler2 → handler3 → render.
+	* The cursor moves 3 positions, but we only pay one render cost.
+	*/
+	async function processEventBatch(events) {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			if (shouldExit || events.length === 0) return null;
+			_renderCount = 0;
+			_eventStart = performance.now();
+			const _perfSpan = _usingCtx$1.u(perfLog.span?.("keypress", (() => {
+				startTracking();
+				const keyEvents = events.filter((e) => e.type === "term:key");
+				return { key: keyEvents.length > 0 ? keyEvents.map((e) => e.data.input).join(",") : events[0]?.type ?? "unknown" };
+			})()));
+			if (!headless) {
+				for (let i = events.length - 1; i >= 0; i--) {
+					const event = events[i];
+					if (event.type !== "term:key") continue;
+					const data = event.data;
+					if (data.input === "z" && data.key.ctrl && suspendOption) if (!(onSuspendHook?.() === false)) {
+						events.splice(i, 1);
+						performSuspend(captureTerminalState({
+							alternateScreen,
+							cursorHidden: true,
+							mouse: mouseEnabled,
+							kitty: kittyEnabled,
+							kittyFlags,
+							bracketedPaste: true,
+							rawMode: true,
+							focusReporting: focusReportingEnabled
+						}), stdout, stdin, () => {
+							runtime.invalidate();
+							onResumeHook?.();
+						});
+					} else events.splice(i, 1);
+					if (data.input === "c" && data.key.ctrl && exitOnCtrlCOption) {
+						if (!(onInterruptHook?.() === false)) {
+							exit();
+							return null;
+						}
+						events.splice(i, 1);
+					}
+				}
+				if (events.length === 0) return null;
+			}
+			inEventHandler = true;
+			isRendering = true;
+			for (const event of events) {
+				if (event.type === "term:key") {
+					const { input, key: parsedKey } = event.data;
+					updateKeyboardModifiers(mouseEventState, parsedKey);
+					if (parsedKey.eventType === "release" || isModifierOnlyEvent(input, parsedKey)) {
+						for (const listener of runtimeInputListeners) listener(input, parsedKey);
+						if (shouldExit) {
+							inEventHandler = false;
+							return null;
+						}
+						continue;
+					}
+					let focusConsumed = false;
+					if (focusManager.activeElement) focusConsumed = handleFocusNavigation(input, parsedKey, focusManager, container) === "consumed";
+					if (!focusConsumed) for (const listener of runtimeInputListeners) listener(input, parsedKey);
+				} else if (event.type === "term:paste") {
+					const { text } = event.data;
+					for (const listener of runtimePasteListeners) listener(text);
+				} else if (event.type === "term:focus") {
+					const { focused } = event.data;
+					for (const listener of runtimeFocusListeners) listener(focused);
+				}
+				if (shouldExit) {
+					inEventHandler = false;
+					return null;
+				}
+				if (event.type === "term:key") {
+					const { input, key: k } = event.data;
+					if (k.eventType === "release") continue;
+					if (isModifierOnlyEvent(input, k)) continue;
+				}
+				const result = runEventHandler(event);
+				if (result === false) {
+					isRendering = false;
+					inEventHandler = false;
+					exit();
+					return null;
+				}
+				if (result === "flush") {
+					pendingRerender = false;
+					currentBuffer = doRender();
+					runtime.render(currentBuffer);
+					await Promise.resolve();
+					if (pendingRerender) {
+						pendingRerender = false;
+						currentBuffer = doRender();
+						runtime.render(currentBuffer);
+					}
+				}
+			}
+			pendingRerender = false;
+			try {
+				currentBuffer = doRender();
+			} finally {
+				isRendering = false;
+			}
+			let flushCount = 0;
+			const maxFlushes = 5;
+			while (flushCount < maxFlushes) {
+				await Promise.resolve();
+				if (!pendingRerender) break;
+				pendingRerender = false;
+				isRendering = true;
+				try {
+					currentBuffer = doRender();
+				} finally {
+					isRendering = false;
+				}
+				flushCount++;
+			}
+			currentBuffer._buffer.markAllRowsDirty();
+			inEventHandler = false;
+			const runtimeStart = performance.now();
+			runtime.render(currentBuffer);
+			pushToScrollback();
+			if (virtualScrollOffset > 0) renderVirtualScrollbackView();
+			writeSelectionOverlay();
+			renderSearchHighlights();
+			renderSearchBarOverlay();
+			const runtimeMs = performance.now() - runtimeStart;
+			if (_perfLog) {
+				const totalMs = performance.now() - _eventStart;
+				__require("node:fs").appendFileSync("/tmp/silvery-perf.log", `EVENT batch(${events.length} ${events[0]?.type}): ${totalMs.toFixed(1)}ms total, ${_renderCount} doRender() calls, runtime.render=${runtimeMs.toFixed(1)}ms\n---\n`);
+			}
+			if (_perfSpan) checkBudget(events[0]?.type ?? "batch", performance.now() - _eventStart);
+			return currentBuffer;
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
+	}
+	const eventQueue = [];
+	let eventQueueResolve = null;
+	const eventLoop = async () => {
+		const allEvents = merge(...Object.entries(providers).map(([name, provider]) => createProviderEventStream(name, provider)));
+		const pumpEvents = async () => {
+			try {
+				for await (const event of takeUntil(allEvents, signal)) {
+					eventQueue.push(event);
+					if (eventQueueResolve) {
+						const resolve = eventQueueResolve;
+						eventQueueResolve = null;
+						resolve();
+					}
+					if (shouldExit) break;
+				}
+			} finally {
+				if (eventQueueResolve) {
+					const resolve = eventQueueResolve;
+					eventQueueResolve = null;
+					resolve();
+				}
+			}
+		};
+		if (needsProbe) try {
+			const wasRaw = stdin.isRaw;
+			if (stdin.isTTY && !wasRaw) {
+				stdin.setRawMode(true);
+				stdin.resume();
+				stdin.setEncoding("utf8");
+			}
+			const probeRead = () => new Promise((resolve) => {
+				const onData = (data) => {
+					stdin.off("data", onData);
+					resolve(data);
+				};
+				stdin.on("data", onData);
+			});
+			const probeResult = await detectTextSizingSupport((data) => outputGuard ? outputGuard.writeStdout(data) : stdout.write(data), probeRead, 500);
+			if (probeResult.supported !== textSizingEnabled) {
+				textSizingEnabled = probeResult.supported;
+				if (effectiveCaps) {
+					effectiveCaps = {
+						...effectiveCaps,
+						textSizingSupported: textSizingEnabled
+					};
+					pipelineConfig = createPipeline({ caps: effectiveCaps });
+					runtime.setOutputPhaseFn(pipelineConfig.outputPhaseFn);
+				}
+				_ag = null;
+				runtime.invalidate();
+				if (!isRendering) {
+					isRendering = true;
+					try {
+						currentBuffer = doRender();
+						runtime.render(currentBuffer);
+					} finally {
+						isRendering = false;
+					}
+				}
+			}
+			if (stdin.isTTY && !wasRaw) {
+				stdin.setRawMode(false);
+				stdin.pause();
+			}
+		} catch {}
+		if (needsWidthDetection) try {
+			const wasRaw = stdin.isRaw;
+			if (stdin.isTTY && !wasRaw) {
+				stdin.setRawMode(true);
+				stdin.resume();
+				stdin.setEncoding("utf8");
+			}
+			const stdinHandlers = [];
+			const stdinListener = (data) => {
+				for (const handler of stdinHandlers) handler(data);
+			};
+			stdin.on("data", stdinListener);
+			const detector = createWidthDetector({
+				write: (data) => outputGuard ? outputGuard.writeStdout(data) : stdout.write(data),
+				onData: (handler) => {
+					stdinHandlers.push(handler);
+					return () => {
+						const idx = stdinHandlers.indexOf(handler);
+						if (idx >= 0) stdinHandlers.splice(idx, 1);
+					};
+				},
+				timeoutMs: 200
+			});
+			const widthConfig = await detector.detect();
+			detector.dispose();
+			stdin.off("data", stdinListener);
+			if (effectiveCaps) {
+				const updatedCaps = applyWidthConfig(effectiveCaps, widthConfig);
+				if (updatedCaps.textEmojiWide !== effectiveCaps.textEmojiWide || updatedCaps.textSizingSupported !== effectiveCaps.textSizingSupported) {
+					effectiveCaps = updatedCaps;
+					pipelineConfig = createPipeline({ caps: effectiveCaps });
+					runtime.setOutputPhaseFn(pipelineConfig.outputPhaseFn);
+					_ag = null;
+					runtime.invalidate();
+					if (!isRendering) {
+						isRendering = true;
+						try {
+							currentBuffer = doRender();
+							runtime.render(currentBuffer);
+						} finally {
+							isRendering = false;
+						}
+					}
+				}
+			}
+			if (stdin.isTTY && !wasRaw) {
+				stdin.setRawMode(false);
+				stdin.pause();
+			}
+		} catch {}
+		pumpEvents().catch((err) => log.error?.(`pumpEvents failed: ${err}`));
+		if (focusReportingOption && !focusReportingEnabled) {
+			enableFocusReporting((s) => outputGuard ? outputGuard.writeStdout(s) : stdout.write(s));
+			focusReportingEnabled = true;
+		}
+		try {
+			while (!shouldExit && !signal.aborted) {
+				if (eventQueue.length === 0) await new Promise((resolve) => {
+					eventQueueResolve = resolve;
+					signal.addEventListener("abort", () => resolve(), { once: true });
+				});
+				if (shouldExit || signal.aborted) break;
+				if (eventQueue.length === 0) continue;
+				const maxDrainSpins = 32;
+				let drainSpins = 0;
+				const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+				await yieldToEventLoop();
+				let prevLen = eventQueue.length;
+				while (drainSpins < maxDrainSpins) {
+					await yieldToEventLoop();
+					const curLen = eventQueue.length;
+					if (curLen === prevLen) break;
+					prevLen = curLen;
+					drainSpins++;
+				}
+				if (_perfLog) __require("node:fs").appendFileSync("/tmp/silvery-perf.log", `DRAIN: spins=${drainSpins}, batch=${eventQueue.length}\n`);
+				const _g = globalThis;
+				_g.__silvery_last_drain_spins = drainSpins;
+				_g.__silvery_last_batch_size = eventQueue.length;
+				_g.__silvery_batch_count = (_g.__silvery_batch_count ?? 0) + 1;
+				const buf = await processEventBatch(eventQueue.splice(0));
+				if (buf) emitFrame(buf);
+			}
+		} finally {
+			framesDone = true;
+			if (frameResolve) {
+				const resolve = frameResolve;
+				frameResolve = null;
+				resolve(null);
+			}
+			if (shouldExit && !cleanedUp && !headless && stdin.isTTY) try {
+				stdin.removeAllListeners("data");
+				stdin.resume();
+				await new Promise((resolve) => setTimeout(resolve, 15));
+				while (stdin.read() !== null);
+				stdin.pause();
+			} catch {}
+			cleanup();
+			exitResolve();
+		}
+	};
+	eventLoop().catch((err) => log.error?.(`eventLoop failed: ${err}`));
+	return {
+		get text() {
+			return currentBuffer.text;
+		},
+		get root() {
+			return getContainerRoot(container);
+		},
+		get buffer() {
+			return currentBuffer?._buffer ?? null;
+		},
+		get store() {
+			return store;
+		},
+		waitUntilExit() {
+			return exitPromise;
+		},
+		unmount() {
+			exit();
+		},
+		[Symbol.dispose]() {
+			exit();
+		},
+		async press(rawKey) {
+			try {
+				var _usingCtx3 = _usingCtx();
+				const pressStart = performance.now();
+				const [input, parsedKey] = parseKey(useKittyMode ? keyToKittyAnsi(rawKey) : keyToAnsi(rawKey));
+				const _perfSpan = _usingCtx3.u(perfLog.span?.("keypress", (() => {
+					startTracking();
+					return { key: input || rawKey };
+				})()));
+				if (input === "c" && parsedKey.ctrl && exitOnCtrlCOption) {
+					if (!(onInterruptHook?.() === false)) {
+						exit();
+						return;
+					}
+				}
+				for (const listener of runtimeInputListeners) listener(input, parsedKey);
+				inEventHandler = true;
+				isRendering = true;
+				if (handleFocusNavigation(input, parsedKey, focusManager, container) === "consumed") {
+					pendingRerender = false;
+					isRendering = false;
+					inEventHandler = false;
+					doRender();
+					await Promise.resolve();
+					if (_perfSpan) checkBudget(input || rawKey, performance.now() - pressStart);
+					return;
+				}
+				if (dispatchKeyToHandlers(input, parsedKey, handlers, createHandlerContext(store, focusManager, container)) === "exit") {
+					isRendering = false;
+					inEventHandler = false;
+					exit();
+					return;
+				}
+				pendingRerender = false;
+				try {
+					currentBuffer = doRender();
+				} finally {
+					isRendering = false;
+				}
+				let flushCount = 0;
+				const maxFlushes = 5;
+				while (flushCount < maxFlushes) {
+					await Promise.resolve();
+					if (!pendingRerender) break;
+					pendingRerender = false;
+					isRendering = true;
+					try {
+						currentBuffer = doRender();
+					} finally {
+						isRendering = false;
+					}
+					flushCount++;
+				}
+				if (flushCount > 0) currentBuffer._buffer.markAllRowsDirty();
+				inEventHandler = false;
+				runtime.render(currentBuffer);
+				if (_perfSpan) checkBudget(input || rawKey, performance.now() - pressStart);
+			} catch (_) {
+				_usingCtx3.e = _;
+			} finally {
+				_usingCtx3.d();
+			}
+		},
+		[Symbol.asyncIterator]() {
+			return {
+				async next() {
+					if (framesDone || shouldExit) return {
+						done: true,
+						value: void 0
+					};
+					const buf = await new Promise((resolve) => {
+						if (framesDone || shouldExit) {
+							resolve(null);
+							return;
+						}
+						frameResolve = resolve;
+					});
+					if (!buf) return {
+						done: true,
+						value: void 0
+					};
+					return {
+						done: false,
+						value: buf
+					};
+				},
+				async return() {
+					exit();
+					return {
+						done: true,
+						value: void 0
+					};
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region ../packages/ag-term/src/runtime/run.tsx
+init_detect();
+init_ThemeContext();
+//#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/ag-react/src/with-react.ts
+/**
+* Associate a React element with an app for rendering.
+*
+* In pipe() composition, this captures the element so that subsequent
+* plugins and the final run() know what to render.
+*
+* The plugin wraps `run()` to automatically pass the element:
+* - Before: `app.run(<Board />, options)`
+* - After: `app.run()` (element already bound)
+*
+* @param element - The React element to render
+* @returns Plugin function that binds the element to the app
+*/
+function withReact(element) {
+	return (app) => {
+		const originalRun = app.run;
+		return Object.assign(Object.create(app), {
+			element,
+			run(...args) {
+				if (args.length === 0 || typeof args[0] !== "object" || args[0] === null || !("type" in args[0])) return originalRun.call(app, element, ...args);
+				return originalRun.apply(app, args);
+			}
+		});
+	};
+}
+//#endregion
+//#region ../packages/ag-term/src/features/clipboard-capability.ts
+/**
+* Create an OSC 52 clipboard capability.
+*
+* Encodes text as base64 and writes the OSC 52 sequence directly.
+* This is a standalone factory that doesn't require the full ClipboardBackend.
+*/
+function createOSC52Clipboard(write) {
+	return { copy(text) {
+		write(`\x1b]52;c;${Buffer.from(text, "utf-8").toString("base64")}\x07`);
+	} };
+}
+//#endregion
+//#region ../packages/ag-term/src/plugins/with-terminal.ts
+/**
+* withTerminal(process, opts?) — Plugin: ALL terminal I/O
+*
+* This plugin represents the terminal I/O layer in silvery's plugin
+* composition model. It wraps all terminal concerns:
+* - stdin → typed events (term:key, term:mouse, term:paste)
+* - stdout → alternate screen, raw mode, incremental diff output
+* - SIGWINCH → term:resize
+* - Lifecycle (Ctrl+Z suspend/resume, Ctrl+C exit)
+* - Protocols (SGR mouse, Kitty keyboard, bracketed paste)
+*
+* In the current architecture, terminal I/O is handled by createApp()
+* and the TermProvider. This plugin provides the declarative interface
+* for pipe() composition:
+*
+* ```tsx
+* const app = pipe(
+*   createApp(store),
+*   withReact(<Board />),
+*   withTerminal(process, { mouse: true, kitty: true }),
+*   withFocus(),
+*   withDomEvents(),
+* )
+* ```
+*
+* @example
+* ```tsx
+* import { pipe, withTerminal } from '@silvery/create'
+*
+* // All protocols enabled by default
+* const app = pipe(baseApp, withTerminal(process))
+*
+* // Customize terminal options
+* const app = pipe(baseApp, withTerminal(process, {
+*   mouse: true,
+*   kitty: true,
+*   paste: true,
+*   onSuspend: () => saveState(),
+*   onResume: () => restoreState(),
+* }))
+* ```
+*/
+/**
+* Configure terminal I/O for an app.
+*
+* In pipe() composition, this captures the process streams and options
+* so that run() configures terminal I/O correctly.
+*
+* The plugin wraps `run()` to inject terminal options:
+* - stdin/stdout from the process object
+* - Protocol options (mouse, kitty, paste)
+* - Lifecycle handlers (suspend, resume, interrupt)
+*
+* @param proc - Process object with stdin/stdout (typically `process`)
+* @param options - Terminal configuration
+* @returns Plugin function that binds terminal config to the app
+*/
+function withTerminal(proc, options = {}) {
+	const termConfig = {
+		mouse: options.mouse ?? true,
+		kitty: options.kitty ?? true,
+		paste: options.paste ?? true,
+		alternateScreen: options.alternateScreen ?? true,
+		suspendOnCtrlZ: options.suspendOnCtrlZ ?? true,
+		exitOnCtrlC: options.exitOnCtrlC ?? true,
+		...options,
+		proc
+	};
+	return (app) => {
+		const originalRun = app.run;
+		const registry = app.capabilityRegistry ?? createCapabilityRegistry();
+		const clipboard = createOSC52Clipboard((data) => {
+			proc.stdout.write(data);
+		});
+		registry.register(CLIPBOARD_CAPABILITY, clipboard);
+		const autoDetect = termConfig.autoDetect ?? false;
+		const timeoutMs = termConfig.autoDetectTimeoutMs ?? 200;
+		let colorSchemeDetector;
+		let widthDetector;
+		let detectionReady;
+		if (autoDetect && proc.stdin.isTTY) {
+			const write = (data) => {
+				proc.stdout.write(data);
+			};
+			const onData = (handler) => {
+				const bufferHandler = (chunk) => {
+					handler(typeof chunk === "string" ? chunk : chunk.toString());
+				};
+				proc.stdin.on("data", bufferHandler);
+				return () => {
+					proc.stdin.removeListener("data", bufferHandler);
+				};
+			};
+			colorSchemeDetector = createColorSchemeDetector({
+				write,
+				onData,
+				timeoutMs
+			});
+			colorSchemeDetector.start();
+			widthDetector = createWidthDetector({
+				write,
+				onData,
+				timeoutMs
+			});
+			detectionReady = widthDetector.detect().then((config) => {
+				if (enhanced.terminalOptions?.proc) enhanced._detectedWidthConfig = config;
+			}).catch(() => {});
+		} else detectionReady = Promise.resolve();
+		const enhanced = Object.assign(Object.create(app), {
+			terminalOptions: termConfig,
+			capabilityRegistry: registry,
+			clipboardCapability: clipboard,
+			colorSchemeDetector,
+			widthDetector,
+			detectionReady,
+			_detectedWidthConfig: null,
+			run(...args) {
+				const runOptions = {};
+				let existingOptions;
+				if (args.length > 0 && typeof args[args.length - 1] === "object" && args[args.length - 1] !== null) {
+					existingOptions = args[args.length - 1];
+					if ("type" in existingOptions && "props" in existingOptions) existingOptions = void 0;
+				}
+				Object.assign(runOptions, existingOptions ?? {}, {
+					stdin: proc.stdin,
+					stdout: proc.stdout,
+					mouse: termConfig.mouse,
+					kitty: termConfig.kitty,
+					alternateScreen: termConfig.alternateScreen,
+					suspendOnCtrlZ: termConfig.suspendOnCtrlZ,
+					exitOnCtrlC: termConfig.exitOnCtrlC,
+					textSizing: termConfig.textSizing,
+					widthDetection: termConfig.widthDetection ?? "auto",
+					focusReporting: termConfig.focusReporting,
+					onSuspend: termConfig.onSuspend,
+					onResume: termConfig.onResume,
+					onInterrupt: termConfig.onInterrupt,
+					capabilityRegistry: registry
+				});
+				if (existingOptions) {
+					const newArgs = [...args];
+					newArgs[newArgs.length - 1] = runOptions;
+					return originalRun.apply(app, newArgs);
+				}
+				return originalRun.call(app, ...args, runOptions);
+			}
+		});
+		return enhanced;
+	};
+}
+//#endregion
+//#region ../packages/create/src/internal/input-router.ts
+/**
+* Compare handler entries for dispatch order:
+* - Higher priority dispatches first
+* - Same priority: lower insertion order (first registered) wins
+*/
+function compareEntries(a, b) {
+	if (a.priority !== b.priority) return b.priority - a.priority;
+	return a.order - b.order;
+}
+/**
+* Create a priority-based input router.
+*
+* The `invalidate` callback is injected by the caller (typically wired to the
+* store/render pipeline by withDomEvents). This keeps the router decoupled
+* from silvery internals.
+*/
+function createInputRouter(options) {
+	const { invalidate } = options;
+	let nextOrder = 0;
+	const mouseHandlers = [];
+	const keyHandlers = [];
+	const overlays = [];
+	function addEntry(list, priority, handler) {
+		const entry = {
+			priority,
+			order: nextOrder++,
+			handler
+		};
+		list.push(entry);
+		list.sort(compareEntries);
+		return () => {
+			const idx = list.indexOf(entry);
+			if (idx !== -1) list.splice(idx, 1);
+		};
+	}
+	function dispatch(list, event) {
+		for (const entry of list) if (entry.handler(event)) return true;
+		return false;
+	}
+	return {
+		registerMouseHandler(priority, handler) {
+			return addEntry(mouseHandlers, priority, handler);
+		},
+		dispatchMouse(event) {
+			return dispatch(mouseHandlers, event);
+		},
+		registerKeyHandler(priority, handler) {
+			return addEntry(keyHandlers, priority, handler);
+		},
+		dispatchKey(event) {
+			return dispatch(keyHandlers, event);
+		},
+		invalidate,
+		registerOverlay(priority, renderer) {
+			return addEntry(overlays, priority, renderer);
+		},
+		getOverlays() {
+			return overlays.map((entry) => entry.handler);
+		}
+	};
+}
+//#endregion
+//#region ../packages/ag-term/src/plugins/with-dom-events.ts
+/**
+* Add DOM-style mouse event dispatch to an App.
+*
+* This plugin creates a mouse event processor and ensures that
+* click(), doubleClick(), and wheel() methods on the app dispatch
+* events through the render tree with proper bubbling.
+*
+* The App's buildApp() already sets up mouse event processing.
+* This plugin is provided for explicit composition via pipe()
+* and ensures the focus manager is connected for click-to-focus.
+*
+* @param options - Configuration (focusManager for click-to-focus)
+* @returns Plugin function that enhances an App with DOM event dispatch
+*/
+function withDomEvents(options = {}) {
+	return (app) => {
+		const fm = options.focusManager ?? app.focusManager;
+		const processorOptions = {};
+		if (fm) processorOptions.focusManager = fm;
+		const mouseState = createMouseEventProcessor(processorOptions);
+		const existingRegistry = app.capabilityRegistry;
+		const registry = options.capabilityRegistry ?? existingRegistry ?? createCapabilityRegistry();
+		let invalidateCallback = () => {};
+		const router = createInputRouter({ invalidate: () => invalidateCallback() });
+		registry.register(INPUT_ROUTER, router);
+		const enhanced = new Proxy(app, { get(target, prop, receiver) {
+			if (prop === "capabilityRegistry") return registry;
+			if (prop === "inputRouter") return router;
+			if (prop === "click") return async function enhancedClick(x, y, clickOptions) {
+				const button = clickOptions?.button ?? 0;
+				if (!router.dispatchMouse({
+					x,
+					y,
+					button,
+					type: "mousedown"
+				})) {
+					const root = target.getContainer();
+					processMouseEvent(mouseState, {
+						button,
+						x,
+						y,
+						action: "down",
+						shift: false,
+						meta: false,
+						ctrl: false
+					}, root);
+				}
+				if (!router.dispatchMouse({
+					x,
+					y,
+					button,
+					type: "mouseup"
+				})) {
+					const root = target.getContainer();
+					processMouseEvent(mouseState, {
+						button,
+						x,
+						y,
+						action: "up",
+						shift: false,
+						meta: false,
+						ctrl: false
+					}, root);
+				}
+				await Promise.resolve();
+				return receiver;
+			};
+			if (prop === "doubleClick") return async function enhancedDoubleClick(x, y, clickOptions) {
+				const button = clickOptions?.button ?? 0;
+				const root = target.getContainer();
+				const parsed = {
+					button,
+					x,
+					y,
+					action: "down",
+					shift: false,
+					meta: false,
+					ctrl: false
+				};
+				processMouseEvent(mouseState, parsed, root);
+				processMouseEvent(mouseState, {
+					...parsed,
+					action: "up"
+				}, root);
+				processMouseEvent(mouseState, parsed, root);
+				processMouseEvent(mouseState, {
+					...parsed,
+					action: "up"
+				}, root);
+				await Promise.resolve();
+				return receiver;
+			};
+			if (prop === "wheel") return async function enhancedWheel(x, y, delta) {
+				if (!router.dispatchMouse({
+					x,
+					y,
+					button: 0,
+					type: "wheel"
+				})) {
+					const root = target.getContainer();
+					processMouseEvent(mouseState, {
+						button: 0,
+						x,
+						y,
+						action: "wheel",
+						delta,
+						shift: false,
+						meta: false,
+						ctrl: false
+					}, root);
+				}
+				await Promise.resolve();
+				return receiver;
+			};
+			if (prop === "run") {
+				const originalRun = Reflect.get(target, prop, receiver);
+				if (typeof originalRun === "function") return function enhancedRun(...args) {
+					const inject = { capabilityRegistry: registry };
+					if (args.length === 0) return originalRun.call(target, inject);
+					else if (args.length === 1) {
+						const arg = args[0];
+						if (arg && typeof arg === "object" && "type" in arg) return originalRun.call(target, arg, inject);
+						else return originalRun.call(target, {
+							...arg,
+							...inject
+						});
+					} else {
+						const opts = {
+							...args[1],
+							...inject
+						};
+						return originalRun.call(target, args[0], opts);
+					}
+				};
+			}
+			return Reflect.get(target, prop, receiver);
+		} });
+		const appAny = app;
+		if (typeof appAny.store?.setState === "function") invalidateCallback = () => {
+			appAny.store.setState((prev) => ({
+				...prev,
+				_inv: (prev._inv ?? 0) + 1
+			}));
+		};
+		return enhanced;
+	};
+}
+//#endregion
+//#region ../packages/test/src/compare-buffers.ts
+init_buffer();
+//#endregion
+//#region ../packages/ag-term/src/plugins/with-diagnostics.ts
+init_buffer();
+createContext(null);
+createContext({
+	activeId: void 0,
+	isFocusEnabled: true,
+	add() {},
+	remove() {},
+	activate() {},
+	deactivate() {},
+	enableFocus() {},
+	disableFocus() {},
+	focusNext() {},
+	focusPrevious() {},
+	focus() {},
+	blur() {}
+});
+//#endregion
+export { createApp as a, pipe as i, withTerminal as n, useApp as o, withReact as r, withDomEvents as t };