silvery 0.19.2 → 0.21.1

package/dist/src-CbhWmUnF.mjs

@@ -0,0 +1,3928 @@
+import { a as NodeContext } from "./context-BU5LkkIy.mjs";
+import { f as syncFocusedSignal } from "./layout-signals-Dch2EiCy.mjs";
+import { y as isDirty } from "./reconciler-NBDSEm8k.mjs";
+import { E as createOutputPhase, R as createMeasurer, mt as stripAnsi, r as getInternalStreams, zt as queryKittyKeyboard } from "./ansi-OYRLxxZQ.mjs";
+import { C as findSpatialTarget, D as isFocusable, E as isFocusHidden, S as findFocusableAncestor, T as getTabOrder$1, b as findByTestID, w as getExplicitFocusLink, y as setFocused } from "./mouse-events-hnbJZRwK.mjs";
+import { u as useScrollRect } from "./useLayout-BKsQl2Or.mjs";
+import { j as createTerminalProfile } from "./src-Oe6x5PrS.mjs";
+import "./layout-engine-Ca_nbtfL.mjs";
+import { a as setActiveColorLevel, i as parseColor } from "./ag-BeFC4S2N.mjs";
+import React, { createContext, useContext, useEffect, useLayoutEffect, useRef } from "react";
+import { createLogger } from "loggily";
+//#region packages/ag/src/focus-manager.ts
+function createFocusManager(options) {
+	const onFocusChange = options?.onFocusChange;
+	let activeElement = null;
+	let activeId = null;
+	let previousElement = null;
+	let previousId = null;
+	let focusOrigin = null;
+	const scopeStack = [];
+	const scopeMemory = {};
+	let activeScopeId = null;
+	const hookFocusables = [];
+	let hookFocusEnabled = true;
+	const listeners = /* @__PURE__ */ new Set();
+	let snapshot = null;
+	/** Counter incremented on every notify(); used by activateScope to detect inner notifications. */
+	let notifyCount = 0;
+	function notify() {
+		snapshot = null;
+		notifyCount++;
+		for (const listener of listeners) listener();
+	}
+	function getTestID(node) {
+		const props = node.props;
+		return typeof props.testID === "string" ? props.testID : null;
+	}
+	function focus(node, origin = "programmatic") {
+		if (activeElement === node) {
+			if (focusOrigin !== origin) {
+				focusOrigin = origin;
+				notify();
+			}
+			return;
+		}
+		const oldElement = activeElement;
+		previousElement = activeElement;
+		previousId = activeId;
+		activeElement = node;
+		activeId = getTestID(node);
+		focusOrigin = origin;
+		if (oldElement) {
+			setFocused(oldElement, false);
+			syncFocusedSignal(oldElement, false);
+		}
+		setFocused(node, true);
+		syncFocusedSignal(node, true);
+		if (activeId && scopeStack.length > 0) scopeMemory[scopeStack[scopeStack.length - 1]] = activeId;
+		notify();
+		onFocusChange?.(oldElement, node, origin);
+	}
+	function focusById(id, root, origin = "programmatic") {
+		const node = findByTestID(root, id);
+		if (node) {
+			const focusable = findFocusableAncestor(node);
+			if (focusable) {
+				focus(focusable, origin);
+				return;
+			}
+		}
+		if (activeId === id && !activeElement) return;
+		const oldElement = activeElement;
+		previousElement = activeElement;
+		previousId = activeId;
+		activeElement = null;
+		activeId = id;
+		focusOrigin = origin;
+		if (oldElement) {
+			setFocused(oldElement, false);
+			syncFocusedSignal(oldElement, false);
+		}
+		notify();
+		onFocusChange?.(oldElement, null, origin);
+	}
+	function blur() {
+		if (!activeElement && !activeId) return;
+		const oldElement = activeElement;
+		previousElement = activeElement;
+		previousId = activeId;
+		activeElement = null;
+		activeId = null;
+		focusOrigin = null;
+		if (oldElement) {
+			setFocused(oldElement, false);
+			syncFocusedSignal(oldElement, false);
+		}
+		notify();
+		onFocusChange?.(oldElement, null, null);
+	}
+	/**
+	* Set the focused target to a hook-registered id directly (no tree lookup).
+	* activeElement becomes null (no backing node), activeId is the hook id.
+	*/
+	function focusVirtualId(id, origin = "programmatic") {
+		if (activeId === id && !activeElement) {
+			if (focusOrigin !== origin) {
+				focusOrigin = origin;
+				notify();
+			}
+			return;
+		}
+		const oldElement = activeElement;
+		previousElement = activeElement;
+		previousId = activeId;
+		activeElement = null;
+		activeId = id;
+		focusOrigin = origin;
+		if (oldElement) {
+			setFocused(oldElement, false);
+			syncFocusedSignal(oldElement, false);
+		}
+		notify();
+		onFocusChange?.(oldElement, null, origin);
+	}
+	function unregisterHookFocusable(id) {
+		const idx = hookFocusables.findIndex((f) => f.id === id);
+		if (idx === -1) return;
+		hookFocusables.splice(idx, 1);
+		if (activeId === id && !activeElement) {
+			previousId = activeId;
+			activeId = null;
+			focusOrigin = null;
+			notify();
+			onFocusChange?.(null, null, null);
+			return;
+		}
+		notify();
+	}
+	function registerHookFocusable(id, opts = {}) {
+		const { isActive = true, autoFocus = false } = opts;
+		const existing = hookFocusables.findIndex((f) => f.id === id);
+		if (existing !== -1) {
+			if (hookFocusables[existing].isActive === isActive && !autoFocus) return () => unregisterHookFocusable(id);
+			hookFocusables[existing] = {
+				id,
+				isActive
+			};
+		} else hookFocusables.push({
+			id,
+			isActive
+		});
+		if (autoFocus && isActive && activeId === null) focusVirtualId(id, "programmatic");
+		else notify();
+		return () => unregisterHookFocusable(id);
+	}
+	function setHookFocusableActive(id, isActive) {
+		const entry = hookFocusables.find((f) => f.id === id);
+		if (!entry) return;
+		if (entry.isActive === isActive) return;
+		entry.isActive = isActive;
+		if (!isActive && activeId === id && !activeElement) {
+			previousId = activeId;
+			activeId = null;
+			focusOrigin = null;
+			notify();
+			onFocusChange?.(null, null, null);
+			return;
+		}
+		notify();
+	}
+	function setHookFocusEnabled(enabled) {
+		if (hookFocusEnabled === enabled) return;
+		hookFocusEnabled = enabled;
+		notify();
+	}
+	/**
+	* Check if a node is the given target or contains it as a descendant.
+	*/
+	function subtreeContains(subtreeRoot, target) {
+		if (subtreeRoot === target) return true;
+		for (const child of subtreeRoot.children) if (subtreeContains(child, target)) return true;
+		return false;
+	}
+	function updateInvalidatesFocusedNode(updatedNode, focusedNode) {
+		if (!subtreeContains(updatedNode, focusedNode)) return false;
+		let current = focusedNode;
+		while (current) {
+			if (isFocusHidden(current)) return true;
+			if (current === updatedNode) break;
+			current = current.parent;
+		}
+		return updatedNode === focusedNode && !isFocusable(focusedNode);
+	}
+	/**
+	* Handle a subtree being removed from the tree. If the active or previous
+	* element lives within the removed subtree, clear the dangling reference.
+	* This prevents dead node retention and broken navigation (indexOf → -1).
+	*/
+	function handleSubtreeRemoved(removedRoot) {
+		let changed = false;
+		if (activeElement && subtreeContains(removedRoot, activeElement)) {
+			const oldElement = activeElement;
+			setFocused(oldElement, false);
+			syncFocusedSignal(oldElement, false);
+			previousElement = activeElement;
+			previousId = activeId;
+			activeElement = null;
+			activeId = null;
+			focusOrigin = null;
+			changed = true;
+			onFocusChange?.(oldElement, null, null);
+		}
+		if (previousElement && subtreeContains(removedRoot, previousElement)) {
+			previousElement = null;
+			previousId = null;
+			changed = true;
+		}
+		if (changed) notify();
+	}
+	/**
+	* Handle a mounted node update. React can update a focused node from
+	* `focusable` to non-focusable without unmounting it; leaving that node as
+	* `activeElement` keeps the focused dispatch lane alive and routes later keys
+	* into an input owner the app has already deactivated.
+	*/
+	function handleNodeUpdated(updatedNode) {
+		let changed = false;
+		if (activeElement && updateInvalidatesFocusedNode(updatedNode, activeElement)) {
+			const oldElement = activeElement;
+			setFocused(oldElement, false);
+			syncFocusedSignal(oldElement, false);
+			previousElement = activeElement;
+			previousId = activeId;
+			activeElement = null;
+			activeId = null;
+			focusOrigin = null;
+			changed = true;
+			onFocusChange?.(oldElement, null, null);
+		}
+		if (previousElement && updateInvalidatesFocusedNode(updatedNode, previousElement)) {
+			previousElement = null;
+			previousId = null;
+			changed = true;
+		}
+		if (changed) notify();
+		maybePromoteVirtualFocus(updatedNode);
+	}
+	/**
+	* Promote pending VIRTUAL focus (activeId set, activeElement null) to the
+	* real node when a matching focusable target exists under `searchRoot`.
+	* Never steals: a real activeElement short-circuits immediately. Resolution
+	* mirrors focusById exactly (findByTestID + nearest focusable ancestor), so
+	* promoted focus is indistinguishable from a direct hit.
+	*/
+	function maybePromoteVirtualFocus(searchRoot) {
+		if (activeId === null || activeElement !== null) return;
+		const node = findByTestID(searchRoot, activeId);
+		if (!node) return;
+		const focusable = findFocusableAncestor(node);
+		if (!focusable) return;
+		focus(focusable, focusOrigin ?? "programmatic");
+	}
+	function handleSubtreeAttached(attachedRoot) {
+		maybePromoteVirtualFocus(attachedRoot);
+	}
+	function enterScope(scopeId) {
+		scopeStack.push(scopeId);
+		notify();
+	}
+	function exitScope() {
+		if (scopeStack.pop() === void 0) return;
+		notify();
+	}
+	function activateScope(scopeId, root) {
+		if (activeScopeId && activeId) scopeMemory[activeScopeId] = activeId;
+		activeScopeId = scopeId;
+		const countBefore = notifyCount;
+		const remembered = scopeMemory[scopeId];
+		if (remembered) focusById(remembered, root, "programmatic");
+		else {
+			const scopeNode = findByTestID(root, scopeId);
+			if (scopeNode) {
+				const order = getTabOrder$1(root, scopeNode);
+				if (order.length > 0) focus(order[0], "programmatic");
+			}
+		}
+		if (notifyCount === countBefore) notify();
+	}
+	function getFocusPath(root) {
+		if (!activeElement) return [];
+		const path = [];
+		let current = activeElement;
+		while (current && current !== root.parent) {
+			const id = getTestID(current);
+			if (id) path.push(id);
+			current = current.parent;
+		}
+		return path;
+	}
+	function hasFocusWithin(root, testID) {
+		if (!activeElement) return false;
+		const target = findByTestID(root, testID);
+		if (!target) return false;
+		let current = activeElement;
+		while (current) {
+			if (current === target) return true;
+			current = current.parent;
+		}
+		return false;
+	}
+	/**
+	* Resolve the effective scope node for tab navigation.
+	* If an explicit scope is provided, use it. Otherwise, if the scopeStack
+	* is non-empty, find the topmost scope node in the tree by testID.
+	*/
+	function resolveScope(root, explicitScope) {
+		if (explicitScope) return explicitScope;
+		if (scopeStack.length > 0) {
+			const scopeId = scopeStack[scopeStack.length - 1];
+			const scopeNode = findByTestID(root, scopeId);
+			if (scopeNode) return scopeNode;
+		}
+	}
+	function buildTabEntries(root, scope) {
+		const effectiveScope = resolveScope(root, scope);
+		const nodes = getTabOrder$1(root, effectiveScope);
+		const entries = nodes.map((node) => ({
+			kind: "node",
+			node
+		}));
+		if (!effectiveScope && hookFocusEnabled) {
+			const treeIds = new Set(nodes.map((n) => n.props.testID).filter(Boolean));
+			for (const entry of hookFocusables) if (entry.isActive && !treeIds.has(entry.id)) entries.push({
+				kind: "hook",
+				id: entry.id
+			});
+		}
+		return entries;
+	}
+	function currentTabIndex(entries) {
+		if (activeElement) {
+			for (let i = 0; i < entries.length; i++) {
+				const e = entries[i];
+				if (e.kind === "node" && e.node === activeElement) return i;
+			}
+			return -1;
+		}
+		if (activeId) for (let i = 0; i < entries.length; i++) {
+			const e = entries[i];
+			if (e.kind === "hook" && e.id === activeId) return i;
+		}
+		return -1;
+	}
+	function focusTabEntry(entry, origin) {
+		if (entry.kind === "node") focus(entry.node, origin);
+		else focusVirtualId(entry.id, origin);
+	}
+	function focusNext(root, scope) {
+		const entries = buildTabEntries(root, scope);
+		if (entries.length === 0) return;
+		const currentIndex = currentTabIndex(entries);
+		if (currentIndex === -1) {
+			focusTabEntry(entries[0], "keyboard");
+			return;
+		}
+		focusTabEntry(entries[(currentIndex + 1) % entries.length], "keyboard");
+	}
+	function focusPrev(root, scope) {
+		const entries = buildTabEntries(root, scope);
+		if (entries.length === 0) return;
+		const currentIndex = currentTabIndex(entries);
+		if (currentIndex === -1) {
+			focusTabEntry(entries[entries.length - 1], "keyboard");
+			return;
+		}
+		focusTabEntry(entries[currentIndex <= 0 ? entries.length - 1 : currentIndex - 1], "keyboard");
+	}
+	function focusDirection(root, direction, layoutFn) {
+		if (!activeElement) return;
+		const explicitTarget = getExplicitFocusLink(activeElement, direction);
+		if (explicitTarget) {
+			focusById(explicitTarget, root, "keyboard");
+			return;
+		}
+		const candidates = getTabOrder$1(root);
+		const target = findSpatialTarget(activeElement, direction, candidates, layoutFn ?? ((node) => node.scrollRect));
+		if (target) focus(target, "keyboard");
+	}
+	function subscribe(listener) {
+		listeners.add(listener);
+		return () => {
+			listeners.delete(listener);
+		};
+	}
+	function getSnapshot() {
+		if (!snapshot) snapshot = {
+			activeId,
+			previousId,
+			focusOrigin,
+			scopeStack: [...scopeStack],
+			activeScopeId
+		};
+		return snapshot;
+	}
+	return {
+		get activeElement() {
+			return activeElement;
+		},
+		get activeId() {
+			return activeId;
+		},
+		get previousElement() {
+			return previousElement;
+		},
+		get previousId() {
+			return previousId;
+		},
+		get focusOrigin() {
+			return focusOrigin;
+		},
+		get scopeStack() {
+			return [...scopeStack];
+		},
+		get scopeMemory() {
+			return scopeMemory;
+		},
+		get activeScopeId() {
+			return activeScopeId;
+		},
+		focus,
+		focusById,
+		focusVirtualId,
+		blur,
+		handleSubtreeRemoved,
+		handleNodeUpdated,
+		handleSubtreeAttached,
+		enterScope,
+		exitScope,
+		activateScope,
+		getFocusPath,
+		hasFocusWithin,
+		focusNext,
+		focusPrev,
+		focusDirection,
+		subscribe,
+		getSnapshot,
+		registerHookFocusable,
+		setHookFocusableActive,
+		get hasHookFocusables() {
+			return hookFocusables.length > 0;
+		},
+		get hookFocusEnabled() {
+			return hookFocusEnabled;
+		},
+		setHookFocusEnabled
+	};
+}
+//#endregion
+//#region packages/ag-term/src/history-buffer.ts
+/**
+* Ring buffer for frozen scrollback items.
+*
+* Each item represents a rendered list entry (card, row, etc.) with its
+* ANSI snapshot, split rows, and plain-text rows for searching.
+* When total rows or cached ANSI bytes exceed capacity, the oldest items are
+* evicted. The byte count tracks the serialized string payload; it is a
+* deterministic cache budget, not an exact process heap measurement.
+*/
+function createHistoryItem(key, ansi, width) {
+	const rows = ansi.split("\n");
+	return {
+		key,
+		ansi,
+		rows,
+		plainTextRows: rows.map((r) => stripAnsi(r)),
+		width
+	};
+}
+function createHistoryBuffer(options = 1e4) {
+	const capacity = typeof options === "number" ? options : options.capacityRows ?? 1e4;
+	const capacityBytes = typeof options === "number" ? null : normalizeCapacityBytes(options.capacityBytes);
+	let items = [];
+	let _totalRows = 0;
+	let _totalBytes = 0;
+	function evict() {
+		while (items.length > 0 && (_totalRows > capacity || capacityBytes !== null && _totalBytes > capacityBytes)) {
+			const removed = items.shift();
+			_totalRows -= removed.rows.length;
+			_totalBytes -= estimateHistoryItemBytes(removed);
+		}
+	}
+	/** Walk items to find which item contains the given document row. */
+	function resolveRow(row) {
+		if (row < 0 || row >= _totalRows) return null;
+		let cumulative = 0;
+		for (let i = 0; i < items.length; i++) {
+			const itemRows = items[i].rows.length;
+			if (row < cumulative + itemRows) return {
+				itemIndex: i,
+				localRow: row - cumulative
+			};
+			cumulative += itemRows;
+		}
+		return null;
+	}
+	return {
+		push(item) {
+			items.push(item);
+			_totalRows += item.rows.length;
+			_totalBytes += estimateHistoryItemBytes(item);
+			evict();
+		},
+		get totalRows() {
+			return _totalRows;
+		},
+		get totalBytes() {
+			return _totalBytes;
+		},
+		get itemCount() {
+			return items.length;
+		},
+		get capacity() {
+			return capacity;
+		},
+		get capacityBytes() {
+			return capacityBytes;
+		},
+		getRows(startRow, count) {
+			const result = [];
+			for (let r = startRow; r < startRow + count; r++) {
+				const resolved = resolveRow(r);
+				if (resolved) result.push(items[resolved.itemIndex].rows[resolved.localRow]);
+				else result.push("");
+			}
+			return result;
+		},
+		getPlainTextRows(startRow, count) {
+			const result = [];
+			for (let r = startRow; r < startRow + count; r++) {
+				const resolved = resolveRow(r);
+				if (resolved) result.push(items[resolved.itemIndex].plainTextRows[resolved.localRow]);
+				else result.push("");
+			}
+			return result;
+		},
+		search(query) {
+			if (!query) return [];
+			const lowerQuery = query.toLowerCase();
+			const matches = [];
+			let rowOffset = 0;
+			for (const item of items) {
+				for (let r = 0; r < item.plainTextRows.length; r++) if (item.plainTextRows[r].toLowerCase().includes(lowerQuery)) matches.push(rowOffset + r);
+				rowOffset += item.rows.length;
+			}
+			return matches;
+		},
+		getItemAtRow(row) {
+			const resolved = resolveRow(row);
+			if (!resolved) return null;
+			return {
+				item: items[resolved.itemIndex],
+				localRow: resolved.localRow
+			};
+		},
+		clear() {
+			items = [];
+			_totalRows = 0;
+			_totalBytes = 0;
+		}
+	};
+}
+function normalizeCapacityBytes(value) {
+	return Number.isFinite(value) && value !== void 0 && value > 0 ? Math.floor(value) : null;
+}
+const utf8Encoder = new TextEncoder();
+function estimateHistoryItemBytes(item) {
+	return utf8Encoder.encode(item.ansi).byteLength;
+}
+//#endregion
+//#region packages/ag-term/src/list-document.ts
+function createListDocument(history, getLiveItems) {
+	function liveRowCount() {
+		let total = 0;
+		for (const block of getLiveItems()) total += block.rows.length;
+		return total;
+	}
+	return {
+		get totalRows() {
+			return history.totalRows + liveRowCount();
+		},
+		get frozenRows() {
+			return history.totalRows;
+		},
+		get liveRows() {
+			return liveRowCount();
+		},
+		getRows(startRow, count) {
+			const frozen = history.totalRows;
+			const result = [];
+			for (let r = startRow; r < startRow + count; r++) if (r < 0 || r >= this.totalRows) result.push("");
+			else if (r < frozen) result.push(...history.getRows(r, 1));
+			else {
+				let liveRow = r - frozen;
+				let found = false;
+				for (const block of getLiveItems()) {
+					if (liveRow < block.rows.length) {
+						result.push(block.rows[liveRow]);
+						found = true;
+						break;
+					}
+					liveRow -= block.rows.length;
+				}
+				if (!found) result.push("");
+			}
+			return result;
+		},
+		getPlainTextRows(startRow, count) {
+			const frozen = history.totalRows;
+			const result = [];
+			for (let r = startRow; r < startRow + count; r++) if (r < 0 || r >= this.totalRows) result.push("");
+			else if (r < frozen) result.push(...history.getPlainTextRows(r, 1));
+			else {
+				let liveRow = r - frozen;
+				let found = false;
+				for (const block of getLiveItems()) {
+					if (liveRow < block.plainTextRows.length) {
+						result.push(block.plainTextRows[liveRow]);
+						found = true;
+						break;
+					}
+					liveRow -= block.plainTextRows.length;
+				}
+				if (!found) result.push("");
+			}
+			return result;
+		},
+		getSource(row) {
+			const frozen = history.totalRows;
+			if (row < 0 || row >= this.totalRows) return null;
+			if (row < frozen) {
+				const hit = history.getItemAtRow(row);
+				if (!hit) return null;
+				return {
+					type: "frozen",
+					itemKey: hit.item.key,
+					localRow: hit.localRow
+				};
+			}
+			const liveItems = getLiveItems();
+			let liveRow = row - frozen;
+			for (const block of liveItems) {
+				if (liveRow < block.rows.length) return {
+					type: "live",
+					itemIndex: block.itemIndex,
+					localRow: liveRow
+				};
+				liveRow -= block.rows.length;
+			}
+			return null;
+		},
+		search(query) {
+			if (!query) return [];
+			const lowerQuery = query.toLowerCase();
+			const matches = [];
+			const frozen = history.totalRows;
+			const frozenRowMatches = history.search(query);
+			for (const row of frozenRowMatches) {
+				const line = history.getPlainTextRows(row, 1)[0].toLowerCase();
+				let pos = line.indexOf(lowerQuery);
+				while (pos !== -1) {
+					matches.push({
+						row,
+						startCol: pos,
+						endCol: pos + query.length
+					});
+					pos = line.indexOf(lowerQuery, pos + 1);
+				}
+			}
+			let rowOffset = 0;
+			for (const block of getLiveItems()) {
+				for (let i = 0; i < block.plainTextRows.length; i++) {
+					const line = block.plainTextRows[i].toLowerCase();
+					let pos = line.indexOf(lowerQuery);
+					while (pos !== -1) {
+						matches.push({
+							row: frozen + rowOffset + i,
+							startCol: pos,
+							endCol: pos + query.length
+						});
+						pos = line.indexOf(lowerQuery, pos + 1);
+					}
+				}
+				rowOffset += block.plainTextRows.length;
+			}
+			return matches;
+		}
+	};
+}
+//#endregion
+//#region packages/ag-term/src/text-surface.ts
+function createTextSurface(config) {
+	const listeners = /* @__PURE__ */ new Set();
+	function notify() {
+		for (const fn of listeners) fn();
+	}
+	return {
+		get id() {
+			return config.id;
+		},
+		get document() {
+			return config.document;
+		},
+		getText(startRow, startCol, endRow, endCol) {
+			const rows = config.document.getRows(startRow, endRow - startRow + 1);
+			const lines = [];
+			for (let i = 0; i < rows.length; i++) {
+				const plain = stripAnsi(rows[i]);
+				const row = startRow + i;
+				if (row === startRow && row === endRow) lines.push(plain.slice(startCol, endCol));
+				else if (row === startRow) lines.push(plain.slice(startCol));
+				else if (row === endRow) lines.push(plain.slice(0, endCol));
+				else lines.push(plain);
+			}
+			return lines.join("\n");
+		},
+		search(query) {
+			return config.document.search(query);
+		},
+		hitTest(viewportRow, viewportCol) {
+			const docRow = config.viewportToDocument(viewportRow);
+			if (docRow < 0 || docRow >= config.document.totalRows) return null;
+			return {
+				row: docRow,
+				col: viewportCol
+			};
+		},
+		reveal(row) {
+			config.onReveal(row);
+			notify();
+		},
+		notifyContentChange() {
+			notify();
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		get capabilities() {
+			return config.capabilities;
+		}
+	};
+}
+//#endregion
+//#region packages/ag-term/src/viewport-compositor.ts
+function composeViewport(config) {
+	const { history, viewportHeight, scrollOffset } = config;
+	const totalHistory = history.totalRows;
+	if (scrollOffset <= 0 || totalHistory === 0) return {
+		overlayRows: [],
+		overlayRowCount: 0,
+		liveRowsVisible: viewportHeight,
+		isScrolledUp: false,
+		totalHeight: totalHistory + viewportHeight
+	};
+	const startRow = Math.max(0, totalHistory - Math.min(scrollOffset, totalHistory));
+	const rowsToShow = Math.min(viewportHeight, totalHistory - startRow);
+	return {
+		overlayRows: history.getRows(startRow, rowsToShow),
+		overlayRowCount: rowsToShow,
+		liveRowsVisible: viewportHeight - rowsToShow,
+		isScrolledUp: true,
+		totalHeight: totalHistory + viewportHeight
+	};
+}
+//#endregion
+//#region packages/ag-term/src/search-overlay.ts
+/**
+* Find all case-insensitive occurrences of `query` inside `text` and return
+* their character offsets. Empty query or empty text returns `[]`.
+*
+* This is the canonical silvery search-match algorithm. The same logic runs
+* inside `ListView`'s registered Searchable (to find matches across items)
+* and is exposed to consumers that render multi-segment items — a LogRow
+* whose searchable text is a concatenation of field values, but whose visual
+* rendering splits those fields across separate Text nodes, needs per-segment
+* ranges to highlight without re-implementing the semantics.
+*
+* Ranges are returned in ascending `start` order; overlapping matches are
+* not produced (`indexOf(..., start = last.start + 1)` advances past each
+* match start, not past its full length, preserving overlapping runs of
+* short queries — e.g. `"aa"` in `"aaaa"` yields `[0..2], [1..3], [2..4]`).
+*
+* Offsets are CHARACTER offsets into the input string. They are not column
+* offsets — multi-column wide glyphs are counted as one character here, the
+* same way the SearchProvider's match-row computation does.
+*/
+function computeMatchRanges(text, query) {
+	if (query === "" || text === "") return [];
+	const lowerText = text.toLowerCase();
+	const lowerQuery = query.toLowerCase();
+	const ranges = [];
+	let cursor = 0;
+	while (cursor < lowerText.length) {
+		const found = lowerText.indexOf(lowerQuery, cursor);
+		if (found === -1) break;
+		ranges.push({
+			start: found,
+			end: found + query.length
+		});
+		cursor = found + 1;
+	}
+	return ranges;
+}
+function createSearchState() {
+	return {
+		active: false,
+		query: "",
+		matches: [],
+		currentMatch: -1,
+		cursorPosition: 0
+	};
+}
+/**
+* Update search state. searchFn is called when query changes to find matches.
+*/
+function searchUpdate(action, state, searchFn) {
+	switch (action.type) {
+		case "open": return [{
+			...state,
+			active: true,
+			query: "",
+			matches: [],
+			currentMatch: -1,
+			cursorPosition: 0
+		}, [{ type: "render" }]];
+		case "close": return [{
+			...state,
+			active: false,
+			query: "",
+			cursorPosition: 0
+		}, [{ type: "render" }]];
+		case "input": {
+			const query = state.query.slice(0, state.cursorPosition) + action.char + state.query.slice(state.cursorPosition);
+			const cursorPosition = state.cursorPosition + 1;
+			const matches = searchFn ? searchFn(query) : [];
+			const currentMatch = matches.length > 0 ? 0 : -1;
+			const effects = [{ type: "render" }];
+			if (currentMatch >= 0) effects.push({
+				type: "scrollTo",
+				row: matches[0].row
+			});
+			return [{
+				...state,
+				query,
+				cursorPosition,
+				matches,
+				currentMatch
+			}, effects];
+		}
+		case "backspace": {
+			if (state.cursorPosition === 0) return [state, []];
+			const query = state.query.slice(0, state.cursorPosition - 1) + state.query.slice(state.cursorPosition);
+			const cursorPosition = state.cursorPosition - 1;
+			const matches = searchFn ? searchFn(query) : [];
+			const currentMatch = matches.length > 0 ? 0 : -1;
+			const effects = [{ type: "render" }];
+			if (currentMatch >= 0) effects.push({
+				type: "scrollTo",
+				row: matches[0].row
+			});
+			return [{
+				...state,
+				query,
+				cursorPosition,
+				matches,
+				currentMatch
+			}, effects];
+		}
+		case "nextMatch": {
+			if (state.matches.length === 0) return [state, []];
+			const currentMatch = (state.currentMatch + 1) % state.matches.length;
+			return [{
+				...state,
+				currentMatch
+			}, [{
+				type: "scrollTo",
+				row: state.matches[currentMatch].row
+			}, { type: "render" }]];
+		}
+		case "prevMatch": {
+			if (state.matches.length === 0) return [state, []];
+			const currentMatch = (state.currentMatch - 1 + state.matches.length) % state.matches.length;
+			return [{
+				...state,
+				currentMatch
+			}, [{
+				type: "scrollTo",
+				row: state.matches[currentMatch].row
+			}, { type: "render" }]];
+		}
+		case "cursorLeft":
+			if (state.cursorPosition === 0) return [state, []];
+			return [{
+				...state,
+				cursorPosition: state.cursorPosition - 1
+			}, []];
+		case "cursorRight":
+			if (state.cursorPosition >= state.query.length) return [state, []];
+			return [{
+				...state,
+				cursorPosition: state.cursorPosition + 1
+			}, []];
+		case "cursorToStart":
+			if (state.cursorPosition === 0) return [state, []];
+			return [{
+				...state,
+				cursorPosition: 0
+			}, []];
+		case "cursorToEnd":
+			if (state.cursorPosition >= state.query.length) return [state, []];
+			return [{
+				...state,
+				cursorPosition: state.query.length
+			}, []];
+		case "deleteWordBack": {
+			if (state.cursorPosition === 0) return [state, []];
+			let pos = state.cursorPosition;
+			while (pos > 0 && /\s/.test(state.query[pos - 1] ?? "")) pos--;
+			while (pos > 0 && !/\s/.test(state.query[pos - 1] ?? "")) pos--;
+			const query = state.query.slice(0, pos) + state.query.slice(state.cursorPosition);
+			const cursorPosition = pos;
+			const matches = searchFn ? searchFn(query) : [];
+			const currentMatch = matches.length > 0 ? 0 : -1;
+			const effects = [{ type: "render" }];
+			if (currentMatch >= 0) effects.push({
+				type: "scrollTo",
+				row: matches[0].row
+			});
+			return [{
+				...state,
+				query,
+				cursorPosition,
+				matches,
+				currentMatch
+			}, effects];
+		}
+		case "deleteToStart": {
+			if (state.cursorPosition === 0) return [state, []];
+			const query = state.query.slice(state.cursorPosition);
+			const cursorPosition = 0;
+			const matches = searchFn ? searchFn(query) : [];
+			const currentMatch = matches.length > 0 ? 0 : -1;
+			const effects = [{ type: "render" }];
+			if (currentMatch >= 0) effects.push({
+				type: "scrollTo",
+				row: matches[0].row
+			});
+			return [{
+				...state,
+				query,
+				cursorPosition,
+				matches,
+				currentMatch
+			}, effects];
+		}
+	}
+}
+/**
+* Render the search bar as a plain (no ANSI) string padded to `cols` width.
+* Format: " / query  [2/15]" or " / query  [no matches]" — padded with spaces.
+*
+* Caller decides how to display it — wrap with `\x1b[7m...\x1b[27m` for the
+* legacy overlay path, or stamp into a buffer's cells with the inverse
+* attribute for the compose+apply path
+* (see `applySearchBarToPaintBuffer` in `runtime/renderer.ts`).
+*/
+function renderSearchBarPlain(state, cols) {
+	const prefix = " / ";
+	const matchInfo = state.matches.length > 0 ? `  [${state.currentMatch + 1}/${state.matches.length}]` : state.query ? "  [no matches]" : "";
+	return (prefix + state.query + matchInfo).padEnd(cols);
+}
+//#endregion
+//#region packages/ag-term/src/pane-manager.ts
+/** Create a single-pane layout */
+function createLeaf(id) {
+	return {
+		type: "leaf",
+		id
+	};
+}
+/** Get all leaf pane IDs in depth-first left-to-right order */
+function getPaneIds(layout) {
+	if (layout.type === "leaf") return [layout.id];
+	return [...getPaneIds(layout.first), ...getPaneIds(layout.second)];
+}
+/** Find the next/previous pane in tab order (depth-first left-to-right) */
+function getTabOrder(layout) {
+	return getPaneIds(layout);
+}
+/**
+* Split a pane into two. Returns new layout tree with the target pane split.
+* The original pane becomes the first child; the new pane becomes the second.
+*/
+function splitPane(layout, targetPaneId, direction, newPaneId, ratio = .5) {
+	const clampedRatio = clampRatio(ratio);
+	if (layout.type === "leaf") {
+		if (layout.id === targetPaneId) return {
+			type: "split",
+			direction,
+			ratio: clampedRatio,
+			first: {
+				type: "leaf",
+				id: targetPaneId
+			},
+			second: {
+				type: "leaf",
+				id: newPaneId
+			}
+		};
+		return layout;
+	}
+	const newFirst = splitPane(layout.first, targetPaneId, direction, newPaneId, ratio);
+	const newSecond = splitPane(layout.second, targetPaneId, direction, newPaneId, ratio);
+	if (newFirst === layout.first && newSecond === layout.second) return layout;
+	return {
+		...layout,
+		first: newFirst,
+		second: newSecond
+	};
+}
+/**
+* Remove a pane from the layout. The sibling takes the full space.
+* Returns null if the removed pane was the last one.
+*/
+function removePane(layout, paneId) {
+	if (layout.type === "leaf") return layout.id === paneId ? null : layout;
+	if (layout.first.type === "leaf" && layout.first.id === paneId) return layout.second;
+	if (layout.second.type === "leaf" && layout.second.id === paneId) return layout.first;
+	const newFirst = removePane(layout.first, paneId);
+	const newSecond = removePane(layout.second, paneId);
+	if (newFirst === null) return newSecond;
+	if (newSecond === null) return newFirst;
+	if (newFirst === layout.first && newSecond === layout.second) return layout;
+	return {
+		...layout,
+		first: newFirst,
+		second: newSecond
+	};
+}
+/** Swap two panes' positions in the layout */
+function swapPanes(layout, paneId1, paneId2) {
+	if (layout.type === "leaf") {
+		if (layout.id === paneId1) return {
+			type: "leaf",
+			id: paneId2
+		};
+		if (layout.id === paneId2) return {
+			type: "leaf",
+			id: paneId1
+		};
+		return layout;
+	}
+	const newFirst = swapPanes(layout.first, paneId1, paneId2);
+	const newSecond = swapPanes(layout.second, paneId1, paneId2);
+	if (newFirst === layout.first && newSecond === layout.second) return layout;
+	return {
+		...layout,
+		first: newFirst,
+		second: newSecond
+	};
+}
+/**
+* Resize a split: adjust the ratio of the nearest ancestor split
+* that contains the target pane as its first child.
+* Positive delta = grow (first child gets more), negative = shrink.
+*/
+function resizeSplit(layout, paneId, delta) {
+	if (layout.type === "leaf") return layout;
+	if (getPaneIds(layout.first).includes(paneId)) {
+		const newRatio = clampRatio(layout.ratio + delta);
+		if (newRatio === layout.ratio) return layout;
+		return {
+			...layout,
+			ratio: newRatio
+		};
+	}
+	if (getPaneIds(layout.second).includes(paneId)) {
+		const newRatio = clampRatio(layout.ratio - delta);
+		if (newRatio === layout.ratio) return layout;
+		return {
+			...layout,
+			ratio: newRatio
+		};
+	}
+	return layout;
+}
+/**
+* Find the pane adjacent to the given pane in a direction.
+*
+* For left/right: looks for siblings in horizontal splits.
+* For up/down: looks for siblings in vertical splits.
+*
+* Returns null if no adjacent pane exists in that direction.
+*/
+function findAdjacentPane(layout, paneId, direction) {
+	const path = findPath(layout, paneId);
+	if (!path) return null;
+	const splitDirection = direction === "left" || direction === "right" ? "horizontal" : "vertical";
+	const goToSecond = direction === "right" || direction === "down";
+	for (let i = path.length - 1; i >= 0; i--) {
+		const step = path[i];
+		if (step.node.type !== "split") continue;
+		if (step.node.direction !== splitDirection) continue;
+		if (step.side === "first" && goToSecond) return firstLeaf(step.node.second);
+		if (step.side === "second" && !goToSecond) return lastLeaf(step.node.first);
+	}
+	return null;
+}
+function clampRatio(ratio) {
+	return Math.max(.1, Math.min(.9, ratio));
+}
+/** Get the first (leftmost/topmost) leaf ID */
+function firstLeaf(node) {
+	if (node.type === "leaf") return node.id;
+	return firstLeaf(node.first);
+}
+/** Get the last (rightmost/bottommost) leaf ID */
+function lastLeaf(node) {
+	if (node.type === "leaf") return node.id;
+	return lastLeaf(node.second);
+}
+/** Find the path from root to a leaf, recording which side we took at each split */
+function findPath(layout, paneId) {
+	if (layout.type === "leaf") return layout.id === paneId ? [] : null;
+	const firstPath = findPath(layout.first, paneId);
+	if (firstPath !== null) return [{
+		node: layout,
+		side: "first"
+	}, ...firstPath];
+	const secondPath = findPath(layout.second, paneId);
+	if (secondPath !== null) return [{
+		node: layout,
+		side: "second"
+	}, ...secondPath];
+	return null;
+}
+//#endregion
+//#region packages/ag-term/src/scroll-region.ts
+/**
+* Terminal scroll region (DECSTBM) utilities.
+*
+* Scroll regions tell the terminal to natively scroll content within
+* a defined row range, which is faster than re-rendering all cells.
+*
+* DECSTBM (DEC Set Top and Bottom Margins) is supported by most modern
+* terminal emulators: xterm, iTerm2, Kitty, Ghostty, WezTerm, etc.
+*/
+const ESC = "\x1B";
+/** Set terminal scroll region (1-indexed top and bottom rows). */
+function setScrollRegion(stdout, top, bottom) {
+	stdout.write(`${ESC}[${top};${bottom}r`);
+}
+/** Reset scroll region to full terminal. */
+function resetScrollRegion(stdout) {
+	stdout.write(`${ESC}[r`);
+}
+/** Scroll content up by N lines within the current scroll region. */
+function scrollUp(stdout, lines = 1) {
+	stdout.write(`${ESC}[${lines}S`);
+}
+/** Scroll content down by N lines within the current scroll region. */
+function scrollDown(stdout, lines = 1) {
+	stdout.write(`${ESC}[${lines}T`);
+}
+/** Move cursor to a specific position (1-indexed row and column). */
+function moveCursor(stdout, row, col) {
+	stdout.write(`${ESC}[${row};${col}H`);
+}
+/**
+* Detect if the terminal likely supports DECSTBM scroll regions.
+*
+* Most modern terminals do (xterm, iTerm2, Kitty, Ghostty, WezTerm, etc.)
+* but some (e.g., Linux console) may not handle them correctly.
+*
+* Pass `emulator` (via `term.emulator` or a test fixture) when in scope.
+* Without it, this falls back to {@link createTerminalProfile} — the canonical
+* single-source-of-truth entry point in `@silvery/ansi/profile`. Direct
+* reads of terminal-signal env vars (TERM / TERM_PROGRAM / …) are banned
+* outside that module — see `scripts/lint-env-reads.ts`.
+*/
+function supportsScrollRegions(emulator) {
+	const resolved = emulator ?? createTerminalProfile().emulator;
+	const term = resolved.TERM;
+	const termProgram = resolved.program;
+	if (termProgram === "iTerm.app" || termProgram === "WezTerm" || termProgram === "ghostty" || termProgram === "Ghostty" || termProgram === "vscode") return true;
+	if (term.includes("xterm") || term.includes("screen") || term.includes("tmux") || term.includes("kitty")) return true;
+	if (term === "linux") return false;
+	return term !== "";
+}
+//#endregion
+//#region packages/ag-term/src/scroll-utils.ts
+/**
+* Scroll Utilities
+*
+* Shared functions for edge-based scrolling behavior across VirtualList,
+* HorizontalVirtualList, and other scroll-aware components.
+*/
+/**
+* Calculate edge-based scroll offset.
+*
+* Only scrolls when cursor approaches the edge of the visible area.
+* This provides smoother scrolling by starting to scroll before hitting
+* the absolute edge, maintaining context around the selected item.
+*
+* ## Algorithm
+*
+* The viewport is divided into zones:
+* ```
+* |<padding>|<------ safe zone ------>|<padding>|
+* |  scroll |    no scroll needed     | scroll  |
+* |  if <   |                         | if >    |
+* ```
+*
+* When the selected item enters a padding zone, the viewport scrolls
+* to keep the item visible with margin.
+*
+* ## Asymmetry Note
+*
+* The +1 in the "scroll down/right" case is intentional:
+* - Offset points to the TOP/LEFT of the viewport
+* - We want the selected item to be `padding` items from the BOTTOM/RIGHT
+* - Formula: `selectedIndex - visibleCount + padding + 1`
+*
+* Example: visibleCount=10, padding=2, selectedIndex=15
+*   offset = 15 - 10 + 2 + 1 = 8
+*   viewport shows items 8-17, selected item 15 is at position 7 (2 from bottom)
+*
+* @param selectedIndex - Currently selected item index
+* @param currentOffset - Current scroll offset (topmost/leftmost visible item)
+* @param visibleCount - Number of items visible in viewport
+* @param totalCount - Total number of items
+* @param padding - Items to keep visible before/after cursor (default: 1)
+* @returns New scroll offset
+*/
+function calcEdgeBasedScrollOffset(selectedIndex, currentOffset, visibleCount, totalCount, padding = 1) {
+	if (totalCount <= visibleCount) return 0;
+	const effectivePadding = padding * 2 >= visibleCount ? 0 : padding;
+	const visibleStart = currentOffset;
+	const visibleEnd = currentOffset + visibleCount - 1;
+	const paddedStart = visibleStart + effectivePadding;
+	const paddedEnd = visibleEnd - effectivePadding;
+	let newOffset = currentOffset;
+	if (selectedIndex < paddedStart) newOffset = Math.max(0, selectedIndex - effectivePadding);
+	else if (effectivePadding === 0 && selectedIndex === paddedStart && currentOffset > 0 && visibleCount > padding) newOffset = Math.max(0, selectedIndex - padding);
+	else if (selectedIndex > paddedEnd) newOffset = Math.min(totalCount - visibleCount, selectedIndex - visibleCount + effectivePadding + 1);
+	return Math.max(0, Math.min(newOffset, totalCount - visibleCount));
+}
+//#endregion
+//#region packages/ag-react/src/hooks/useCursor.ts
+/**
+* useCursor - Show and position the terminal's blinking cursor.
+*
+* Maps component-relative (col, row) to absolute terminal coordinates
+* using useScrollRect. Per-instance last-writer-wins: only one cursor
+* can be active at a time per silvery instance (the terminal has one hardware cursor).
+*
+* Cursor state is isolated per silvery instance via CursorContext. Each runtime
+* (run(), createApp(), test renderer) provides its own CursorProvider so
+* multiple silvery instances don't fight over cursor position.
+*
+* Falls back to module-level globals when no CursorProvider is present
+* (backward compatibility / deprecation path).
+*/
+/**
+* Unique-id counter for `useCursor` instances. Module-level so the
+* counter is shared across ALL instances in the process — guarantees
+* uniqueness regardless of CursorProvider scope. Wraps at MAX_SAFE_INTEGER
+* (practically infinite for terminal-UI lifetimes).
+*/
+let cursorInstanceIdCounter = 0;
+/**
+* Create an isolated cursor store. Each silvery instance gets one.
+* Returns the store (for CursorProvider) and accessors (for scheduler/output).
+*/
+function createCursorStore() {
+	const store = {
+		state: null,
+		listeners: /* @__PURE__ */ new Set(),
+		accessors: null,
+		setCursorState(s) {
+			store.state = s;
+			for (const listener of store.listeners) listener();
+		}
+	};
+	store.accessors = {
+		getCursorState: () => store.state,
+		subscribeCursor: (listener) => {
+			store.listeners.add(listener);
+			return () => {
+				store.listeners.delete(listener);
+			};
+		}
+	};
+	return store;
+}
+const CursorCtx = createContext(null);
+/**
+* Provider that gives its subtree an isolated cursor store.
+* Wrap your silvery app root in this to isolate cursor state per instance.
+*/
+function CursorProvider({ store, children }) {
+	return React.createElement(CursorCtx.Provider, { value: store }, children);
+}
+let _globalCursorState = null;
+let _globalCursorListeners = /* @__PURE__ */ new Set();
+function globalSetCursorState(state) {
+	_globalCursorState = state;
+	for (const listener of _globalCursorListeners) listener();
+}
+function globalGetCursorState() {
+	return _globalCursorState;
+}
+/** For testing -- reset global fallback state between tests. */
+function resetCursorState() {
+	_globalCursorState = null;
+	_globalCursorListeners = /* @__PURE__ */ new Set();
+}
+/**
+* Show and position the terminal's blinking cursor within this component.
+*
+* The cursor position is relative to the component's screen position.
+* Only one cursor can be active per silvery instance -- last caller with visible=true wins.
+*
+* Uses CursorContext if a CursorProvider is present (per-instance isolation).
+* Falls back to module-level globals otherwise (backward compat).
+*
+* @deprecated Phase 2 of `km-silvery.view-as-layout-output` migrated cursor
+* positioning from a React-effect-chain (`useCursor` → `useScrollRect` →
+* `setCursorState`) to a layout-output prop (`<Box cursorOffset={…}>`). The
+* prop path resolves absolute coordinates synchronously during the layout
+* phase, so the very first frame after a conditional mount emits correct
+* cursor ANSI — fixing `km-silvercode.cursor-startup-position` end-to-end.
+*
+* Migrate consumers by deleting the `useCursor({col, row, visible})` call
+* and adding `cursorOffset={{col, row, visible}}` to the surrounding Box. The
+* layout phase applies border + padding offsets automatically, so consumers
+* no longer need to add `borderColOffset` / `borderRowOffset` manually.
+*
+* This hook remains as a back-compat wrapper that writes to the cursor
+* store; the scheduler still reads the store as a fallback when no
+* `cursorOffset` prop is set on any node. Slated for deletion once all
+* in-tree consumers migrate (TextArea + TextInput already migrated; Ink
+* compat goes through the store directly and is unaffected). See bead
+* `km-silvery.delete-cursor-globals`.
+*/
+function useCursor(position) {
+	const { col, row, visible = true, shape } = position;
+	const store = useContext(CursorCtx);
+	const node = useContext(NodeContext);
+	const set = store ? store.setCursorState.bind(store) : globalSetCursorState;
+	const get = store ? store.accessors.getCursorState : globalGetCursorState;
+	const instanceIdRef = useRef(0);
+	if (instanceIdRef.current === 0) {
+		cursorInstanceIdCounter += 1;
+		instanceIdRef.current = cursorInstanceIdCounter;
+	}
+	const props = node?.props;
+	const padLeft = props?.paddingLeft ?? props?.paddingX ?? props?.padding ?? 0;
+	const padTop = props?.paddingTop ?? props?.paddingY ?? props?.padding ?? 0;
+	const borderLeft = props?.borderStyle ? 1 : 0;
+	const borderTop = props?.borderStyle ? 1 : 0;
+	const contentOffsetX = borderLeft + padLeft;
+	const contentOffsetY = borderTop + padTop;
+	const colRef = useRef(col);
+	const rowRef = useRef(row);
+	const visibleRef = useRef(visible);
+	const shapeRef = useRef(shape);
+	const setRef = useRef(set);
+	const getRef = useRef(get);
+	const lastRectRef = useRef(null);
+	const contentOffsetXRef = useRef(contentOffsetX);
+	const contentOffsetYRef = useRef(contentOffsetY);
+	colRef.current = col;
+	rowRef.current = row;
+	visibleRef.current = visible;
+	shapeRef.current = shape;
+	setRef.current = set;
+	getRef.current = get;
+	contentOffsetXRef.current = contentOffsetX;
+	contentOffsetYRef.current = contentOffsetY;
+	const scrollRect = useScrollRect();
+	const hasNode = node != null;
+	useEffect(() => {
+		if (!hasNode) return;
+		lastRectRef.current = scrollRect;
+		if (!visibleRef.current) return;
+		setRef.current({
+			x: scrollRect.x + contentOffsetXRef.current + colRef.current,
+			y: scrollRect.y + contentOffsetYRef.current + rowRef.current,
+			visible: true,
+			shape: shapeRef.current,
+			owner: instanceIdRef.current
+		});
+	}, [
+		hasNode,
+		scrollRect.x,
+		scrollRect.y,
+		scrollRect.width,
+		scrollRect.height,
+		scrollRect
+	]);
+	const owns = () => {
+		const current = getRef.current();
+		if (!current) return false;
+		if (current.owner === void 0) return true;
+		return current.owner === instanceIdRef.current;
+	};
+	const ownsRef = useRef(owns);
+	ownsRef.current = owns;
+	useLayoutEffect(() => {
+		const rect = lastRectRef.current;
+		if (!rect) return;
+		if (visible) set({
+			x: rect.x + contentOffsetX + col,
+			y: rect.y + contentOffsetY + row,
+			visible: true,
+			shape,
+			owner: instanceIdRef.current
+		});
+		else if (ownsRef.current()) set(null);
+	}, [
+		col,
+		row,
+		contentOffsetX,
+		contentOffsetY,
+		shape,
+		visible,
+		set
+	]);
+	useEffect(() => {
+		return () => {
+			if (ownsRef.current()) setRef.current(null);
+		};
+	}, []);
+}
+//#endregion
+//#region packages/ag-term/src/hit-registry-core.ts
+/**
+* Registry for managing hit regions.
+*
+* Components register their screen regions with targets, and the registry
+* resolves mouse clicks to the appropriate target based on position and z-index.
+*
+* @example
+* ```typescript
+* const registry = new HitRegistry();
+*
+* // Register a card region
+* registry.register('card-1', {
+*   x: 10, y: 5, width: 30, height: 8,
+*   target: { type: 'node', nodeId: 'abc123' },
+*   zIndex: 10
+* });
+*
+* // Hit test a click
+* const target = registry.hitTest(15, 7);
+* // Returns { type: 'node', nodeId: 'abc123' }
+* ```
+*/
+var HitRegistry = class {
+	regions = /* @__PURE__ */ new Map();
+	/**
+	* Register a hit region with a unique ID.
+	*
+	* @param id - Unique identifier for the region (used for unregistration)
+	* @param region - The region definition including position, size, target, and z-index
+	*/
+	register(id, region) {
+		this.regions.set(id, region);
+	}
+	/**
+	* Unregister a hit region by ID.
+	*
+	* @param id - The ID used when registering the region
+	*/
+	unregister(id) {
+		this.regions.delete(id);
+	}
+	/**
+	* Clear all registered regions.
+	* Useful when the UI is completely redrawn.
+	*/
+	clear() {
+		this.regions.clear();
+	}
+	/**
+	* Get the number of registered regions.
+	* Useful for debugging.
+	*/
+	get size() {
+		return this.regions.size;
+	}
+	/**
+	* Test a screen position and return the highest z-index matching target.
+	*
+	* @param screenX - X position on screen (0-indexed column)
+	* @param screenY - Y position on screen (0-indexed row)
+	* @returns The target of the highest z-index region containing the point, or null if none
+	*/
+	hitTest(screenX, screenY) {
+		let bestMatch = null;
+		for (const region of this.regions.values()) if (screenX >= region.x && screenX < region.x + region.width && screenY >= region.y && screenY < region.y + region.height) {
+			if (!bestMatch || region.zIndex > bestMatch.zIndex) bestMatch = region;
+		}
+		return bestMatch?.target ?? null;
+	}
+	/**
+	* Get all regions that contain a point, sorted by z-index (highest first).
+	* Useful for debugging or when you need to know all overlapping elements.
+	*
+	* @param screenX - X position on screen (0-indexed column)
+	* @param screenY - Y position on screen (0-indexed row)
+	* @returns Array of matching regions, sorted by z-index descending
+	*/
+	hitTestAll(screenX, screenY) {
+		const matches = [];
+		for (const region of this.regions.values()) if (screenX >= region.x && screenX < region.x + region.width && screenY >= region.y && screenY < region.y + region.height) matches.push(region);
+		return matches.sort((a, b) => b.zIndex - a.zIndex);
+	}
+	/**
+	* Debug helper: get all registered regions.
+	*/
+	getAllRegions() {
+		return new Map(this.regions);
+	}
+};
+/**
+* Generate a unique ID for hit region registration.
+*/
+let hitRegionIdCounter = 0;
+function generateHitRegionId() {
+	return `hit-${++hitRegionIdCounter}`;
+}
+/**
+* Reset the ID counter (useful for testing).
+*/
+function resetHitRegionIdCounter() {
+	hitRegionIdCounter = 0;
+}
+/**
+* Recommended z-index values for different UI layers.
+*/
+const Z_INDEX = {
+	/** Background elements */
+	BACKGROUND: 0,
+	/** Column headers */
+	COLUMN_HEADER: 5,
+	/** Cards in the main view */
+	CARD: 10,
+	/** Fold toggles (above cards for easier clicking) */
+	FOLD_TOGGLE: 15,
+	/** Links within cards */
+	LINK: 20,
+	/** Floating elements */
+	FLOATING: 50,
+	/** Modal dialogs */
+	DIALOG: 100,
+	/** Dropdown menus */
+	DROPDOWN: 150,
+	/** Tooltips */
+	TOOLTIP: 200
+};
+createLogger("silvery:render");
+createLogger("@silvery/ag-react");
+//#endregion
+//#region packages/ag-term/src/adapters/canvas-adapter.ts
+const DEFAULT_CONFIG$1 = {
+	fontSize: 14,
+	fontFamily: "monospace",
+	lineHeight: 1.2,
+	backgroundColor: "#1e1e1e",
+	foregroundColor: "#d4d4d4",
+	monospace: true,
+	dpr: 1
+};
+const BORDER_CHARS$1 = {
+	single: {
+		topLeft: "┌",
+		topRight: "┐",
+		bottomLeft: "└",
+		bottomRight: "┘",
+		horizontal: "─",
+		vertical: "│"
+	},
+	double: {
+		topLeft: "╔",
+		topRight: "╗",
+		bottomLeft: "╚",
+		bottomRight: "╝",
+		horizontal: "═",
+		vertical: "║"
+	},
+	round: {
+		topLeft: "╭",
+		topRight: "╮",
+		bottomLeft: "╰",
+		bottomRight: "╯",
+		horizontal: "─",
+		vertical: "│"
+	},
+	bold: {
+		topLeft: "┏",
+		topRight: "┓",
+		bottomLeft: "┗",
+		bottomRight: "┛",
+		horizontal: "━",
+		vertical: "┃"
+	}
+};
+/** Create a scratch canvas 2D context for text measurement. */
+function createMeasureContext(fontSize, fontFamily) {
+	const canvas = typeof document !== "undefined" ? document.createElement("canvas") : typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(1, 1) : null;
+	if (!canvas) throw new Error("Canvas not available for text measurement");
+	const ctx = canvas.getContext("2d");
+	if (!ctx) throw new Error("Could not get 2d context for measurement");
+	ctx.font = `${fontSize}px ${fontFamily}`;
+	return ctx;
+}
+function createCanvasMeasurer(config) {
+	if (config.monospace) return {
+		measureText(text, _style) {
+			return {
+				width: text.length,
+				height: 1
+			};
+		},
+		getLineHeight(_style) {
+			return 1;
+		}
+	};
+	const lineHeightPx = config.fontSize * config.lineHeight;
+	const ctx = createMeasureContext(config.fontSize, config.fontFamily);
+	return {
+		measureText(text, _style) {
+			return {
+				width: ctx.measureText(text).width,
+				height: lineHeightPx
+			};
+		},
+		getLineHeight(_style) {
+			return lineHeightPx;
+		}
+	};
+}
+const ANSI_COLORS$1 = {
+	black: "#000000",
+	red: "#cd0000",
+	green: "#00cd00",
+	yellow: "#cdcd00",
+	blue: "#0000ee",
+	magenta: "#cd00cd",
+	cyan: "#00cdcd",
+	white: "#e5e5e5",
+	gray: "#7f7f7f",
+	grey: "#7f7f7f",
+	brightBlack: "#7f7f7f",
+	brightRed: "#ff0000",
+	brightGreen: "#00ff00",
+	brightYellow: "#ffff00",
+	brightBlue: "#5c5cff",
+	brightMagenta: "#ff00ff",
+	brightCyan: "#00ffff",
+	brightWhite: "#ffffff"
+};
+function resolveColor$1(color, fallback) {
+	if (!color) return fallback;
+	if (color.startsWith("#") || color.startsWith("rgb")) return color;
+	const named = ANSI_COLORS$1[color.toLowerCase()];
+	if (named) return named;
+	return color;
+}
+var CanvasRenderBuffer = class {
+	width;
+	height;
+	canvas;
+	ctx;
+	config;
+	charWidth;
+	cellHeight;
+	constructor(width, height, config) {
+		this.width = width;
+		this.height = height;
+		this.config = config;
+		const dpr = config.dpr;
+		let cssWidth;
+		let cssHeight;
+		if (config.monospace) {
+			this.charWidth = config.fontSize * .6;
+			this.cellHeight = config.fontSize * config.lineHeight;
+			cssWidth = width * this.charWidth;
+			cssHeight = height * this.cellHeight;
+		} else {
+			this.charWidth = 1;
+			this.cellHeight = 1;
+			cssWidth = width;
+			cssHeight = height;
+		}
+		const nativeWidth = Math.ceil(cssWidth * dpr);
+		const nativeHeight = Math.ceil(cssHeight * dpr);
+		if (typeof OffscreenCanvas !== "undefined") this.canvas = new OffscreenCanvas(nativeWidth, nativeHeight);
+		else if (typeof document !== "undefined") {
+			this.canvas = document.createElement("canvas");
+			this.canvas.width = nativeWidth;
+			this.canvas.height = nativeHeight;
+		} else throw new Error("Canvas not available");
+		const ctx = this.canvas.getContext("2d");
+		if (!ctx) throw new Error("Could not get 2d context");
+		this.ctx = ctx;
+		if (dpr !== 1) this.ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+		this.ctx.fillStyle = config.backgroundColor;
+		this.ctx.fillRect(0, 0, cssWidth, cssHeight);
+	}
+	fillRect(x, y, width, height, style) {
+		if (style.bg) {
+			const px = x * this.charWidth;
+			const py = y * this.cellHeight;
+			const pw = width * this.charWidth;
+			const ph = height * this.cellHeight;
+			this.ctx.fillStyle = resolveColor$1(style.bg, this.config.backgroundColor);
+			this.ctx.fillRect(px, py, pw, ph);
+		}
+	}
+	drawText(x, y, text, style) {
+		const px = x * this.charWidth;
+		const attrs = style.attrs ?? {};
+		const weight = attrs.bold ? "bold" : "normal";
+		const fontStyle = attrs.italic ? "italic" : "normal";
+		this.ctx.font = `${fontStyle} ${weight} ${this.config.fontSize}px ${this.config.fontFamily}`;
+		let py = y * this.cellHeight;
+		this.ctx.fillStyle = resolveColor$1(style.fg, this.config.foregroundColor);
+		if (!this.config.monospace) {
+			const metrics = this.ctx.measureText("Hg");
+			const fontAscent = metrics.fontBoundingBoxAscent;
+			const contentArea = fontAscent + metrics.fontBoundingBoxDescent;
+			const halfLeading = (this.config.fontSize * this.config.lineHeight - contentArea) / 2;
+			this.ctx.textBaseline = "alphabetic";
+			py += halfLeading + fontAscent;
+		} else this.ctx.textBaseline = "top";
+		this.ctx.fillText(text, px, py);
+		if (attrs.underline) this.drawUnderline(px, py, text, style);
+		if (attrs.strikethrough) {
+			const textWidth = this.ctx.measureText(text).width;
+			const strikeY = py + this.config.fontSize * .5;
+			this.ctx.strokeStyle = resolveColor$1(style.fg, this.config.foregroundColor);
+			this.ctx.lineWidth = 1;
+			this.ctx.beginPath();
+			this.ctx.moveTo(px, strikeY);
+			this.ctx.lineTo(px + textWidth, strikeY);
+			this.ctx.stroke();
+		}
+	}
+	/**
+	* Draw underline decorations at pixel coordinates.
+	* Note: px, py are already in pixel coordinates.
+	*/
+	drawUnderline(px, py, text, style) {
+		const attrs = style.attrs ?? {};
+		const textWidth = this.ctx.measureText(text).width;
+		const underlineY = py + this.config.fontSize * .9;
+		const underlineColor = resolveColor$1(attrs.underlineColor ?? style.fg, this.config.foregroundColor);
+		this.ctx.strokeStyle = underlineColor;
+		this.ctx.lineWidth = 1;
+		switch (attrs.underlineStyle ?? "single") {
+			case "double":
+				this.ctx.beginPath();
+				this.ctx.moveTo(px, underlineY - 1);
+				this.ctx.lineTo(px + textWidth, underlineY - 1);
+				this.ctx.moveTo(px, underlineY + 1);
+				this.ctx.lineTo(px + textWidth, underlineY + 1);
+				this.ctx.stroke();
+				break;
+			case "curly":
+				this.ctx.beginPath();
+				this.ctx.moveTo(px, underlineY);
+				const waveLength = 4;
+				const amplitude = 2;
+				for (let wx = 0; wx < textWidth; wx += waveLength * 2) {
+					this.ctx.quadraticCurveTo(px + wx + waveLength / 2, underlineY - amplitude, px + wx + waveLength, underlineY);
+					this.ctx.quadraticCurveTo(px + wx + waveLength * 3 / 2, underlineY + amplitude, px + wx + waveLength * 2, underlineY);
+				}
+				this.ctx.stroke();
+				break;
+			case "dotted":
+				this.ctx.setLineDash([2, 2]);
+				this.ctx.beginPath();
+				this.ctx.moveTo(px, underlineY);
+				this.ctx.lineTo(px + textWidth, underlineY);
+				this.ctx.stroke();
+				this.ctx.setLineDash([]);
+				break;
+			case "dashed":
+				this.ctx.setLineDash([4, 2]);
+				this.ctx.beginPath();
+				this.ctx.moveTo(px, underlineY);
+				this.ctx.lineTo(px + textWidth, underlineY);
+				this.ctx.stroke();
+				this.ctx.setLineDash([]);
+				break;
+			default:
+				this.ctx.beginPath();
+				this.ctx.moveTo(px, underlineY);
+				this.ctx.lineTo(px + textWidth, underlineY);
+				this.ctx.stroke();
+		}
+	}
+	drawChar(x, y, char, style) {
+		this.drawText(x, y, char, style);
+	}
+	inBounds(x, y) {
+		return x >= 0 && x < this.width && y >= 0 && y < this.height;
+	}
+	fillRoundedRect(x, y, width, height, radius, fill, stroke, lineWidth = 1) {
+		const px = x * this.charWidth;
+		const py = y * this.cellHeight;
+		const pw = width * this.charWidth;
+		const ph = height * this.cellHeight;
+		const r = Math.min(radius, pw / 2, ph / 2);
+		this.ctx.beginPath();
+		this.ctx.moveTo(px + r, py);
+		this.ctx.lineTo(px + pw - r, py);
+		this.ctx.quadraticCurveTo(px + pw, py, px + pw, py + r);
+		this.ctx.lineTo(px + pw, py + ph - r);
+		this.ctx.quadraticCurveTo(px + pw, py + ph, px + pw - r, py + ph);
+		this.ctx.lineTo(px + r, py + ph);
+		this.ctx.quadraticCurveTo(px, py + ph, px, py + ph - r);
+		this.ctx.lineTo(px, py + r);
+		this.ctx.quadraticCurveTo(px, py, px + r, py);
+		this.ctx.closePath();
+		if (fill) {
+			this.ctx.fillStyle = fill;
+			this.ctx.fill();
+		}
+		if (stroke) {
+			this.ctx.strokeStyle = stroke;
+			this.ctx.lineWidth = lineWidth;
+			this.ctx.stroke();
+		}
+	}
+};
+function createCanvasAdapter(config = {}) {
+	const cfg = {
+		...DEFAULT_CONFIG$1,
+		...config
+	};
+	return {
+		name: "canvas",
+		measurer: createCanvasMeasurer(cfg),
+		createBuffer(width, height) {
+			return new CanvasRenderBuffer(width, height, cfg);
+		},
+		flush(_buffer, _prevBuffer) {},
+		getBorderChars(style) {
+			return BORDER_CHARS$1[style] ?? BORDER_CHARS$1.single;
+		}
+	};
+}
+//#endregion
+//#region packages/ag-term/src/adapters/dom-adapter.ts
+const DEFAULT_CONFIG = {
+	fontSize: 14,
+	fontFamily: "monospace",
+	lineHeight: 1.2,
+	backgroundColor: "#1e1e1e",
+	foregroundColor: "#d4d4d4",
+	classPrefix: "silvery"
+};
+const BORDER_CHARS = {
+	single: {
+		topLeft: "┌",
+		topRight: "┐",
+		bottomLeft: "└",
+		bottomRight: "┘",
+		horizontal: "─",
+		vertical: "│"
+	},
+	double: {
+		topLeft: "╔",
+		topRight: "╗",
+		bottomLeft: "╚",
+		bottomRight: "╝",
+		horizontal: "═",
+		vertical: "║"
+	},
+	round: {
+		topLeft: "╭",
+		topRight: "╮",
+		bottomLeft: "╰",
+		bottomRight: "╯",
+		horizontal: "─",
+		vertical: "│"
+	},
+	bold: {
+		topLeft: "┏",
+		topRight: "┓",
+		bottomLeft: "┗",
+		bottomRight: "┛",
+		horizontal: "━",
+		vertical: "┃"
+	}
+};
+const ANSI_COLORS = {
+	black: "#000000",
+	red: "#cd0000",
+	green: "#00cd00",
+	yellow: "#cdcd00",
+	blue: "#0000ee",
+	magenta: "#cd00cd",
+	cyan: "#00cdcd",
+	white: "#e5e5e5",
+	gray: "#7f7f7f",
+	grey: "#7f7f7f",
+	brightblack: "#7f7f7f",
+	brightred: "#ff0000",
+	brightgreen: "#00ff00",
+	brightyellow: "#ffff00",
+	brightblue: "#5c5cff",
+	brightmagenta: "#ff00ff",
+	brightcyan: "#00ffff",
+	brightwhite: "#ffffff"
+};
+function resolveColor(color, fallback) {
+	if (!color) return fallback;
+	if (color.startsWith("#") || color.startsWith("rgb")) return color;
+	return ANSI_COLORS[color.toLowerCase()] ?? color;
+}
+function createDOMMeasurer(_config) {
+	return {
+		measureText(text, _style) {
+			return {
+				width: text.length,
+				height: 1
+			};
+		},
+		getLineHeight(_style) {
+			return 1;
+		}
+	};
+}
+var DOMRenderBuffer = class {
+	width;
+	height;
+	config;
+	lines;
+	backgrounds;
+	charWidth;
+	cellHeight;
+	container = null;
+	constructor(width, height, config) {
+		this.width = width;
+		this.height = height;
+		this.config = config;
+		this.lines = /* @__PURE__ */ new Map();
+		this.backgrounds = /* @__PURE__ */ new Map();
+		this.charWidth = config.fontSize * .6;
+		this.cellHeight = config.fontSize * config.lineHeight;
+	}
+	/**
+	* Set the container element for rendering.
+	*/
+	setContainer(container) {
+		this.container = container;
+	}
+	/**
+	* Get the container element.
+	*/
+	getContainer() {
+		return this.container;
+	}
+	fillRect(x, y, width, height, style) {
+		if (style.bg) {
+			const key = `${x},${y},${width},${height}`;
+			this.backgrounds.set(key, {
+				x,
+				y,
+				w: width,
+				h: height,
+				color: resolveColor(style.bg, this.config.backgroundColor)
+			});
+		}
+	}
+	drawText(x, y, text, style) {
+		if (!this.lines.has(y)) this.lines.set(y, []);
+		this.lines.get(y).push({
+			text,
+			style,
+			x
+		});
+	}
+	drawChar(x, y, char, style) {
+		this.drawText(x, y, char, style);
+	}
+	inBounds(x, y) {
+		return x >= 0 && x < this.width && y >= 0 && y < this.height;
+	}
+	/**
+	* Render the buffer to the container element.
+	* Coordinates in the buffer are in cell units (cols/rows).
+	* This method converts them to pixel coordinates for DOM positioning.
+	*/
+	render() {
+		if (!this.container) throw new Error("DOMRenderBuffer: No container set. Call setContainer() first.");
+		const container = this.container;
+		const cw = this.charWidth;
+		const ch = this.cellHeight;
+		const containerWidthPx = this.width * cw;
+		const containerHeightPx = this.height * ch;
+		container.innerHTML = "";
+		container.style.cssText = `
+			position: relative;
+			font-family: ${this.config.fontFamily};
+			font-size: ${this.config.fontSize}px;
+			line-height: ${this.config.lineHeight};
+			background-color: ${this.config.backgroundColor};
+			color: ${this.config.foregroundColor};
+			white-space: pre;
+			overflow: hidden;
+			width: ${containerWidthPx}px;
+			height: ${containerHeightPx}px;
+		`;
+		for (const bg of this.backgrounds.values()) {
+			const bgDiv = document.createElement("div");
+			bgDiv.className = `${this.config.classPrefix}-bg`;
+			bgDiv.style.cssText = `
+				position: absolute;
+				left: ${bg.x * cw}px;
+				top: ${bg.y * ch}px;
+				width: ${bg.w * cw}px;
+				height: ${bg.h * ch}px;
+				background-color: ${bg.color};
+			`;
+			container.appendChild(bgDiv);
+		}
+		const sortedLines = Array.from(this.lines.entries()).sort((a, b) => a[0] - b[0]);
+		for (const [y, runs] of sortedLines) {
+			const lineDiv = document.createElement("div");
+			lineDiv.className = `${this.config.classPrefix}-line`;
+			lineDiv.style.cssText = `
+				position: absolute;
+				left: 0;
+				top: ${y * ch}px;
+				height: ${ch}px;
+				white-space: pre;
+			`;
+			const sortedRuns = runs.sort((a, b) => a.x - b.x);
+			for (const run of sortedRuns) {
+				const span = document.createElement(run.style.hyperlink === void 0 ? "span" : "a");
+				span.className = `${this.config.classPrefix}-text`;
+				span.textContent = run.text;
+				if (run.style.hyperlink !== void 0) span.setAttribute("href", run.style.hyperlink);
+				const styles = [`position: absolute`, `left: ${run.x * cw}px`];
+				if (run.style.fg) styles.push(`color: ${resolveColor(run.style.fg, this.config.foregroundColor)}`);
+				if (run.style.bg) styles.push(`background-color: ${resolveColor(run.style.bg, this.config.backgroundColor)}`);
+				const attrs = run.style.attrs;
+				if (attrs) {
+					if (attrs.bold) styles.push("font-weight: bold");
+					if (attrs.dim) styles.push("opacity: 0.5");
+					if (attrs.italic) styles.push("font-style: italic");
+					if (attrs.underline || attrs.underlineStyle) {
+						const underlineStyle = attrs.underlineStyle ?? "single";
+						const underlineColor = attrs.underlineColor ? resolveColor(attrs.underlineColor, this.config.foregroundColor) : "currentColor";
+						switch (underlineStyle) {
+							case "double":
+								styles.push(`text-decoration: underline double ${underlineColor}`);
+								break;
+							case "curly":
+								styles.push(`text-decoration: underline wavy ${underlineColor}`);
+								break;
+							case "dotted":
+								styles.push(`text-decoration: underline dotted ${underlineColor}`);
+								break;
+							case "dashed":
+								styles.push(`text-decoration: underline dashed ${underlineColor}`);
+								break;
+							default: styles.push(`text-decoration: underline solid ${underlineColor}`);
+						}
+					}
+					if (attrs.strikethrough) {
+						const existing = styles.find((s) => s.startsWith("text-decoration:"));
+						if (existing) {
+							const idx = styles.indexOf(existing);
+							styles[idx] = existing.replace("underline", "underline line-through");
+						} else styles.push("text-decoration: line-through");
+					}
+					if (attrs.inverse) {
+						const fg = run.style.fg ? resolveColor(run.style.fg, this.config.foregroundColor) : this.config.foregroundColor;
+						const bg = run.style.bg ? resolveColor(run.style.bg, this.config.backgroundColor) : this.config.backgroundColor;
+						styles.push(`color: ${bg}`, `background-color: ${fg}`);
+					}
+				}
+				span.style.cssText = styles.join("; ");
+				lineDiv.appendChild(span);
+			}
+			container.appendChild(lineDiv);
+		}
+	}
+	/**
+	* Clear the buffer.
+	*/
+	clear() {
+		this.lines.clear();
+		this.backgrounds.clear();
+	}
+};
+function createDOMAdapter(config = {}) {
+	const cfg = {
+		...DEFAULT_CONFIG,
+		...config
+	};
+	return {
+		name: "dom",
+		measurer: createDOMMeasurer(cfg),
+		createBuffer(width, height) {
+			return new DOMRenderBuffer(width, height, cfg);
+		},
+		flush(buffer, _prevBuffer) {
+			const domBuffer = buffer;
+			if (domBuffer.getContainer()) domBuffer.render();
+		},
+		getBorderChars(style) {
+			return BORDER_CHARS[style] ?? BORDER_CHARS.single;
+		}
+	};
+}
+let stylesInjected = false;
+/**
+* Inject global CSS styles for silvery DOM rendering.
+* Call once at application startup if you want default styling.
+*/
+function injectDOMStyles(classPrefix = "silvery") {
+	if (stylesInjected || typeof document === "undefined") return;
+	const style = document.createElement("style");
+	style.textContent = `
+		.${classPrefix}-container {
+			font-family: monospace;
+			white-space: pre;
+			overflow: hidden;
+		}
+		.${classPrefix}-line {
+			white-space: pre;
+		}
+		.${classPrefix}-text {
+			white-space: pre;
+		}
+		/* Selection styling */
+		.${classPrefix}-text::selection {
+			background-color: rgba(100, 150, 255, 0.3);
+		}
+	`;
+	document.head.appendChild(style);
+	stylesInjected = true;
+}
+//#endregion
+//#region packages/ag-term/src/caret-style.ts
+/**
+* Walk a tree and return the AgNode whose `cursorOffset` produced the active
+* caret rect (matching the precedence rules of `findActiveCursorRect`).
+*
+* Used by the scheduler to feed `resolveCaretStyle`. Re-walks the tree to
+* keep `findActiveCursorRect` returning a value-only (data) result rather
+* than coupling it to the AgNode reference.
+*
+* Returns null when no caret is active.
+*/
+function findActiveCursorNode(root) {
+	let focusedNode = null;
+	let focusedSuppressesFallback = false;
+	let fallbackNode = null;
+	function walk(node) {
+		for (const child of node.children) walk(child);
+		const props = node.props;
+		if (!props?.cursorOffset) return;
+		const offset = props.cursorOffset;
+		if (props.focused === true || node.interactiveState?.focused) {
+			focusedSuppressesFallback = true;
+			focusedNode = node;
+			return;
+		}
+		if (offset.visible !== false) fallbackNode = node;
+	}
+	walk(root);
+	return focusedNode ?? (focusedSuppressesFallback ? null : fallbackNode);
+}
+//#endregion
+//#region packages/ag-term/src/osc-markers.ts
+/**
+* OSC 133 Semantic Prompt Markers
+*
+* Shell integration protocol that marks prompts and commands in terminal output.
+* Terminals like iTerm2, Kitty, and WezTerm use these markers to provide
+* "jump to previous/next prompt" navigation (Cmd+Up/Cmd+Down in iTerm2).
+*
+* Protocol: OSC 133
+* - Prompt start:         ESC ] 133 ; A BEL     (before user input)
+* - Prompt end:           ESC ] 133 ; B BEL     (after user input, before command output)
+* - Command output start: ESC ] 133 ; C BEL     (before command output)
+* - Command output end:   ESC ] 133 ; D ; N BEL (after command output, N = exit code)
+*
+* For a chat-style app, each "exchange" (user prompt + assistant response) maps to:
+* - 133;A before the user's message
+* - 133;B after the user's message
+* - 133;C before the assistant's response
+* - 133;D;0 after the assistant's response
+*
+* Supported by: iTerm2, Kitty, WezTerm, foot, Ghostty
+*/
+const OSC133 = {
+	/** Mark prompt start (before user input) */
+	promptStart: "\x1B]133;A\x07",
+	/** Mark prompt end (after user input, before command output) */
+	promptEnd: "\x1B]133;B\x07",
+	/** Mark command output start */
+	commandStart: "\x1B]133;C\x07",
+	/** Mark command output end (exit code defaults to 0 = success) */
+	commandEnd: (exitCode) => `\x1b]133;D;${exitCode ?? 0}\x07`
+};
+//#endregion
+//#region packages/ag-term/src/kitty-detect.ts
+/**
+* Kitty keyboard protocol detection.
+*
+* Sends CSI ? u and parses the response to determine whether the terminal
+* supports the Kitty keyboard protocol and which flags it reports.
+*/
+/** Regex to match a Kitty keyboard query response: CSI ? <flags> u */
+const KITTY_RESPONSE_RE = /\x1b\[\?(\d+)u/;
+/**
+* Detect Kitty keyboard protocol support.
+*
+* Sends CSI ? u to the terminal and waits for a response.
+* Supported terminals respond with CSI ? flags u.
+* Unsupported terminals either ignore the query or echo it.
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin (should resolve with data or null on timeout)
+* @param timeoutMs How long to wait for response (default: 200ms)
+*/
+async function detectKittySupport(write, read, timeoutMs = 200) {
+	write(queryKittyKeyboard());
+	const data = await read(timeoutMs);
+	if (data == null) return {
+		supported: false,
+		flags: 0
+	};
+	const match = KITTY_RESPONSE_RE.exec(data);
+	if (!match) return {
+		supported: false,
+		flags: 0,
+		buffered: data
+	};
+	return {
+		supported: true,
+		flags: parseInt(match[1], 10),
+		buffered: data.slice(0, match.index) + data.slice(match.index + match[0].length) || void 0
+	};
+}
+/**
+* Detect Kitty support using real stdin/stdout.
+* Convenience wrapper around detectKittySupport.
+*/
+async function detectKittyFromStdio(stdout, stdin, timeoutMs = 200) {
+	const otherListeners = stdin.listenerCount("data") > 0;
+	const wasRaw = stdin.isRaw;
+	let didSetRaw = false;
+	if (!wasRaw && !otherListeners) {
+		stdin.setRawMode(true);
+		didSetRaw = true;
+	}
+	try {
+		const write = (s) => {
+			stdout.write(s);
+		};
+		const read = (ms) => new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				stdin.removeListener("data", onData);
+				resolve(null);
+			}, ms);
+			function onData(chunk) {
+				clearTimeout(timer);
+				stdin.removeListener("data", onData);
+				resolve(chunk.toString());
+			}
+			stdin.on("data", onData);
+		});
+		return await detectKittySupport(write, read, timeoutMs);
+	} finally {
+		if (didSetRaw) stdin.setRawMode(false);
+	}
+}
+//#endregion
+//#region packages/ag-term/src/termtest.ts
+/**
+* Terminal Capability Test
+*
+* Renders labeled test patterns for each terminal feature.
+* Run in any terminal to visually verify what it supports.
+*
+* Usage:
+*   import { runTermtest } from "@silvery/ag-react"
+*   runTermtest()                    // all sections
+*   runTermtest({ sections: ["emoji", "colors"] })  // specific sections
+*
+* Compare output across terminals to build/verify profiles.
+*/
+const CSI = `[`;
+const RESET = `${CSI}0m`;
+function sgr(...codes) {
+	return `${CSI}${codes.join(";")}m`;
+}
+function sectionHeader(title) {
+	return `\n${sgr(1)}═══ ${title} ═══${RESET}\n`;
+}
+function row(label, content) {
+	return `  ${label.padEnd(24)} ${content}${RESET}`;
+}
+/** Available test sections */
+const TERMTEST_SECTIONS = [
+	"sgr",
+	"underline",
+	"colors",
+	"256",
+	"truecolor",
+	"unicode",
+	"emoji",
+	"borders",
+	"inverse",
+	"profile"
+];
+/**
+* Run the terminal capability test.
+* Pass section names to filter: `runTermtest({ sections: ["emoji"] })`
+*/
+function runTermtest(options) {
+	const w = options?.output ?? process.stdout;
+	const filter = options?.sections;
+	const show = (s) => !filter || filter.length === 0 || filter.includes(s);
+	const { caps, emulator } = createTerminalProfile();
+	w.write(`\n${sgr(1)}Terminal Capability Test${RESET}\n`);
+	w.write(`  Program: ${emulator.program || "(unknown)"}\n`);
+	w.write(`  TERM: ${emulator.TERM || "(unknown)"}\n`);
+	w.write(`  COLORTERM: ${process.env.COLORTERM || "(unset)"}\n`);
+	w.write(`  Detected: color=${caps.colorLevel} maybe-dark=${caps.maybeDarkBackground} maybe-nerdfont=${caps.maybeNerdFont}\n`);
+	w.write(`  Underline: styles=[${caps.underlineStyles.join(", ")}] color=${caps.underlineColor}\n`);
+	w.write(`  Maybe wide emojis: ${caps.maybeWideEmojis}\n`);
+	if (show("sgr")) {
+		w.write(sectionHeader("SGR Text Attributes"));
+		w.write(row("Bold", `${sgr(1)}The quick brown fox${RESET}`) + "\n");
+		w.write(row("Dim", `${sgr(2)}The quick brown fox${RESET}`) + "\n");
+		w.write(row("Italic", `${sgr(3)}The quick brown fox${RESET}`) + "\n");
+		w.write(row("Underline", `${sgr(4)}The quick brown fox${RESET}`) + "\n");
+		w.write(row("Strikethrough", `${sgr(9)}The quick brown fox${RESET}`) + "\n");
+		w.write(row("Inverse", `${sgr(7)}The quick brown fox${RESET}`) + "\n");
+		w.write(row("Blink", `${sgr(5)}The quick brown fox${RESET}`) + "\n");
+		w.write(row("Bold+Italic", `${sgr(1, 3)}The quick brown fox${RESET}`) + "\n");
+	}
+	if (show("underline")) {
+		w.write(sectionHeader("SGR 4:x Underline Styles (Terminal.app BREAKS here)"));
+		w.write(row("4:1 Single", `${CSI}4:1mThe quick brown fox${RESET}`) + "\n");
+		w.write(row("4:2 Double", `${CSI}4:2mThe quick brown fox${RESET}`) + "\n");
+		w.write(row("4:3 Curly", `${CSI}4:3mThe quick brown fox${RESET}`) + "\n");
+		w.write(row("4:4 Dotted", `${CSI}4:4mThe quick brown fox${RESET}`) + "\n");
+		w.write(row("4:5 Dashed", `${CSI}4:5mThe quick brown fox${RESET}`) + "\n");
+		w.write(row("After 4:x (clean?)", `${CSI}4:3m${RESET}This text should be normal — if garbled, 4:x corrupted SGR state`) + "\n");
+		w.write(sectionHeader("SGR 58 Underline Color (Terminal.app BREAKS here)"));
+		w.write(row("58;5;1 Red UL", `${sgr(4)}${CSI}58;5;1mThe quick brown fox${RESET}`) + "\n");
+		w.write(row("58;5;2 Green UL", `${sgr(4)}${CSI}58;5;2mThe quick brown fox${RESET}`) + "\n");
+		w.write(row("58;5;4 Blue UL", `${sgr(4)}${CSI}58;5;4mThe quick brown fox${RESET}`) + "\n");
+		w.write(row("58;2;R;G;B TC UL", `${sgr(4)}${CSI}58;2;255;128;0mThe quick brown fox${RESET}`) + "\n");
+		w.write(row("After SGR 58 (clean?)", `${sgr(4)}${CSI}58;5;1m${RESET}This text should be normal — if garbled, 58 corrupted SGR state`) + "\n");
+	}
+	if (show("colors")) {
+		w.write(sectionHeader("ANSI 16 Colors"));
+		const colorNames = [
+			"Black",
+			"Red",
+			"Green",
+			"Yellow",
+			"Blue",
+			"Magenta",
+			"Cyan",
+			"White"
+		];
+		let fgLine = "  FG:  ";
+		for (let i = 0; i < 8; i++) fgLine += `${sgr(30 + i)} ${colorNames[i]}${RESET}`;
+		w.write(fgLine + "\n");
+		let fgBrLine = "  Br:  ";
+		for (let i = 0; i < 8; i++) fgBrLine += `${sgr(90 + i)} ${colorNames[i]}${RESET}`;
+		w.write(fgBrLine + "\n");
+		let bgLine = "  BG:  ";
+		for (let i = 0; i < 8; i++) bgLine += `${sgr(40 + i)} ${colorNames[i]} ${RESET}`;
+		w.write(bgLine + "\n");
+		let bgBrLine = "  BrBG:";
+		for (let i = 0; i < 8; i++) bgBrLine += `${sgr(100 + i)} ${colorNames[i]} ${RESET}`;
+		w.write(bgBrLine + "\n");
+	}
+	if (show("256")) {
+		w.write(sectionHeader("256 Colors (indices 0-15, 16-231, 232-255)"));
+		let stdLine = "  0-15:  ";
+		for (let i = 0; i < 16; i++) stdLine += `${CSI}48;5;${i}m  ${RESET}`;
+		w.write(stdLine + "\n");
+		let cubeLine = "  Cube:  ";
+		for (let i = 16; i < 52; i++) cubeLine += `${CSI}48;5;${i}m ${RESET}`;
+		w.write(cubeLine + "\n");
+		let grayLine = "  Gray:  ";
+		for (let i = 232; i < 256; i++) grayLine += `${CSI}48;5;${i}m ${RESET}`;
+		w.write(grayLine + "\n");
+	}
+	if (show("truecolor")) {
+		w.write(sectionHeader("Truecolor (38;2;R;G;B / 48;2;R;G;B)"));
+		let tcLine = "  Gradient: ";
+		for (let i = 0; i < 40; i++) {
+			const r = Math.round(i / 39 * 255);
+			const g = Math.round((39 - i) / 39 * 128);
+			tcLine += `${CSI}48;2;${r};${g};80m ${RESET}`;
+		}
+		w.write(tcLine + "\n");
+		w.write(row("If solid blocks →", "Truecolor NOT supported (256-color fallback)") + "\n");
+	}
+	if (show("unicode")) {
+		w.write(sectionHeader("Unicode, Emoji, PUA (Nerd Fonts)"));
+		w.write(row("ASCII", "Hello World! 0123456789") + "\n");
+		w.write(row("Latin Extended", "àéîõü ñ ß ø å") + "\n");
+		w.write(row("CJK", "你好世界 日本語 한국어") + "\n");
+		w.write(row("Box Drawing", "┌─┬─┐ ╔═╦═╗ ╭─╮") + "\n");
+		w.write(row("Block Elements", "▀▄█▌▐░▒▓") + "\n");
+		w.write(row("Symbols", "● ○ ◉ ▶ ◀ ⚠ ✓ ✗ ⋮ §") + "\n");
+		w.write(row("Emoji", "🎉 🚀 📁 📄 ⭐ 🔥 👍") + "\n");
+		w.write(row("Nerd Font PUA", " folder   file   arrow   gear") + "\n");
+		w.write(row("If PUA = boxes →", "Nerd Fonts not installed") + "\n");
+	}
+	if (show("emoji")) {
+		w.write(sectionHeader("Emoji Width Alignment (_'s should align with ruler)"));
+		w.write("  Ruler:     |1234567890|\n");
+		w.write("  ASCII 'A': |A_________| (w=1)\n");
+		w.write("  CJK '你':  |你________| (w=2)\n");
+		w.write("  Flag 🇨🇦:  |🇨🇦________| (w=2)\n");
+		w.write("  Flag 🇺🇸:  |🇺🇸________| (w=2)\n");
+		w.write("  Emoji 📁:  |📁________| (w=2)\n");
+		w.write("  Emoji 📄:  |📄________| (w=2)\n");
+		w.write("  Emoji 📋:  |📋________| (w=2)\n");
+		w.write("  Emoji ⚠️:  |⚠️________| (w=2)\n");
+		w.write("  Text  ⚠:   |⚠_________| (w=1 text, 2 emoji)\n");
+		w.write("  Text  ⭐:   |⭐________| (w=1 text, 2 emoji)\n");
+		w.write("  Text  ☑:   |☑_________| (w=1 text, 2 emoji)\n");
+		w.write("  Emoji 🏠:  |🏠________| (w=2)\n");
+		w.write("  Emoji 👓:  |👓________| (w=2)\n");
+		w.write("  ZWJ 👨🏻‍💻: |👨🏻‍💻________| (w=2)\n");
+		w.write("  Arrow →:   |→_________| (w=1)\n");
+		w.write("  Arrow ▸:   |▸_________| (w=1)\n");
+		w.write("  Circle ○:  |○_________| (w=1)\n");
+		w.write("  Square □:  |□_________| (w=1)\n");
+		w.write("  Check ✓:   |✓_________| (w=1)\n");
+	}
+	if (show("borders")) {
+		w.write(sectionHeader("Box Drawing Borders"));
+		w.write("  ┌──────────┐  ╔══════════╗  ╭──────────╮\n");
+		w.write("  │  single  │  ║  double  ║  │  round   │\n");
+		w.write("  └──────────┘  ╚══════════╝  ╰──────────╯\n");
+	}
+	if (show("inverse")) {
+		w.write(sectionHeader("Inverse + Background (potential artifact source)"));
+		w.write(row("Red FG + Inverse", `${sgr(31, 7)}This should have red background${RESET}`) + "\n");
+		w.write(row("Cyan BG + White FG", `${sgr(46, 37)}Cyan background, white text${RESET}`) + "\n");
+		w.write(row("Black BG + White FG", `${sgr(40, 97)}Black bg, bright white text${RESET}`) + "\n");
+		w.write(row("White BG + Black FG", `${sgr(107, 30)}White bg, black text${RESET}`) + "\n");
+		w.write(sectionHeader("Reset Sanity Check"));
+		w.write("  This line should be completely normal with no formatting artifacts.\n");
+		w.write("  If you see colors, underlines, or other styling above, the terminal\n");
+		w.write("  failed to process an SGR reset (\\x1b[0m) correctly.\n");
+	}
+	if (show("profile")) {
+		w.write(sectionHeader("Detected Terminal Profile"));
+		const entries = Object.entries(caps);
+		for (const [key, value] of entries) {
+			const indicator = value === true ? "✓" : value === false ? "✗" : String(value);
+			w.write(`  ${key.padEnd(20)} ${indicator}\n`);
+		}
+	}
+	w.write("\n");
+}
+//#endregion
+//#region packages/ag-term/src/cursor-query.ts
+/**
+* CSI 6n Cursor Position Query
+*
+* Queries the terminal for the current cursor position using the standard
+* Device Status Report (DSR) mechanism.
+*
+* Protocol:
+* - Query:    CSI 6 n  (\x1b[6n)
+* - Response: CSI {row} ; {col} R  (\x1b[{row};{col}R)
+*
+* Row and column are 1-indexed in the protocol response.
+*
+* Supported by: virtually all terminals (VT100+)
+*/
+/** Regex to match a CPR response: CSI row ; col R */
+const CPR_RESPONSE_RE = /\x1b\[(\d+);(\d+)R/;
+/**
+* Query the terminal cursor position.
+*
+* Sends CSI 6n and parses the CPR response.
+* Returns 1-indexed row and column.
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin (resolves with data or null on timeout)
+* @param timeoutMs How long to wait for response (default: 200ms)
+*/
+async function queryCursorPosition(write, read, timeoutMs = 200) {
+	write("\x1B[6n");
+	const data = await read(timeoutMs);
+	if (data == null) return null;
+	const match = CPR_RESPONSE_RE.exec(data);
+	if (!match) return null;
+	return {
+		row: parseInt(match[1], 10),
+		col: parseInt(match[2], 10)
+	};
+}
+/**
+* Query cursor position using real stdin/stdout.
+* Convenience wrapper around queryCursorPosition.
+*/
+async function queryCursorFromStdio(stdout, stdin, timeoutMs = 200) {
+	const otherListeners = stdin.listenerCount("data") > 0;
+	const wasRaw = stdin.isRaw;
+	let didSetRaw = false;
+	if (!wasRaw && !otherListeners) {
+		stdin.setRawMode(true);
+		didSetRaw = true;
+	}
+	try {
+		const write = (s) => {
+			stdout.write(s);
+		};
+		const read = (ms) => new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				stdin.removeListener("data", onData);
+				resolve(null);
+			}, ms);
+			function onData(chunk) {
+				clearTimeout(timer);
+				stdin.removeListener("data", onData);
+				resolve(chunk.toString());
+			}
+			stdin.on("data", onData);
+		});
+		return await queryCursorPosition(write, read, timeoutMs);
+	} finally {
+		if (didSetRaw) stdin.setRawMode(false);
+	}
+}
+//#endregion
+//#region packages/ag-term/src/ansi/width-detection.ts
+/**
+* DEC Width Mode Detection (xterm patch #407)
+*
+* Queries the terminal for its character width settings using DECRQM
+* (DEC Private Mode Request). This replaces guesswork with definitive
+* answers from the terminal itself.
+*
+* Modes:
+* - 1020: UTF-8 mode
+* - 1021: CJK ambiguous width (1 or 2 cells)
+* - 1022: Emoji width (1 or 2 cells)
+* - 1023: Private-use area width (1 or 2 cells)
+*
+* Protocol:
+* - Query:    CSI ? {mode} $ p    (DECRQM)
+* - Response: CSI ? {mode} ; {Ps} $ y  (DECRPM)
+*
+* Where Ps is:
+*   1 = set (enabled / wide / 2-cell)
+*   2 = reset (disabled / narrow / 1-cell)
+*   0 = not recognized
+*   3 = permanently set
+*   4 = permanently reset
+*
+* @see https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+*/
+/** Well-known xterm width DEC mode numbers. */
+const WidthMode = {
+	/** UTF-8 mode */
+	UTF8: 1020,
+	/** CJK ambiguous character width */
+	CJK_WIDTH: 1021,
+	/** Emoji width */
+	EMOJI_WIDTH: 1022,
+	/** Private-use area width */
+	PRIVATE_USE_WIDTH: 1023
+};
+/** Default configuration when detection fails or times out. */
+const DEFAULT_WIDTH_CONFIG = {
+	utf8: true,
+	cjkWidth: 1,
+	emojiWidth: 2,
+	privateUseWidth: 1
+};
+/** Regex for DECRPM response: CSI ? mode ; Ps $ y */
+const DECRPM_RE = /\x1b\[\?(\d+);(\d+)\$y/g;
+/**
+* Parse a DECRPM response value into a boolean (set/reset).
+* 1 and 3 (permanently set) = true, everything else = false.
+*/
+function isSet(ps) {
+	return ps === 1 || ps === 3;
+}
+/**
+* Query a single DEC width mode via DECRQM.
+* Returns the Ps value from the DECRPM response, or null on timeout.
+*/
+function queryWidthMode(write, onData, mode, timeoutMs) {
+	return new Promise((resolve) => {
+		let timer = null;
+		let unsubscribe = null;
+		let buffer = "";
+		function cleanup() {
+			if (timer !== null) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			if (unsubscribe !== null) {
+				unsubscribe();
+				unsubscribe = null;
+			}
+		}
+		unsubscribe = onData((data) => {
+			buffer += data;
+			DECRPM_RE.lastIndex = 0;
+			let match;
+			while ((match = DECRPM_RE.exec(buffer)) !== null) if (parseInt(match[1], 10) === mode) {
+				const ps = parseInt(match[2], 10);
+				cleanup();
+				resolve(ps);
+				return;
+			}
+		});
+		timer = setTimeout(() => {
+			cleanup();
+			resolve(null);
+		}, timeoutMs);
+		write(`\x1b[?${mode}$p`);
+	});
+}
+/**
+* Apply detected width configuration to terminal capabilities.
+*
+* Post km-silvery.plateau-naming-polish (2026-04-23): `maybeWideEmojis` and
+* `textSizing` both live on caps, so the overlay returns a single updated
+* caps object. The mapping is:
+* - emojiWidth=2 → caps.maybeWideEmojis=true
+* - privateUseWidth=2 → caps.textSizing=true (PUA treated as 2-wide)
+*
+* CJK width and UTF-8 mode are informational — they don't yet map to caps
+* fields but are available in TerminalWidthConfig for consumers.
+*/
+function applyWidthConfig(caps, config) {
+	return {
+		...caps,
+		textSizing: config.privateUseWidth === 2,
+		maybeWideEmojis: config.emojiWidth === 2
+	};
+}
+/**
+* Create a width detector that queries the terminal for DEC modes 1020-1023.
+*
+* @example
+* ```ts
+* const detector = createWidthDetector({
+*   write: (data) => process.stdout.write(data),
+*   onData: (handler) => {
+*     process.stdin.on('data', (chunk) => handler(chunk.toString()))
+*     return () => process.stdin.removeListener('data', handler)
+*   },
+* })
+*
+* const config = await detector.detect()
+* console.log(config.emojiWidth) // 1 or 2
+* detector.dispose()
+* ```
+*/
+function createWidthDetector(options) {
+	const { write, onData, timeoutMs = 200 } = options;
+	let config = null;
+	let disposed = false;
+	return {
+		get config() {
+			return config;
+		},
+		async detect() {
+			if (disposed) return config ?? { ...DEFAULT_WIDTH_CONFIG };
+			if (config !== null) return config;
+			const utf8Ps = await queryWidthMode(write, onData, WidthMode.UTF8, timeoutMs);
+			const cjkPs = await queryWidthMode(write, onData, WidthMode.CJK_WIDTH, timeoutMs);
+			const emojiPs = await queryWidthMode(write, onData, WidthMode.EMOJI_WIDTH, timeoutMs);
+			const puaPs = await queryWidthMode(write, onData, WidthMode.PRIVATE_USE_WIDTH, timeoutMs);
+			config = {
+				utf8: utf8Ps !== null ? isSet(utf8Ps) : DEFAULT_WIDTH_CONFIG.utf8,
+				cjkWidth: cjkPs !== null ? isSet(cjkPs) ? 2 : 1 : DEFAULT_WIDTH_CONFIG.cjkWidth,
+				emojiWidth: emojiPs !== null ? isSet(emojiPs) ? 2 : 1 : DEFAULT_WIDTH_CONFIG.emojiWidth,
+				privateUseWidth: puaPs !== null ? isSet(puaPs) ? 2 : 1 : DEFAULT_WIDTH_CONFIG.privateUseWidth
+			};
+			return config;
+		},
+		dispose() {
+			disposed = true;
+		}
+	};
+}
+//#endregion
+//#region packages/ag-term/src/device-attrs.ts
+/**
+* Device Attributes (DA1/DA2/DA3) + XTVERSION Queries
+*
+* Provides functions to query terminal identity and capabilities using
+* the standard VT device attribute escape sequences.
+*
+* Protocols:
+*
+* DA1 (Primary Device Attributes):
+*   Query:    CSI c       (\x1b[c)
+*   Response: CSI ? Ps ; Ps ; ... c
+*
+* DA2 (Secondary Device Attributes):
+*   Query:    CSI > c     (\x1b[>c)
+*   Response: CSI > Pt ; Pv ; Pc c
+*   Where Pt=terminal type, Pv=firmware version, Pc=ROM cartridge id
+*
+* DA3 (Tertiary Device Attributes):
+*   Query:    CSI = c     (\x1b[=c)
+*   Response: DCS ! | hex-encoded-id ST  (\x1bP!|{hex}\x1b\\)
+*
+* XTVERSION (Terminal Name + Version):
+*   Query:    CSI > 0 q   (\x1b[>0q)
+*   Response: DCS > | name(version) ST  (\x1bP>|{text}\x1b\\)
+*
+* Supported by: xterm, Ghostty, Kitty, WezTerm, foot, VTE-based terminals
+*/
+/** Regex for DA1 response: CSI ? params c */
+const DA1_RESPONSE_RE = /\x1b\[\?([\d;]+)c/;
+/** Regex for DA2 response: CSI > params c */
+const DA2_RESPONSE_RE = /\x1b\[>([\d;]+)c/;
+/** Regex for DA3 response: DCS ! | hex ST */
+const DA3_RESPONSE_RE = /\x1bP!\|([0-9a-fA-F]*)\x1b\\/;
+/** Regex for XTVERSION response: DCS > | text ST */
+const XTVERSION_RESPONSE_RE = /\x1bP>\|([^\x1b]*)\x1b\\/;
+/**
+* Query primary device attributes (DA1).
+*
+* Returns the list of attribute parameters the terminal reports.
+* Common params: 1=132-cols, 4=sixel, 6=selective-erase, 22=ANSI-color
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin
+* @param timeoutMs How long to wait for response (default: 200ms)
+*/
+async function queryPrimaryDA(write, read, timeoutMs = 200) {
+	write("\x1B[c");
+	const data = await read(timeoutMs);
+	if (data == null) return null;
+	const match = DA1_RESPONSE_RE.exec(data);
+	if (!match) return null;
+	return { params: match[1].split(";").map((s) => parseInt(s, 10)) };
+}
+/**
+* Query secondary device attributes (DA2).
+*
+* Returns terminal type, firmware version, and ROM cartridge id.
+* Common type values: 0=VT100, 1=VT220, 41=xterm, 65=VT500
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin
+* @param timeoutMs How long to wait for response (default: 200ms)
+*/
+async function querySecondaryDA(write, read, timeoutMs = 200) {
+	write("\x1B[>c");
+	const data = await read(timeoutMs);
+	if (data == null) return null;
+	const match = DA2_RESPONSE_RE.exec(data);
+	if (!match) return null;
+	const parts = match[1].split(";");
+	if (parts.length < 3) return null;
+	return {
+		type: parseInt(parts[0], 10),
+		version: parseInt(parts[1], 10),
+		id: parseInt(parts[2], 10)
+	};
+}
+/**
+* Query tertiary device attributes (DA3).
+*
+* Returns a hex-encoded unit ID string. Decode with Buffer.from(hex, 'hex').
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin
+* @param timeoutMs How long to wait for response (default: 200ms)
+*/
+async function queryTertiaryDA(write, read, timeoutMs = 200) {
+	write("\x1B[=c");
+	const data = await read(timeoutMs);
+	if (data == null) return null;
+	const match = DA3_RESPONSE_RE.exec(data);
+	if (!match) return null;
+	return match[1];
+}
+/**
+* Query the terminal name and version via XTVERSION.
+*
+* Returns the version string as reported by the terminal, e.g.:
+* - "xterm(388)"
+* - "tmux 3.4"
+* - "WezTerm 20230712-072601-f4abf8fd"
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin
+* @param timeoutMs How long to wait for response (default: 200ms)
+*/
+async function queryTerminalVersion(write, read, timeoutMs = 200) {
+	write("\x1B[>0q");
+	const data = await read(timeoutMs);
+	if (data == null) return null;
+	const match = XTVERSION_RESPONSE_RE.exec(data);
+	if (!match) return null;
+	return match[1];
+}
+/**
+* Query all device attributes: DA1, DA2, and XTVERSION.
+*
+* Convenience wrapper that queries all three sequentially.
+* DA3 is omitted from the combined query as it's rarely needed.
+*
+* @param stdout Writable stream (e.g., process.stdout)
+* @param stdin Readable stream (e.g., process.stdin)
+* @param timeoutMs Per-query timeout (default: 200ms)
+*/
+async function queryDeviceAttributes(stdout, stdin, timeoutMs = 200) {
+	const otherListeners = stdin.listenerCount("data") > 0;
+	const wasRaw = stdin.isRaw;
+	let didSetRaw = false;
+	if (!wasRaw && !otherListeners) {
+		stdin.setRawMode(true);
+		didSetRaw = true;
+	}
+	try {
+		const write = (s) => {
+			stdout.write(s);
+		};
+		const read = (ms) => new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				stdin.removeListener("data", onData);
+				resolve(null);
+			}, ms);
+			function onData(chunk) {
+				clearTimeout(timer);
+				stdin.removeListener("data", onData);
+				resolve(chunk.toString());
+			}
+			stdin.on("data", onData);
+		});
+		return {
+			da1: await queryPrimaryDA(write, read, timeoutMs),
+			da2: await querySecondaryDA(write, read, timeoutMs),
+			version: await queryTerminalVersion(write, read, timeoutMs)
+		};
+	} finally {
+		if (didSetRaw) stdin.setRawMode(false);
+	}
+}
+//#endregion
+//#region packages/ag-term/src/mode-query.ts
+/**
+* DECRQM — DEC Private Mode Query
+*
+* Queries the terminal for the state of DEC private modes.
+*
+* Protocol:
+* - Query:    CSI ? {mode} $ p
+* - Response: CSI ? {mode} ; {Ps} $ y
+*
+* Where Ps is:
+*   1 = set (mode is enabled)
+*   2 = reset (mode is disabled)
+*   0 = not recognized (unknown mode)
+*   3 = permanently set
+*   4 = permanently reset
+*
+* We normalize 3→"set" and 4→"reset" for simplicity.
+*
+* Supported by: xterm, Ghostty, Kitty, WezTerm, foot, VTE-based terminals
+*/
+/** Regex for DECRPM response: CSI ? mode ; Ps $ y */
+const DECRPM_RESPONSE_RE = /\x1b\[\?(\d+);(\d+)\$y/;
+/** Well-known DEC private mode constants. */
+const DecMode = {
+	/** DEC cursor visible (DECTCEM) */
+	CURSOR_VISIBLE: 25,
+	/** Alternate screen buffer (DECSET 1049) */
+	ALT_SCREEN: 1049,
+	/** Normal mouse tracking (X10) */
+	MOUSE_TRACKING: 1e3,
+	/** Bracketed paste mode */
+	BRACKETED_PASTE: 2004,
+	/** Synchronized output */
+	SYNC_OUTPUT: 2026,
+	/** Focus reporting */
+	FOCUS_REPORTING: 1004
+};
+/**
+* Query the state of a single DEC private mode.
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin
+* @param mode DEC private mode number (e.g., DecMode.ALT_SCREEN)
+* @param timeoutMs How long to wait for response (default: 200ms)
+* @returns "set", "reset", or "unknown"
+*/
+async function queryMode(write, read, mode, timeoutMs = 200) {
+	write(`\x1b[?${mode}$p`);
+	const data = await read(timeoutMs);
+	if (data == null) return "unknown";
+	const match = DECRPM_RESPONSE_RE.exec(data);
+	if (!match) return "unknown";
+	if (parseInt(match[1], 10) !== mode) return "unknown";
+	switch (parseInt(match[2], 10)) {
+		case 1:
+		case 3: return "set";
+		case 2:
+		case 4: return "reset";
+		default: return "unknown";
+	}
+}
+/**
+* Query the state of multiple DEC private modes.
+*
+* Queries each mode sequentially and returns a Map of results.
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin
+* @param modes Array of DEC private mode numbers
+* @param timeoutMs Per-query timeout (default: 200ms)
+*/
+async function queryModes(write, read, modes, timeoutMs = 200) {
+	const results = /* @__PURE__ */ new Map();
+	for (const mode of modes) {
+		const state = await queryMode(write, read, mode, timeoutMs);
+		results.set(mode, state);
+	}
+	return results;
+}
+//#endregion
+//#region packages/ag-term/src/pixel-size.ts
+/**
+* CSI 14t/18t — Terminal Pixel and Text Area Size Queries
+*
+* Queries the terminal for window dimensions in pixels and characters.
+*
+* Protocols:
+*
+* Text Area Pixels (CSI 14t):
+*   Query:    CSI 14 t
+*   Response: CSI 4 ; height ; width t
+*
+* Text Area Size in Characters (CSI 18t):
+*   Query:    CSI 18 t
+*   Response: CSI 8 ; rows ; cols t
+*
+* Cell size can be derived by dividing pixel dimensions by character dimensions.
+*
+* Supported by: xterm, Ghostty, Kitty, WezTerm, foot, iTerm2
+*/
+/** Regex for CSI 4 ; height ; width t (pixel size response) */
+const PIXEL_RESPONSE_RE = /\x1b\[4;(\d+);(\d+)t/;
+/** Regex for CSI 8 ; rows ; cols t (text area size response) */
+const TEXT_AREA_RESPONSE_RE = /\x1b\[8;(\d+);(\d+)t/;
+/**
+* Query the terminal text area size in pixels.
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin
+* @param timeoutMs How long to wait for response (default: 200ms)
+* @returns Width and height in pixels, or null on timeout/unsupported
+*/
+async function queryTextAreaPixels(write, read, timeoutMs = 200) {
+	write("\x1B[14t");
+	const data = await read(timeoutMs);
+	if (data == null) return null;
+	const match = PIXEL_RESPONSE_RE.exec(data);
+	if (!match) return null;
+	return {
+		height: parseInt(match[1], 10),
+		width: parseInt(match[2], 10)
+	};
+}
+/**
+* Query the terminal text area size in characters (rows x columns).
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin
+* @param timeoutMs How long to wait for response (default: 200ms)
+* @returns Rows and columns, or null on timeout/unsupported
+*/
+async function queryTextAreaSize(write, read, timeoutMs = 200) {
+	write("\x1B[18t");
+	const data = await read(timeoutMs);
+	if (data == null) return null;
+	const match = TEXT_AREA_RESPONSE_RE.exec(data);
+	if (!match) return null;
+	return {
+		rows: parseInt(match[1], 10),
+		cols: parseInt(match[2], 10)
+	};
+}
+/**
+* Query the terminal cell size in pixels by querying both pixel
+* dimensions and character dimensions, then dividing.
+*
+* @param write Function to write to stdout
+* @param read Function to read a chunk from stdin
+* @param timeoutMs Per-query timeout (default: 200ms)
+* @returns Cell width and height in pixels, or null if either query fails
+*/
+async function queryCellSize(write, read, timeoutMs = 200) {
+	const pixels = await queryTextAreaPixels(write, read, timeoutMs);
+	if (pixels == null) return null;
+	const size = await queryTextAreaSize(write, read, timeoutMs);
+	if (size == null) return null;
+	if (size.cols === 0 || size.rows === 0) return null;
+	return {
+		width: pixels.width / size.cols,
+		height: pixels.height / size.rows
+	};
+}
+//#endregion
+//#region packages/ag-term/src/term-def.ts
+/**
+* Default dimensions when not detectable.
+*/
+const DEFAULT_WIDTH = 80;
+const DEFAULT_HEIGHT = 24;
+/**
+* Check if a value is a Term instance (duck typing).
+*
+* Post km-silvery.caps-restructure Phase 7: the legacy hasCursor/hasInput/
+* hasColor methods were removed — caps/profile/write/size are the canonical
+* Term surface.
+*/
+function isTerm(value) {
+	if (!value || typeof value !== "object" && typeof value !== "function") return false;
+	const obj = value;
+	return typeof obj.caps === "object" && obj.caps !== null && typeof obj.write === "function" && typeof obj.size === "object";
+}
+/**
+* Check if a value is a TermDef (not a Term).
+*/
+function isTermDef(value) {
+	if (!value || typeof value !== "object") return false;
+	return value.caps === void 0;
+}
+/**
+* Resolve a TermDef into concrete values.
+*
+* @param def - TermDef to resolve
+* @returns Resolved values ready for rendering
+*/
+function resolveTermDef(def) {
+	const width = def.width ?? def.stdout?.columns ?? DEFAULT_WIDTH;
+	const height = def.height ?? def.stdout?.rows ?? DEFAULT_HEIGHT;
+	let colors;
+	if (def.colors === true) colors = detectColorLevel(def.stdout);
+	else if (def.colors === false || def.colors === null) colors = "mono";
+	else if (def.colors) colors = def.colors;
+	else colors = detectColorLevel(def.stdout);
+	let events = null;
+	if (def.events) events = def.events;
+	else if (def.stdin) events = createInputEvents(def.stdin);
+	return {
+		stdout: def.stdout ?? null,
+		width,
+		height,
+		colors,
+		events,
+		isStatic: events === null
+	};
+}
+/**
+* Resolve a Term instance into ResolvedTermDef.
+*
+* @param term - Term instance
+* @returns Resolved values
+*/
+function resolveFromTerm(term) {
+	const { stdin, stdout } = getInternalStreams(term);
+	return {
+		stdout,
+		width: term.cols ?? DEFAULT_WIDTH,
+		height: term.rows ?? DEFAULT_HEIGHT,
+		colors: term.profile.colorLevel,
+		events: createInputEvents(stdin),
+		isStatic: false
+	};
+}
+/**
+* Detect the color tier from a stdout stream.
+*
+* Phase 3 of km-silvery.terminal-profile-plateau: this is now a single-line
+* delegate into `createTerminalProfile` — no more local detection copy.
+*/
+function detectColorLevel(stdout) {
+	return createTerminalProfile({ stdout: stdout ?? { isTTY: false } }).colorLevel;
+}
+/**
+* Create an async iterable of input events from a stdin stream.
+*
+* This enables interactive mode by providing a source of keyboard events.
+*/
+function createInputEvents(stdin) {
+	return { [Symbol.asyncIterator]() {
+		const buffer = [];
+		let resolveNext = null;
+		let done = false;
+		const handleData = (chunk) => {
+			const data = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+			for (const char of data) {
+				const event = {
+					type: "key",
+					key: char,
+					ctrl: char.charCodeAt(0) < 32 && char !== "\r" && char !== "\n" && char !== "	"
+				};
+				if (resolveNext) {
+					resolveNext({
+						value: event,
+						done: false
+					});
+					resolveNext = null;
+				} else buffer.push(event);
+			}
+		};
+		const handleEnd = () => {
+			done = true;
+			if (resolveNext) {
+				resolveNext({
+					value: void 0,
+					done: true
+				});
+				resolveNext = null;
+			}
+		};
+		if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+			stdin.setEncoding("utf8");
+			stdin.on("data", handleData);
+			stdin.on("end", handleEnd);
+		}
+		return {
+			next() {
+				const buffered = buffer.shift();
+				if (buffered) return Promise.resolve({
+					value: buffered,
+					done: false
+				});
+				if (done) return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+				return new Promise((resolve) => {
+					resolveNext = resolve;
+				});
+			},
+			return() {
+				done = true;
+				stdin.off("data", handleData);
+				stdin.off("end", handleEnd);
+				return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+			}
+		};
+	} };
+}
+//#endregion
+//#region packages/ag-term/src/non-tty.ts
+/**
+* Non-TTY Mode Support for Silvery
+*
+* Provides detection and rendering modes for non-interactive environments:
+* - Piped output (process.stdout.isTTY === false)
+* - CI environments
+* - TERM=dumb
+*
+* When in non-TTY mode, silvery avoids cursor positioning codes that garble
+* output in non-interactive environments.
+*
+* Modes:
+* - 'auto': Detect based on environment (default)
+* - 'tty': Force TTY mode (normal cursor positioning)
+* - 'line-by-line': Simple newline-separated output, no cursor movement
+* - 'static': Single output at end (no updates)
+* - 'plain': Strip all ANSI codes
+*/
+/**
+* Check if the environment is a TTY.
+*
+* Returns false if:
+* - stdout.isTTY is false or undefined
+* - TERM=dumb
+* - CI environment variables are set
+*
+* Pass `emulator` (from `term.emulator` or a TerminalEmulator fixture) when
+* available to avoid a redundant env read. Without it, the TERM=dumb check
+* delegates to {@link createTerminalProfile} — the canonical single-source-
+* of-truth entry in `@silvery/ansi/profile`. CI env vars remain read
+* directly because they are orthogonal to terminal capabilities (a CI
+* runner's TTY status doesn't describe what the terminal can render).
+*/
+function isTTY(stdout = process.stdout, emulator) {
+	if (!stdout.isTTY) return false;
+	if ((emulator?.TERM ?? createTerminalProfile().emulator.TERM) === "dumb") return false;
+	if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.JENKINS_URL || process.env.BUILDKITE || process.env.CIRCLECI || process.env.TRAVIS) return false;
+	return true;
+}
+/**
+* Resolve the non-TTY mode based on options and environment.
+*
+* When mode is 'auto':
+* - If TTY detected: returns 'tty'
+* - If non-TTY detected: returns 'line-by-line'
+*/
+function resolveNonTTYMode(options = {}) {
+	const { mode = "auto", stdout = process.stdout } = options;
+	if (mode !== "auto") return mode;
+	return isTTY(stdout) ? "tty" : "line-by-line";
+}
+/**
+* Convert buffer output to line-by-line format.
+*
+* Instead of using cursor positioning, outputs each line with a simple
+* carriage return and clear-to-end-of-line sequence.
+*
+* @param content The rendered content (may contain ANSI codes but no cursor positioning)
+* @param prevLineCount Number of lines in the previous frame (for clearing)
+* @returns Output string suitable for non-TTY rendering
+*/
+function toLineByLineOutput(content, prevLineCount) {
+	const lines = content.split("\n");
+	let output = "";
+	if (prevLineCount > 0) {
+		output += "\r";
+		if (prevLineCount > 1) output += `\x1b[${prevLineCount - 1}A`;
+	}
+	for (let i = 0; i < lines.length; i++) {
+		if (i > 0) output += "\n";
+		output += lines[i];
+		output += "\x1B[K";
+	}
+	const extraLines = prevLineCount - lines.length;
+	if (extraLines > 0) {
+		for (let i = 0; i < extraLines; i++) output += "\n\x1B[K";
+		output += `\x1b[${extraLines}A`;
+	}
+	return output;
+}
+/**
+* Convert buffer output to plain text format.
+*
+* Strips all ANSI codes and outputs simple newline-separated text.
+* No cursor movement or clearing.
+*
+* @param content The rendered content
+* @param prevLineCount Number of lines in the previous frame (unused in plain mode)
+* @returns Plain text output
+*/
+function toPlainOutput(content, _prevLineCount) {
+	const lines = stripAnsi(content).split("\n").map((line) => line.trimEnd());
+	while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return lines.join("\n");
+}
+/**
+* Create an output transformer based on the non-TTY mode.
+*
+* @param mode The resolved non-TTY mode
+* @returns A function that transforms output based on the mode
+*/
+function createOutputTransformer(mode) {
+	switch (mode) {
+		case "tty": return (content) => content;
+		case "line-by-line": return toLineByLineOutput;
+		case "static": return () => "";
+		case "plain": return toPlainOutput;
+	}
+}
+/**
+* Count the number of lines in a string.
+*/
+function countLines(str) {
+	if (!str) return 0;
+	return str.split("\n").length;
+}
+//#endregion
+//#region packages/ag-term/src/inspector.ts
+let inspectorEnabled = false;
+let inspectorOutput = process.stderr;
+/** Enable the silvery inspector. */
+function enableInspector(options) {
+	inspectorEnabled = true;
+	if (options?.logFile) inspectorOutput = process.getBuiltinModule("node:fs").createWriteStream(options.logFile, { flags: "a" });
+	else if (options?.output) inspectorOutput = options.output;
+	else inspectorOutput = process.stderr;
+}
+/** Disable the inspector. */
+function disableInspector() {
+	inspectorEnabled = false;
+}
+/** Check if inspector is active. */
+function isInspectorEnabled() {
+	return inspectorEnabled;
+}
+/**
+* Log render stats after each frame.
+*
+* Called by the scheduler after doRender completes. When the inspector
+* is disabled this is a no-op (zero overhead).
+*/
+function inspectFrame(stats) {
+	if (!inspectorEnabled) return;
+	const line = `[silvery] frame #${stats.renderCount} ${stats.lastRenderTime.toFixed(1)}ms avg=${stats.avgRenderTime.toFixed(1)}ms skipped=${stats.skippedCount}\n`;
+	inspectorOutput.write(line);
+}
+/**
+* Dump the component tree structure as indented text.
+*
+* Walks the SilveryNode tree and formats each node with its type, testID,
+* layout rect, and dirty flags.
+*/
+function inspectTree(rootNode, options) {
+	const maxDepth = options?.depth ?? 10;
+	const showLayout = options?.showLayout ?? true;
+	const lines = [];
+	function walk(node, indent) {
+		if (indent > maxDepth) return;
+		const prefix = "  ".repeat(indent);
+		const type = node.type;
+		const testID = node.props?.testID;
+		const idStr = testID ? ` #${testID}` : "";
+		let rectStr = "";
+		if (showLayout) {
+			if (node.boxRect) {
+				const r = node.boxRect;
+				rectStr = ` [${r.x},${r.y} ${r.width}x${r.height}]`;
+			} else if (node.layoutNode) {
+				const ln = node.layoutNode;
+				rectStr = ` [${ln.getComputedLeft()},${ln.getComputedTop()} ${ln.getComputedWidth()}x${ln.getComputedHeight()}]`;
+			}
+		}
+		const dirtyFlags = [];
+		if (node.layoutNode?.isDirty()) dirtyFlags.push("layout");
+		if (isDirty(node.dirtyBits, node.dirtyEpoch, 1)) dirtyFlags.push("content");
+		if (isDirty(node.dirtyBits, node.dirtyEpoch, 2)) dirtyFlags.push("paint");
+		if (isDirty(node.dirtyBits, node.dirtyEpoch, 4)) dirtyFlags.push("bg");
+		if (isDirty(node.dirtyBits, node.dirtyEpoch, 16)) dirtyFlags.push("subtree");
+		if (isDirty(node.dirtyBits, node.dirtyEpoch, 8)) dirtyFlags.push("children");
+		const dirtyStr = dirtyFlags.length > 0 ? ` dirty=[${dirtyFlags.join(",")}]` : "";
+		const textStr = node.textContent ? ` "${node.textContent.slice(0, 30)}${node.textContent.length > 30 ? "..." : ""}"` : "";
+		lines.push(`${prefix}${type}${idStr}${rectStr}${dirtyStr}${textStr}`);
+		for (const child of node.children) walk(child, indent + 1);
+	}
+	walk(rootNode, 0);
+	return lines.join("\n");
+}
+/**
+* Auto-enable if SILVERY_DEV=1 is set.
+*
+* Call this at startup to respect the environment variable convention.
+*/
+function autoEnableInspector() {
+	if (process.env.SILVERY_DEV === "1" || process.env.SILVERY_DEV === "true") {
+		const logFile = process.env.SILVERY_DEV_LOG;
+		enableInspector(logFile ? { logFile } : void 0);
+	}
+}
+//#endregion
+//#region packages/ag-term/src/measurer.ts
+/**
+* Extend a Term with measurement capabilities.
+*
+* Creates a width measurer from the term's caps and adds measurement
+* methods (displayWidth, graphemeWidth, wrapText, etc.) to the term.
+*/
+function withMeasurer(term) {
+	const caps = term.caps;
+	const measurer = createMeasurer(caps ?? {});
+	return Object.create(term, {
+		maybeWideEmojis: {
+			get: () => measurer.maybeWideEmojis,
+			enumerable: true
+		},
+		textSizing: {
+			get: () => measurer.textSizing,
+			enumerable: true
+		},
+		displayWidth: {
+			value: measurer.displayWidth.bind(measurer),
+			enumerable: true
+		},
+		displayWidthAnsi: {
+			value: measurer.displayWidthAnsi.bind(measurer),
+			enumerable: true
+		},
+		graphemeWidth: {
+			value: measurer.graphemeWidth.bind(measurer),
+			enumerable: true
+		},
+		wrapText: {
+			value: measurer.wrapText.bind(measurer),
+			enumerable: true
+		},
+		sliceByWidth: {
+			value: measurer.sliceByWidth.bind(measurer),
+			enumerable: true
+		},
+		sliceByWidthFromEnd: {
+			value: measurer.sliceByWidthFromEnd.bind(measurer),
+			enumerable: true
+		}
+	});
+}
+/**
+* Create a pipeline configuration from caps and/or measurer.
+*
+* This is the single factory for PipelineConfig -- use it instead of
+* manually constructing { measurer, outputPhaseFn }.
+*
+* @param options.caps - Terminal capabilities (for output phase SGR generation).
+*   Reads `caps.maybeWideEmojis` (text-presentation emoji width) and
+*   `caps.textSizing` for measurement.
+* @param options.measurer - Explicit measurer (if omitted, created from caps)
+*/
+function createPipeline(options = {}) {
+	const { caps, measurer: explicitMeasurer } = options;
+	const measurer = explicitMeasurer ?? createMeasurer(caps ?? {});
+	const outputPhaseFn = createOutputPhase(caps ? {
+		underlineStyles: caps.underlineStyles,
+		underlineColor: caps.underlineColor,
+		overline: caps.overline,
+		colorLevel: caps.colorLevel
+	} : {}, measurer);
+	if (caps?.colorLevel) setActiveColorLevel(caps.colorLevel);
+	return {
+		measurer,
+		outputPhaseFn
+	};
+}
+//#endregion
+//#region packages/headless/src/selection.ts
+/**
+* Check if a character is a word character (not whitespace/punctuation).
+* Word chars: letters, digits, underscore (matching \w).
+*/
+function isWordChar(ch) {
+	return /\w/.test(ch);
+}
+/**
+* Find word boundaries at a given column in the buffer row.
+* Returns { startCol, endCol } inclusive of the word.
+* If the position is on whitespace/punctuation, selects that single char.
+*/
+function findWordBoundary(buffer, col, row) {
+	const width = buffer.width;
+	const ch = buffer.getCell(col, row).char;
+	if (isWordChar(ch)) {
+		let startCol = col;
+		while (startCol > 0 && isWordChar(buffer.getCell(startCol - 1, row).char)) startCol--;
+		let endCol = col;
+		while (endCol < width - 1 && isWordChar(buffer.getCell(endCol + 1, row).char)) endCol++;
+		return {
+			startCol,
+			endCol
+		};
+	}
+	return {
+		startCol: col,
+		endCol: col
+	};
+}
+/**
+* Find line boundaries for a given row.
+* Returns { startCol, endCol } spanning from first content to last content.
+* If the row is empty, returns { startCol: 0, endCol: width - 1 }.
+*/
+function findLineBoundary(buffer, row) {
+	const width = buffer.width;
+	let endCol = width - 1;
+	while (endCol > 0 && buffer.getCell(endCol, row).char.trim() === "") endCol--;
+	let startCol = 0;
+	while (startCol < endCol && buffer.getCell(startCol, row).char.trim() === "") startCol++;
+	if (startCol >= endCol && buffer.getCell(startCol, row).char.trim() === "") return {
+		startCol: 0,
+		endCol: width - 1
+	};
+	return {
+		startCol,
+		endCol
+	};
+}
+/**
+* Extend the head position according to the current granularity.
+* For word granularity: snaps to word boundaries.
+* For line granularity: snaps to line boundaries.
+*/
+function extendByGranularity(col, row, anchor, granularity, buffer) {
+	if (granularity === "character" || !buffer) return {
+		col,
+		row
+	};
+	if (granularity === "word") {
+		const { startCol, endCol } = findWordBoundary(buffer, col, row);
+		return row > anchor.row || row === anchor.row && col >= anchor.col ? {
+			col: endCol,
+			row
+		} : {
+			col: startCol,
+			row
+		};
+	}
+	if (granularity === "line") {
+		const { startCol, endCol } = findLineBoundary(buffer, row);
+		return row > anchor.row || row === anchor.row && col >= anchor.col ? {
+			col: endCol,
+			row
+		} : {
+			col: startCol,
+			row
+		};
+	}
+	return {
+		col,
+		row
+	};
+}
+function createTerminalSelectionState() {
+	return {
+		range: null,
+		selecting: false,
+		source: null,
+		granularity: "character",
+		scope: null
+	};
+}
+/**
+* Clamp a position to a scope boundary.
+*/
+function clampToScope(col, row, scope) {
+	if (!scope) return {
+		col,
+		row
+	};
+	return {
+		col: Math.max(scope.left, Math.min(scope.right, col)),
+		row: Math.max(scope.top, Math.min(scope.bottom, row))
+	};
+}
+function terminalSelectionUpdate(action, state) {
+	switch (action.type) {
+		case "start": {
+			const scope = action.scope ?? null;
+			const pos = clampToScope(action.col, action.row, scope);
+			return [{
+				range: {
+					anchor: pos,
+					head: pos
+				},
+				selecting: true,
+				source: action.source ?? "mouse",
+				granularity: "character",
+				scope
+			}, [{ type: "render" }]];
+		}
+		case "startWord": {
+			const scope = action.scope ?? null;
+			const { startCol, endCol } = findWordBoundary(action.buffer, action.col, action.row);
+			return [{
+				range: {
+					anchor: clampToScope(startCol, action.row, scope),
+					head: clampToScope(endCol, action.row, scope)
+				},
+				selecting: true,
+				source: action.source ?? "mouse",
+				granularity: "word",
+				scope
+			}, [{ type: "render" }]];
+		}
+		case "startLine": {
+			const scope = action.scope ?? null;
+			const { startCol, endCol } = findLineBoundary(action.buffer, action.row);
+			return [{
+				range: {
+					anchor: clampToScope(startCol, action.row, scope),
+					head: clampToScope(endCol, action.row, scope)
+				},
+				selecting: true,
+				source: action.source ?? "mouse",
+				granularity: "line",
+				scope
+			}, [{ type: "render" }]];
+		}
+		case "extend": {
+			if (!state.selecting) return [state, []];
+			const scope = "scope" in action ? action.scope ?? null : state.scope;
+			const extended = extendByGranularity(action.col, action.row, state.range.anchor, state.granularity, action.buffer);
+			const head = clampToScope(extended.col, extended.row, scope);
+			return [{
+				...state,
+				range: {
+					anchor: state.range.anchor,
+					head
+				},
+				scope,
+				selecting: true
+			}, [{ type: "render" }]];
+		}
+		case "finish":
+			if (!state.range) return [{
+				...state,
+				selecting: false
+			}, []];
+			return [{
+				...state,
+				range: state.range,
+				selecting: false
+			}, []];
+		case "clear": {
+			const hadRange = state.range !== null;
+			return [createTerminalSelectionState(), hadRange ? [{ type: "render" }] : []];
+		}
+	}
+}
+function normalizeRange(range) {
+	const { anchor, head } = range;
+	if (anchor.row < head.row || anchor.row === head.row && anchor.col <= head.col) return {
+		startRow: anchor.row,
+		startCol: anchor.col,
+		endRow: head.row,
+		endCol: head.col
+	};
+	return {
+		startRow: head.row,
+		startCol: head.col,
+		endRow: anchor.row,
+		endCol: anchor.col
+	};
+}
+/**
+* Extract text from a buffer within a selection range.
+*
+* Handles:
+* - Soft-wrap joining (via RowMetadata.softWrapped) — rejoins wrapped visual
+*   rows into their logical line, reinserting the word-wrap break space
+*   (RowMetadata.wrapJoinSpace) that trim-mode rendering stripped
+* - Trailing fill exclusion (clamp to RowMetadata.lastContentCol; falls back
+*   to a trailing-whitespace trim when a row carries no metadata)
+* - Blank line preservation within selection
+* - Wide-char continuation cell skipping
+* - SELECTABLE_FLAG filtering (when respectSelectableFlag is true)
+* - Contain-scope clipping (when options.scope is set)
+*/
+function extractText(buffer, range, options) {
+	const { startRow, startCol, endRow, endCol } = normalizeRange(range);
+	const respectSelectable = options?.respectSelectableFlag ?? true;
+	const rowMeta = options?.rowMetadata;
+	const scope = options?.scope;
+	const parts = [];
+	for (let row = startRow; row <= endRow; row++) {
+		const meta = rowMeta?.[row];
+		let colStart = row === startRow ? startCol : 0;
+		let colEnd = row === endRow ? endCol : buffer.width - 1;
+		if (scope) {
+			colStart = Math.max(colStart, scope.left);
+			colEnd = Math.min(colEnd, scope.right);
+			if (colStart > colEnd) {
+				if (!(meta?.softWrapped && row < endRow)) {
+					parts.push("");
+					if (row < endRow) parts.push("\n");
+				}
+				continue;
+			}
+		}
+		if (meta && meta.lastContentCol >= 0) colEnd = Math.min(colEnd, meta.lastContentCol);
+		let line = "";
+		for (let col = colStart; col <= colEnd; col++) {
+			if (buffer.isCellContinuation(col, row)) continue;
+			if (respectSelectable && !buffer.isCellSelectable(col, row)) continue;
+			line += buffer.getCellChar(col, row);
+		}
+		if (!meta || meta.lastContentCol < 0) line = line.replace(/\s+$/, "");
+		if (meta?.softWrapped && row < endRow) {
+			parts.push(line);
+			if (meta.wrapJoinSpace) parts.push(" ");
+		} else {
+			parts.push(line);
+			if (row < endRow) parts.push("\n");
+		}
+	}
+	return parts.join("");
+}
+//#endregion
+//#region packages/ag-term/src/selection-renderer.ts
+function normalizeSelectionColor(color) {
+	if (color === void 0) return void 0;
+	if (typeof color === "string") return parseColor(color);
+	return color;
+}
+/**
+* Compute selection style changes for all cells within a selection range.
+*
+* Returns a sparse list of cell changes (fg/bg only). The caller applies these
+* to the buffer before the output phase diffs it. This approach:
+* - Composes correctly with existing cell styles
+* - Handles already-inverted content (swaps back to normal instead of double-inverting)
+* - Respects SELECTABLE_FLAG per cell (skip non-selectable)
+* - Works with the normal diff/output renderer (no separate ANSI pass)
+*
+* @param buffer The rendered buffer (post-render-phase)
+* @param selection Current selection range, or null
+* @param theme Optional selection theme colors
+* @param respectSelectableFlag When true, skip cells without SELECTABLE_FLAG
+*/
+function composeSelectionCells(buffer, selection, theme, respectSelectableFlag = false, scope) {
+	if (!selection) return [];
+	const { startRow, startCol, endRow, endCol } = normalizeRange(selection);
+	const changes = [];
+	for (let row = startRow; row <= endRow; row++) {
+		let colStart = row === startRow ? startCol : 0;
+		let colEnd = row === endRow ? endCol : buffer.width - 1;
+		const rowMeta = buffer.getRowMeta(row);
+		if (rowMeta.lastContentCol >= 0) colEnd = Math.min(colEnd, rowMeta.lastContentCol);
+		if (colStart > colEnd) continue;
+		if (scope) {
+			colStart = Math.max(colStart, scope.left);
+			colEnd = Math.min(colEnd, scope.right);
+			if (colStart > colEnd) continue;
+		}
+		const firstContentCol = findFirstContentCol(buffer, row, colStart, colEnd, respectSelectableFlag);
+		if (firstContentCol === null) continue;
+		colStart = Math.max(colStart, firstContentCol);
+		for (let col = colStart; col <= colEnd; col++) {
+			if (buffer.isCellContinuation(col, row)) continue;
+			if (respectSelectableFlag && !buffer.isCellSelectable(col, row)) continue;
+			const cellFg = buffer.getCellFg(col, row);
+			const cellBg = buffer.getCellBg(col, row);
+			let newFg;
+			let newBg;
+			let inverseAttr = false;
+			if (theme?.selectionBg != null) {
+				newFg = theme.selectionFg ?? cellFg;
+				newBg = theme.selectionBg;
+			} else if (cellFg == null || cellBg == null) {
+				newFg = cellFg;
+				newBg = cellBg;
+				inverseAttr = true;
+			} else {
+				newFg = cellBg;
+				newBg = cellFg;
+			}
+			changes.push({
+				col,
+				row,
+				fg: newFg,
+				bg: newBg,
+				inverseAttr
+			});
+		}
+	}
+	return changes;
+}
+function findFirstContentCol(buffer, row, colStart, colEnd, respectSelectableFlag) {
+	for (let col = colStart; col <= colEnd; col++) {
+		if (buffer.isCellContinuation(col, row)) continue;
+		if (respectSelectableFlag && !buffer.isCellSelectable(col, row)) continue;
+		if (buffer.getCell(col, row).char.trim().length > 0) return col;
+	}
+	return null;
+}
+/**
+* Apply selection style changes to a buffer.
+*
+* Modifies the buffer in-place by setting fg/bg on affected cells.
+* Call this after the render phase and before the output phase.
+*
+* @param buffer The rendered buffer to modify
+* @param changes Cell changes from composeSelectionCells
+*/
+function applySelectionToBuffer(buffer, changes) {
+	for (const change of changes) {
+		const cell = buffer.getCell(change.col, change.row);
+		if (change.inverseAttr) buffer.setCell(change.col, change.row, {
+			...cell,
+			attrs: {
+				...cell.attrs,
+				inverse: !cell.attrs.inverse
+			}
+		});
+		else buffer.setCell(change.col, change.row, {
+			...cell,
+			fg: normalizeSelectionColor(change.fg) ?? null,
+			bg: normalizeSelectionColor(change.bg) ?? null
+		});
+	}
+}
+/**
+* Compute search-highlight style changes for a list of highlight ranges.
+*
+* Returns a sparse list of cell changes (fg/bg only) — apply them with
+* `applySelectionToBuffer` (the apply step is style-source-agnostic — it
+* just sets fg/bg or toggles inverse on the cells you give it).
+*
+* Default behaviour mirrors the legacy `renderSearchHighlights` that wrote
+* `\x1b[7m...\x1b[27m` past the buffer: cells with default fg/bg get the
+* inverse-attr toggle (so the terminal handles the SGR 7 swap at display).
+* Cells with explicit fg/bg get a direct fg↔bg swap. A theme can override
+* with explicit `selectionFg` / `selectionBg` tokens.
+*
+* Tracking: km-silvery.delete-search-overlay-ansi
+*/
+function composeSearchHighlightCells(buffer, highlights, theme) {
+	if (highlights.length === 0) return [];
+	const changes = [];
+	for (const h of highlights) {
+		const row = h.screenRow;
+		if (row < 0 || row >= buffer.height) continue;
+		const colStart = Math.max(0, h.startCol);
+		const colEnd = Math.min(buffer.width - 1, h.endCol);
+		if (colStart > colEnd) continue;
+		for (let col = colStart; col <= colEnd; col++) {
+			if (buffer.isCellContinuation(col, row)) continue;
+			const cellFg = buffer.getCellFg(col, row);
+			const cellBg = buffer.getCellBg(col, row);
+			let newFg;
+			let newBg;
+			let inverseAttr = false;
+			if (theme?.selectionBg != null) {
+				newFg = theme.selectionFg ?? cellFg;
+				newBg = theme.selectionBg;
+			} else if (cellFg == null || cellBg == null) {
+				newFg = cellFg;
+				newBg = cellBg;
+				inverseAttr = true;
+			} else {
+				newFg = cellBg;
+				newBg = cellFg;
+			}
+			changes.push({
+				col,
+				row,
+				fg: newFg,
+				bg: newBg,
+				inverseAttr
+			});
+		}
+	}
+	return changes;
+}
+//#endregion
+//#region packages/ag-term/src/virtual-scrollback.ts
+/**
+* Virtual scrollback buffer for storing historical rendered content.
+*
+* Used by virtual inline mode to maintain scrollable history while
+* rendering in altscreen (which normally has no scrollback).
+*
+* Implementation uses a circular buffer for O(1) push and bounded memory.
+*/
+function createVirtualScrollback(options) {
+	const maxLines = options?.maxLines ?? 1e4;
+	const ansiLines = new Array(maxLines);
+	const plainLines = new Array(maxLines);
+	let head = 0;
+	let count = 0;
+	return {
+		push(lines) {
+			for (const line of lines) {
+				ansiLines[head] = line;
+				plainLines[head] = stripAnsi(line);
+				head = (head + 1) % maxLines;
+				if (count < maxLines) count++;
+			}
+		},
+		getVisibleRows(offset, rowCount) {
+			const result = [];
+			for (let i = 0; i < rowCount; i++) {
+				const logicalIndex = count - offset - rowCount + i;
+				if (logicalIndex < 0 || logicalIndex >= count) result.push("");
+				else {
+					const physical = (head - count + logicalIndex + maxLines) % maxLines;
+					result.push(ansiLines[physical]);
+				}
+			}
+			return result;
+		},
+		get totalLines() {
+			return count;
+		},
+		search(query) {
+			if (!query) return [];
+			const lowerQuery = query.toLowerCase();
+			const matches = [];
+			for (let i = 0; i < count; i++) if (plainLines[(head - count + i + maxLines) % maxLines].toLowerCase().includes(lowerQuery)) matches.push(i);
+			return matches;
+		},
+		clear() {
+			head = 0;
+			count = 0;
+		}
+	};
+}
+//#endregion
+export { generateHitRegionId as $, queryModes as A, TERMTEST_SECTIONS as B, resolveFromTerm as C, searchUpdate as Ct, queryTextAreaSize as D, createHistoryBuffer as Dt, queryTextAreaPixels as E, createListDocument as Et, queryTertiaryDA as F, findActiveCursorNode as G, detectKittyFromStdio as H, applyWidthConfig as I, injectDOMStyles as J, DOMRenderBuffer as K, createWidthDetector as L, queryPrimaryDA as M, querySecondaryDA as N, DecMode as O, createHistoryItem as Ot, queryTerminalVersion as P, Z_INDEX as Q, queryCursorFromStdio as R, isTermDef as S, renderSearchBarPlain as St, queryCellSize as T, createTextSurface as Tt, detectKittySupport as U, runTermtest as V, OSC133 as W, createCanvasAdapter as X, CanvasRenderBuffer as Y, HitRegistry as Z, createOutputTransformer as _, resizeSplit as _t, createTerminalSelectionState as a, calcEdgeBasedScrollOffset as at, createInputEvents as b, computeMatchRanges as bt, createPipeline as c, scrollDown as ct, disableInspector as d, supportsScrollRegions as dt, resetHitRegionIdCounter as et, enableInspector as f, createLeaf as ft, countLines as g, removePane as gt, isInspectorEnabled as h, getTabOrder as ht, composeSelectionCells as i, useCursor as it, queryDeviceAttributes as j, queryMode as k, createFocusManager as kt, withMeasurer as l, scrollUp as lt, inspectTree as m, getPaneIds as mt, applySelectionToBuffer as n, createCursorStore as nt, extractText as o, moveCursor as ot, inspectFrame as p, findAdjacentPane as pt, createDOMAdapter as q, composeSearchHighlightCells as r, resetCursorState as rt, terminalSelectionUpdate as s, resetScrollRegion as st, createVirtualScrollback as t, CursorProvider as tt, autoEnableInspector as u, setScrollRegion as ut, isTTY as v, splitPane as vt, resolveTermDef as w, composeViewport as wt, isTerm as x, createSearchState as xt, resolveNonTTYMode as y, swapPanes as yt, queryCursorPosition as z };
+
+//# sourceMappingURL=src-CbhWmUnF.mjs.map