@solid-tui/runtime 0.1.0

package/dist/render-to-string-zweiEGvu.mjs

@@ -0,0 +1,4661 @@
+import { batch, catchError, children, createComponent as createComponent$1, createContext, createEffect, createMemo, createRenderEffect, createRoot as createRoot$1, createSignal, mergeProps as mergeProps$1, on, onCleanup, splitProps, untrack, useContext } from "solid-js/dist/solid.js";
+import Yoga from "better-yoga-layout";
+import cliTruncate from "cli-truncate";
+import sliceAnsi from "slice-ansi";
+import stringWidth from "string-width";
+import wrapAnsi from "wrap-ansi";
+import { EventEmitter } from "node:events";
+import isInCi from "is-in-ci";
+import { onExit } from "signal-exit";
+import patchConsoleFn from "patch-console";
+import ansiEscapes from "ansi-escapes";
+import * as fs from "node:fs";
+import { writeSync } from "node:fs";
+import cliBoxes from "cli-boxes";
+import { styledCharsFromTokens, styledCharsToString, tokenize } from "@alcalzone/ansi-tokenize";
+import chalk from "chalk";
+import { cwd } from "node:process";
+import StackUtils from "stack-utils";
+import codeExcerpt from "code-excerpt";
+import terminalSize from "terminal-size";
+//#region src/solid-universal.ts
+const memo$1 = (fn) => createMemo(() => fn());
+function createRenderer({ createElement, createTextNode, isTextNode, replaceText, insertNode, removeNode, setProperty, getParentNode, getFirstChild, getNextSibling }) {
+	function insert(parent, accessor, marker, initial) {
+		if (marker !== void 0 && !initial) initial = [];
+		if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
+		createRenderEffect((current) => insertExpression(parent, accessor(), current, marker), initial);
+		return parent;
+	}
+	function insertExpression(parent, value, current, marker, unwrapArray) {
+		while (typeof current === "function") current = current();
+		if (value === current) return current;
+		const valueType = typeof value;
+		const multi = marker !== void 0;
+		if (valueType === "string" || valueType === "number") {
+			const text = valueType === "number" ? String(value) : value;
+			if (multi) {
+				let node = current?.[0];
+				if (node && isTextNode(node)) replaceText(node, text);
+				else node = createTextNode(text);
+				current = cleanChildren(parent, current, marker, node);
+			} else if (current !== "" && typeof current === "string") {
+				const first = getFirstChild(parent);
+				if (first) replaceText(first, text);
+				current = text;
+			} else {
+				cleanChildren(parent, current, marker, createTextNode(text));
+				current = text;
+			}
+		} else if (value == null || valueType === "boolean") current = cleanChildren(parent, current, marker);
+		else if (valueType === "function") {
+			createRenderEffect(() => {
+				let v = value();
+				while (typeof v === "function") v = v();
+				current = insertExpression(parent, v, current, marker);
+			});
+			return () => current;
+		} else if (Array.isArray(value)) {
+			const array = [];
+			if (normalizeIncomingArray(array, value, unwrapArray)) {
+				createRenderEffect(() => {
+					current = insertExpression(parent, array, current, marker, true);
+				});
+				return () => current;
+			}
+			if (array.length === 0) {
+				const replacement = cleanChildren(parent, current, marker);
+				if (multi) return current = replacement;
+			} else if (Array.isArray(current)) if (current.length === 0) appendNodes(parent, array, marker);
+			else reconcileArrays(parent, current, array);
+			else if (current == null || current === "") appendNodes(parent, array, marker);
+			else {
+				const first = getFirstChild(parent);
+				reconcileArrays(parent, multi && current || (first ? [first] : []), array);
+			}
+			current = array;
+		} else {
+			const node = value;
+			if (Array.isArray(current)) {
+				if (multi) return current = cleanChildren(parent, current, marker, node);
+				cleanChildren(parent, current, null, node);
+			} else if (current == null || current === "" || !getFirstChild(parent)) insertNode(parent, node);
+			else {
+				const first = getFirstChild(parent);
+				if (first) replaceNode(parent, node, first);
+			}
+			current = node;
+		}
+		return current;
+	}
+	function normalizeIncomingArray(normalized, array, unwrap) {
+		let dynamic = false;
+		for (let i = 0, len = array.length; i < len; i++) {
+			let item = array[i];
+			let t;
+			if (item == null || item === true || item === false) continue;
+			else if (Array.isArray(item)) dynamic = normalizeIncomingArray(normalized, item) || dynamic;
+			else if ((t = typeof item) === "string" || t === "number") normalized.push(createTextNode(String(item)));
+			else if (t === "function") if (unwrap) {
+				while (typeof item === "function") item = item();
+				dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item]) || dynamic;
+			} else {
+				normalized.push(item);
+				dynamic = true;
+			}
+			else normalized.push(item);
+		}
+		return dynamic;
+	}
+	function reconcileArrays(parentNode, a, b) {
+		let bLength = b.length;
+		let aEnd = a.length;
+		let bEnd = bLength;
+		let aStart = 0;
+		let bStart = 0;
+		const after = getNextSibling(a[aEnd - 1]);
+		let map = null;
+		while (aStart < aEnd || bStart < bEnd) {
+			if (a[aStart] === b[bStart]) {
+				aStart++;
+				bStart++;
+				continue;
+			}
+			while (a[aEnd - 1] === b[bEnd - 1]) {
+				aEnd--;
+				bEnd--;
+			}
+			if (aEnd === aStart) {
+				const node = bEnd < bLength ? bStart ? getNextSibling(b[bStart - 1]) : b[bEnd - bStart] : after;
+				while (bStart < bEnd) insertNode(parentNode, b[bStart++], node);
+			} else if (bEnd === bStart) while (aStart < aEnd) {
+				if (!map || !map.has(a[aStart])) removeNode(parentNode, a[aStart]);
+				aStart++;
+			}
+			else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+				const node = getNextSibling(a[--aEnd]);
+				insertNode(parentNode, b[bStart++], getNextSibling(a[aStart++]));
+				insertNode(parentNode, b[--bEnd], node);
+				a[aEnd] = b[bEnd];
+			} else {
+				if (!map) {
+					map = /* @__PURE__ */ new Map();
+					let i = bStart;
+					while (i < bEnd) map.set(b[i], i++);
+				}
+				const index = map.get(a[aStart]);
+				if (index != null) if (bStart < index && index < bEnd) {
+					let i = aStart;
+					let sequence = 1;
+					let t;
+					while (++i < aEnd && i < bEnd) {
+						t = map.get(a[i]);
+						if (t == null || t !== index + sequence) break;
+						sequence++;
+					}
+					if (sequence > index - bStart) {
+						const node = a[aStart];
+						while (bStart < index) insertNode(parentNode, b[bStart++], node);
+					} else replaceNode(parentNode, b[bStart++], a[aStart++]);
+				} else aStart++;
+				else removeNode(parentNode, a[aStart++]);
+			}
+		}
+	}
+	function cleanChildren(parent, current, marker, replacement) {
+		if (marker === void 0) {
+			let removed;
+			while (removed = getFirstChild(parent)) removeNode(parent, removed);
+			if (replacement) insertNode(parent, replacement);
+			return "";
+		}
+		const node = replacement || createTextNode("");
+		const currentArray = Array.isArray(current) ? current : [];
+		if (currentArray.length) {
+			let inserted = false;
+			for (let i = currentArray.length - 1; i >= 0; i--) {
+				const el = currentArray[i];
+				if (node !== el) {
+					const isParent = getParentNode(el) === parent;
+					if (!inserted && !i) if (isParent) replaceNode(parent, node, el);
+					else insertNode(parent, node, marker ?? void 0);
+					else if (isParent) removeNode(parent, el);
+				} else inserted = true;
+			}
+		} else insertNode(parent, node, marker ?? void 0);
+		return [node];
+	}
+	function appendNodes(parent, array, marker) {
+		for (let i = 0, len = array.length; i < len; i++) insertNode(parent, array[i], marker ?? void 0);
+	}
+	function replaceNode(parent, newNode, oldNode) {
+		insertNode(parent, newNode, oldNode);
+		removeNode(parent, oldNode);
+	}
+	function spreadExpression(node, props, prevProps = {}, skipChildren) {
+		props ||= {};
+		if (!skipChildren) createRenderEffect(() => {
+			prevProps.children = insertExpression(node, props.children, prevProps.children);
+		});
+		createRenderEffect(() => {
+			if (typeof props.ref === "function") props.ref(node);
+		});
+		createRenderEffect(() => {
+			for (const prop in props) {
+				if (prop === "children" || prop === "ref") continue;
+				const value = props[prop];
+				if (value === prevProps[prop]) continue;
+				setProperty(node, prop, value, prevProps[prop]);
+				prevProps[prop] = value;
+			}
+		});
+		return prevProps;
+	}
+	return {
+		render(code, element) {
+			let disposer;
+			createRoot$1((dispose) => {
+				disposer = dispose;
+				insert(element, code());
+			});
+			return () => disposer?.();
+		},
+		insert,
+		spread(node, accessor, skipChildren) {
+			if (typeof accessor === "function") createRenderEffect((current) => spreadExpression(node, accessor(), current, skipChildren));
+			else spreadExpression(node, accessor, void 0, skipChildren);
+		},
+		createElement,
+		createTextNode,
+		insertNode,
+		setProp(node, name, value, prev) {
+			setProperty(node, name, value, prev);
+			return value;
+		},
+		mergeProps: mergeProps$1,
+		effect: createRenderEffect,
+		memo: memo$1,
+		createComponent: createComponent$1,
+		use(fn, element, arg) {
+			return untrack(() => fn(element, arg));
+		}
+	};
+}
+//#endregion
+//#region src/host/nodes.ts
+const UNATTACHED_YOGA = Symbol("solid-tui:yoga-unattached");
+function createRoot(appContext) {
+	return {
+		type: "root",
+		parent: null,
+		children: [],
+		yoga: UNATTACHED_YOGA,
+		appContext,
+		layoutListeners: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* Register a callback to be invoked after every layout calculation.
+* Returns an unsubscribe function.
+*/
+function addLayoutListener(root, listener) {
+	root.layoutListeners.add(listener);
+	return () => {
+		root.layoutListeners.delete(listener);
+	};
+}
+/** Invoke all registered layout listeners. Called after `yoga.calculateLayout`. */
+function emitLayoutListeners(root) {
+	for (const listener of root.layoutListeners) listener();
+}
+function createBox() {
+	return {
+		type: "tui-box",
+		parent: null,
+		children: [],
+		yoga: UNATTACHED_YOGA,
+		props: {},
+		paintDirty: true
+	};
+}
+function createText() {
+	return {
+		type: "tui-text",
+		parent: null,
+		children: [],
+		yoga: UNATTACHED_YOGA,
+		props: {}
+	};
+}
+function createVirtualText() {
+	return {
+		type: "tui-virtual-text",
+		parent: null,
+		children: [],
+		props: {}
+	};
+}
+function createTextLeaf(value) {
+	return {
+		type: "text-leaf",
+		parent: null,
+		value: typeof value === "string" ? value : String(value)
+	};
+}
+function createStatic() {
+	return {
+		type: "tui-static",
+		parent: null,
+		children: [],
+		yoga: UNATTACHED_YOGA,
+		props: {},
+		writtenNodes: /* @__PURE__ */ new Set()
+	};
+}
+function createTransform(fn) {
+	return {
+		type: "tui-transform",
+		parent: null,
+		children: [],
+		yoga: UNATTACHED_YOGA,
+		transform: fn
+	};
+}
+function isContainer(node) {
+	return node.type !== "text-leaf" && node.type !== "comment";
+}
+/**
+* Whether a child counts as a positional line for transform/squash indexing.
+* Mirrors Ink: `null`/`''` children are not rendered as childNodes, so neither a
+* `comment` (Solid's null/false/v-if placeholder) nor an EMPTY `text-leaf` (an
+* empty-string `{''}` child, or a template `<slot/>` boundary anchor) advances the
+* index. Verified against real Ink v7.0.4 (`a{''}<Transform>b` → `ab[1]`, not
+* `ab[2]`). The inverse of static-channel's `isInertStaticAnchor`.
+*/
+function advancesLineIndex(child) {
+	return child.type !== "comment" && !(child.type === "text-leaf" && child.value === "");
+}
+//#endregion
+//#region src/paint/ansi-tokenizer.ts
+const bellCharacter = "\x07";
+const escapeCharacter = "\x1B";
+const stringTerminatorCharacter = "œ";
+const csiCharacter = "›";
+const oscCharacter = "";
+const dcsCharacter = "";
+const pmCharacter = "ž";
+const apcCharacter = "Ÿ";
+const sosCharacter = "˜";
+const isCsiParameterCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 48 && codePoint <= 63;
+};
+const isCsiIntermediateCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 32 && codePoint <= 47;
+};
+const isCsiFinalCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 64 && codePoint <= 126;
+};
+const isEscapeIntermediateCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 32 && codePoint <= 47;
+};
+const isEscapeFinalCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 48 && codePoint <= 126;
+};
+const isC1ControlCharacter = (character) => {
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 128 && codePoint <= 159;
+};
+const readCsiSequence = (text, fromIndex) => {
+	let index = fromIndex;
+	while (index < text.length) {
+		const character = text[index];
+		if (!isCsiParameterCharacter(character)) break;
+		index++;
+	}
+	const parameterString = text.slice(fromIndex, index);
+	const intermediateStartIndex = index;
+	while (index < text.length) {
+		const character = text[index];
+		if (!isCsiIntermediateCharacter(character)) break;
+		index++;
+	}
+	const intermediateString = text.slice(intermediateStartIndex, index);
+	const finalCharacter = text[index];
+	if (finalCharacter === void 0 || !isCsiFinalCharacter(finalCharacter)) return;
+	return {
+		endIndex: index + 1,
+		parameterString,
+		intermediateString,
+		finalCharacter
+	};
+};
+const findControlStringTerminatorIndex = (text, fromIndex, allowBellTerminator) => {
+	for (let index = fromIndex; index < text.length; index++) {
+		const character = text[index];
+		if (allowBellTerminator && character === bellCharacter) return index + 1;
+		if (character === stringTerminatorCharacter) return index + 1;
+		if (character === escapeCharacter) {
+			const followingCharacter = text[index + 1];
+			if (followingCharacter === escapeCharacter) {
+				index++;
+				continue;
+			}
+			if (followingCharacter === "\\") return index + 2;
+		}
+	}
+};
+const readEscapeSequence = (text, fromIndex) => {
+	let index = fromIndex;
+	while (index < text.length) {
+		const character = text[index];
+		if (!isEscapeIntermediateCharacter(character)) break;
+		index++;
+	}
+	const intermediateString = text.slice(fromIndex, index);
+	const finalCharacter = text[index];
+	if (finalCharacter === void 0 || !isEscapeFinalCharacter(finalCharacter)) return;
+	return {
+		endIndex: index + 1,
+		intermediateString,
+		finalCharacter
+	};
+};
+const getControlStringFromEscapeIntroducer = (character) => {
+	switch (character) {
+		case "]": return {
+			type: "osc",
+			allowBellTerminator: true
+		};
+		case "P": return {
+			type: "dcs",
+			allowBellTerminator: false
+		};
+		case "^": return {
+			type: "pm",
+			allowBellTerminator: false
+		};
+		case "_": return {
+			type: "apc",
+			allowBellTerminator: false
+		};
+		case "X": return {
+			type: "sos",
+			allowBellTerminator: false
+		};
+		default: return;
+	}
+};
+const getControlStringFromC1Introducer = (character) => {
+	switch (character) {
+		case oscCharacter: return {
+			type: "osc",
+			allowBellTerminator: true
+		};
+		case dcsCharacter: return {
+			type: "dcs",
+			allowBellTerminator: false
+		};
+		case pmCharacter: return {
+			type: "pm",
+			allowBellTerminator: false
+		};
+		case apcCharacter: return {
+			type: "apc",
+			allowBellTerminator: false
+		};
+		case sosCharacter: return {
+			type: "sos",
+			allowBellTerminator: false
+		};
+		default: return;
+	}
+};
+const hasAnsiControlCharacters = (text) => {
+	if (text.includes(escapeCharacter)) return true;
+	for (const character of text) if (isC1ControlCharacter(character)) return true;
+	return false;
+};
+const malformedFromIndex = (tokens, text, textStartIndex, fromIndex) => {
+	if (fromIndex > textStartIndex) tokens.push({
+		type: "text",
+		value: text.slice(textStartIndex, fromIndex)
+	});
+	tokens.push({
+		type: "invalid",
+		value: text.slice(fromIndex)
+	});
+	return tokens;
+};
+const tokenizeAnsi = (text) => {
+	if (!hasAnsiControlCharacters(text)) return [{
+		type: "text",
+		value: text
+	}];
+	const tokens = [];
+	let textStartIndex = 0;
+	for (let index = 0; index < text.length;) {
+		const character = text[index];
+		if (character === void 0) break;
+		if (character === escapeCharacter) {
+			const followingCharacter = text[index + 1];
+			if (followingCharacter === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+			if (followingCharacter === "[") {
+				const csiSequence = readCsiSequence(text, index + 2);
+				if (csiSequence === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+				if (index > textStartIndex) tokens.push({
+					type: "text",
+					value: text.slice(textStartIndex, index)
+				});
+				tokens.push({
+					type: "csi",
+					value: text.slice(index, csiSequence.endIndex),
+					parameterString: csiSequence.parameterString,
+					intermediateString: csiSequence.intermediateString,
+					finalCharacter: csiSequence.finalCharacter
+				});
+				index = csiSequence.endIndex;
+				textStartIndex = index;
+				continue;
+			}
+			const escapeControlString = getControlStringFromEscapeIntroducer(followingCharacter);
+			if (escapeControlString !== void 0) {
+				const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 2, escapeControlString.allowBellTerminator);
+				if (controlStringTerminatorIndex === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+				if (index > textStartIndex) tokens.push({
+					type: "text",
+					value: text.slice(textStartIndex, index)
+				});
+				tokens.push({
+					type: escapeControlString.type,
+					value: text.slice(index, controlStringTerminatorIndex)
+				});
+				index = controlStringTerminatorIndex;
+				textStartIndex = index;
+				continue;
+			}
+			const escapeSequence = readEscapeSequence(text, index + 1);
+			if (escapeSequence === void 0) {
+				if (isEscapeIntermediateCharacter(followingCharacter)) return malformedFromIndex(tokens, text, textStartIndex, index);
+				if (index > textStartIndex) tokens.push({
+					type: "text",
+					value: text.slice(textStartIndex, index)
+				});
+				index++;
+				textStartIndex = index;
+				continue;
+			}
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "esc",
+				value: text.slice(index, escapeSequence.endIndex),
+				intermediateString: escapeSequence.intermediateString,
+				finalCharacter: escapeSequence.finalCharacter
+			});
+			index = escapeSequence.endIndex;
+			textStartIndex = index;
+			continue;
+		}
+		if (character === csiCharacter) {
+			const csiSequence = readCsiSequence(text, index + 1);
+			if (csiSequence === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "csi",
+				value: text.slice(index, csiSequence.endIndex),
+				parameterString: csiSequence.parameterString,
+				intermediateString: csiSequence.intermediateString,
+				finalCharacter: csiSequence.finalCharacter
+			});
+			index = csiSequence.endIndex;
+			textStartIndex = index;
+			continue;
+		}
+		const c1ControlString = getControlStringFromC1Introducer(character);
+		if (c1ControlString !== void 0) {
+			const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 1, c1ControlString.allowBellTerminator);
+			if (controlStringTerminatorIndex === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: c1ControlString.type,
+				value: text.slice(index, controlStringTerminatorIndex)
+			});
+			index = controlStringTerminatorIndex;
+			textStartIndex = index;
+			continue;
+		}
+		if (character === stringTerminatorCharacter) {
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "st",
+				value: character
+			});
+			index++;
+			textStartIndex = index;
+			continue;
+		}
+		if (isC1ControlCharacter(character)) {
+			if (index > textStartIndex) tokens.push({
+				type: "text",
+				value: text.slice(textStartIndex, index)
+			});
+			tokens.push({
+				type: "c1",
+				value: character
+			});
+			index++;
+			textStartIndex = index;
+			continue;
+		}
+		index++;
+	}
+	if (textStartIndex < text.length) tokens.push({
+		type: "text",
+		value: text.slice(textStartIndex)
+	});
+	return tokens;
+};
+//#endregion
+//#region src/paint/sanitize-ansi.ts
+const sgrParametersRegex = /^[\d:;]*$/;
+function sanitizeAnsi(text) {
+	if (!hasAnsiControlCharacters(text)) return text;
+	let output = "";
+	for (const token of tokenizeAnsi(text)) {
+		if (token.type === "text" || token.type === "osc") {
+			output += token.value;
+			continue;
+		}
+		if (token.type === "csi" && token.finalCharacter === "m" && token.intermediateString === "" && sgrParametersRegex.test(token.parameterString)) output += token.value;
+	}
+	return output;
+}
+//#endregion
+//#region src/host/text-measure.ts
+function flattenLeaves(node) {
+	if (!node.children || node.children.length === 0) return "";
+	let out = "";
+	let transformIndex = 0;
+	for (const child of node.children) {
+		out += squashTransformChild$1(child, transformIndex);
+		if (advancesLineIndex(child)) transformIndex++;
+	}
+	return sanitizeAnsi(out);
+}
+function squashTransformChild$1(child, index) {
+	if (child.type === "text-leaf") return child.value;
+	if (child.type === "tui-virtual-text" || child.type === "tui-text") return flattenLeaves(child);
+	if (child.type === "tui-transform") {
+		let innerText = "";
+		let grandIndex = 0;
+		for (const grandchild of child.children) {
+			innerText += squashTransformChild$1(grandchild, grandIndex);
+			if (advancesLineIndex(grandchild)) grandIndex++;
+		}
+		if (innerText.length > 0 && child.transform) innerText = child.transform(innerText, index);
+		return innerText;
+	}
+	return "";
+}
+function flattenTransformLeaves(node) {
+	if (!node.children || node.children.length === 0) return "";
+	let out = "";
+	let transformIndex = 0;
+	for (const child of node.children) {
+		out += squashTransformChild$1(child, transformIndex);
+		if (advancesLineIndex(child)) transformIndex++;
+	}
+	return sanitizeAnsi(out);
+}
+/**
+* Slice `text` from the start so the result is at most `maxCols` columns wide.
+* `slice-ansi` can overshoot when a wide character straddles the boundary, so
+* we reduce the slice position until the result fits.
+*/
+function safeSliceEnd(text, maxCols) {
+	if (maxCols <= 0) return "";
+	let end = maxCols;
+	let sliced = sliceAnsi(text, 0, end);
+	let w = stringWidth(sliced);
+	while (w > maxCols && end > 0) {
+		end--;
+		sliced = sliceAnsi(text, 0, end);
+		w = stringWidth(sliced);
+	}
+	return sliced;
+}
+const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+/**
+* Strip ALL ANSI from `text`, returning only its visible code points. Reuses the paint
+* tokenizer (the same one sanitizeAnsi uses) rather than a strip-ansi regex dep: every
+* non-`text` token — SGR, OSC hyperlinks, control strings — is dropped, so the result is the
+* exact visible string wrap-ansi must lay out. (wrap-ansi recognises SGR/OSC8 and would
+* byte-split SGR at width<=0; feeding it the plain string sidesteps that bug entirely.)
+*/
+function stripAnsi(text) {
+	let out = "";
+	for (const token of tokenizeAnsi(text)) if (token.type === "text") out += token.value;
+	return out;
+}
+/**
+* Replicate wrap-ansi's width<=0 layout for a (possibly STYLED) string, ANSI-awarely.
+*
+* The output's LINE STRUCTURE exactly equals wrap-ansi's authoritative width-0 layout for the
+* given wrap `mode` — `wrap` uses `{hard:true, trim:false}`, `hard` uses
+* `{hard:true, trim:false, wordWrap:false}`, mirroring Ink's wrap-text.ts (the SOLE difference
+* between the two modes). At width 0 `wordWrap:false` makes wrap-ansi emit an EXTRA blank row
+* before each interior word's first grapheme (wrapAnsi("a b c",0,…,wordWrap:false) =
+* ["","a"," ","","b"," ","","c"] vs `wrap`'s ["","a"," ","b"," ","c"]), so `hard` measures
+* taller than `wrap` — which is exactly Ink's behavior. Threading `mode` here keeps both
+* line-counts in lockstep with Ink instead of measuring `hard` with `wrap` structure.
+*
+* wrap-ansi breaks BEFORE each grapheme it cannot fit, so an interior zero-width grapheme
+* (ZWSP/ZWNJ/ZWJ, combining mark, VS16, soft-hyphen, BOM) lands on its OWN row with the
+* surrounding `""` blanks — but a TRAILING zero-width run (nothing visible after it) stays glued
+* to the preceding grapheme's row (wrapAnsi("中​",0)=["","中​"], not ["","中","​"]). Deriving
+* structure from wrap-ansi on the plain string reproduces both cases for free; the old
+* column-stepping `slice(col,col+1)` could not (it glued an interior zero-width onto the next
+* grapheme → line-count too low, and `break`-ed on a leading zero-width + wide glyph → dropped
+* the rest of the line).
+*
+* Styling is re-applied in lockstep: the plain and styled strings share an identical grapheme
+* sequence (SGR/OSC are zero-width), so each NON-EMPTY plain line maps to a contiguous run of
+* graphemes (USUALLY one, but a trailing zero-width run makes it several — e.g. "中​"). We slice
+* that run out of the STYLED text with slice-ansi via the same slot model wrap-ansi's plain
+* layout implies, so slice-ansi re-emits the active SGR span around it (e.g. "\x1b[41mA\x1b[49m")
+* and keeps a wide glyph whole — matching Ink's per-grapheme colored output. We never let
+* wrap-ansi touch the styled string (it byte-splits the escapes at width<=0); we only ask it
+* for structure.
+*/
+function wrapZeroWidthAnsi(text, mode) {
+	text = text.normalize("NFC");
+	const result = [];
+	const styledLines = text.split("\n");
+	const wrapOptions = mode === "hard" ? {
+		hard: true,
+		trim: false,
+		wordWrap: false
+	} : {
+		hard: true,
+		trim: false
+	};
+	for (const styledLine of styledLines) {
+		const plainLine = stripAnsi(styledLine);
+		const plainLines = wrapAnsi(plainLine, 0, wrapOptions).split("\n");
+		const slotEnds = [];
+		let slot = 0;
+		for (const { segment } of graphemeSegmenter.segment(plainLine)) {
+			slot += Math.max(1, stringWidth(segment));
+			slotEnds.push(slot);
+		}
+		let graphemeIndex = 0;
+		for (const line of plainLines) {
+			if (line === "") {
+				result.push("");
+				continue;
+			}
+			const startSlot = graphemeIndex === 0 ? 0 : slotEnds[graphemeIndex - 1];
+			const graphemeCount = [...graphemeSegmenter.segment(line)].length;
+			graphemeIndex += graphemeCount;
+			const endSlot = slotEnds[graphemeIndex - 1] ?? startSlot;
+			result.push(sliceAnsi(styledLine, startSlot, endSlot));
+		}
+	}
+	return result;
+}
+function wrapText(text, width, mode = "wrap") {
+	if (mode === "wrap" || mode === "hard") {
+		if (measureTextNatural(text).width <= width) return text.split("\n");
+		if (width <= 0) return wrapZeroWidthAnsi(text, mode);
+		if (mode === "wrap") return wrapAnsi(text, width, {
+			hard: true,
+			trim: false
+		}).split("\n");
+		return wrapAnsi(text, width, {
+			hard: true,
+			trim: false,
+			wordWrap: false
+		}).split("\n");
+	}
+	const lines = text.split("\n");
+	if (lines.every((l) => stringWidth(l) <= width)) return lines;
+	return cliTruncate(text, width, { position: mode === "truncate-start" ? "start" : mode === "truncate-middle" ? "middle" : "end" }).split("\n");
+}
+/**
+* Natural (unwrapped) dimensions of `text`, mode-independent. Mirrors Ink's
+* measure-text.js: width = widest line, height = number of \n-separated lines.
+*/
+function measureTextNatural(text) {
+	const lines = text.split("\n");
+	let width = 0;
+	for (const line of lines) width = Math.max(width, stringWidth(line));
+	return {
+		width,
+		height: lines.length
+	};
+}
+//#endregion
+//#region src/host/yoga.ts
+let _createCount = 0;
+let _freeCount = 0;
+function createYogaNode() {
+	_createCount++;
+	return Yoga.Node.create();
+}
+function freeYogaNode(node) {
+	_freeCount++;
+	node.free();
+}
+const yogaNodeTracker = {
+	reset() {
+		_createCount = 0;
+		_freeCount = 0;
+	},
+	snapshot() {
+		return {
+			created: _createCount,
+			freed: _freeCount,
+			live: _createCount - _freeCount
+		};
+	}
+};
+function hasYoga$1(node) {
+	return node.type === "root" || node.type === "tui-box" || node.type === "tui-text" || node.type === "tui-static" || node.type === "tui-transform";
+}
+function attachYoga(node) {
+	node.yoga = createYogaNode();
+	if (node.type === "tui-static") node.yoga.setDisplay(Yoga.DISPLAY_NONE);
+	if (node.type === "tui-box") {
+		node.yoga.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
+		node.yoga.setFlexShrink(1);
+		node.yoga.setFlexWrap(Yoga.WRAP_NO_WRAP);
+		node.yoga.setFlexGrow(0);
+	}
+	if (node.type === "tui-text") {
+		node.yoga.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
+		node.yoga.setFlexShrink(1);
+		node.yoga.setFlexGrow(0);
+	}
+	if (node.type === "tui-transform") {
+		node.yoga.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
+		node.yoga.setFlexShrink(1);
+		node.yoga.setFlexGrow(0);
+		bindTransformMeasure(node);
+	}
+}
+/** A transform yoga node has at least one yoga-carrying child (e.g. a <Text>). */
+function transformHasYogaChild(node) {
+	return node.yoga.getChildCount() > 0;
+}
+function detachYoga(node) {
+	freeYogaNode(node.yoga);
+}
+function yogaIndexFor(parent, child) {
+	const isTextParent = parent.type === "tui-text" || parent.type === "tui-virtual-text" || parent.type === "tui-transform";
+	let yIdx = 0;
+	for (const sibling of parent.children) {
+		if (sibling === child) return yIdx;
+		if (hasYoga$1(sibling)) {
+			if (isTextParent && sibling.type === "tui-transform") continue;
+			yIdx++;
+		}
+	}
+	return yIdx;
+}
+function insertYogaChild(parent, child, _domIndex) {
+	if (!hasYoga$1(parent) || !hasYoga$1(child)) return;
+	if (child.type === "tui-transform" && (parent.type === "tui-text" || parent.type === "tui-transform")) return;
+	if (parent.type === "tui-transform") parent.yoga.unsetMeasureFunc();
+	const childYoga = child.yoga;
+	const currentYogaParent = childYoga.getParent();
+	if (currentYogaParent) currentYogaParent.removeChild(childYoga);
+	const yIdx = yogaIndexFor(parent, child);
+	parent.yoga.insertChild(childYoga, yIdx);
+}
+function removeYogaChild(parent, child) {
+	if (!hasYoga$1(parent) || !hasYoga$1(child)) return;
+	if (child.type === "tui-transform" && (parent.type === "tui-text" || parent.type === "tui-transform")) return;
+	const childYoga = child.yoga;
+	const currentYogaParent = childYoga.getParent();
+	if (currentYogaParent) currentYogaParent.removeChild(childYoga);
+	if (parent.type === "tui-transform" && parent.yoga.getChildCount() === 0) bindTransformMeasure(parent);
+}
+const YOGA_PROP_SETTERS = {
+	width: (n, v) => {
+		if (typeof v === "number") n.setWidth(v);
+		else if (typeof v === "string") n.setWidthPercent(Number.parseInt(v, 10));
+		else n.setWidthAuto();
+	},
+	height: (n, v) => {
+		if (typeof v === "number") n.setHeight(v);
+		else if (typeof v === "string") n.setHeightPercent(Number.parseInt(v, 10));
+		else n.setHeightAuto();
+	},
+	minWidth: (n, v) => typeof v === "string" ? n.setMinWidthPercent(Number.parseInt(v, 10)) : n.setMinWidth(v == null ? 0 : v),
+	minHeight: (n, v) => typeof v === "string" ? n.setMinHeightPercent(Number.parseInt(v, 10)) : n.setMinHeight(v == null ? 0 : v),
+	flexGrow: (n, v) => n.setFlexGrow(v == null ? 0 : v),
+	flexShrink: (n, v) => n.setFlexShrink(v == null ? 1 : v),
+	flexBasis: (n, v) => {
+		if (typeof v === "number") n.setFlexBasis(v);
+		else if (typeof v === "string") n.setFlexBasisPercent(Number.parseInt(v, 10));
+		else n.setFlexBasisAuto();
+	},
+	flexDirection: (n, v) => n.setFlexDirection(v == null ? Yoga.FLEX_DIRECTION_ROW : toFlexDirection(v)),
+	flexWrap: (n, v) => n.setFlexWrap(v == null ? Yoga.WRAP_NO_WRAP : toFlexWrap(v)),
+	alignItems: (n, v) => n.setAlignItems(v == null ? Yoga.ALIGN_STRETCH : toAlign(v)),
+	alignSelf: (n, v) => n.setAlignSelf(v == null ? Yoga.ALIGN_AUTO : toAlign(v)),
+	justifyContent: (n, v) => n.setJustifyContent(v == null ? Yoga.JUSTIFY_FLEX_START : toJustify(v)),
+	gap: (n, v) => n.setGap(Yoga.GUTTER_ALL, v == null ? 0 : v),
+	columnGap: (n, v) => n.setGap(Yoga.GUTTER_COLUMN, v == null ? 0 : v),
+	rowGap: (n, v) => n.setGap(Yoga.GUTTER_ROW, v == null ? 0 : v),
+	margin: () => {},
+	marginX: () => {},
+	marginY: () => {},
+	marginTop: () => {},
+	marginBottom: () => {},
+	marginLeft: () => {},
+	marginRight: () => {},
+	padding: () => {},
+	paddingX: () => {},
+	paddingY: () => {},
+	paddingTop: () => {},
+	paddingBottom: () => {},
+	paddingLeft: () => {},
+	paddingRight: () => {},
+	borderStyle: () => {},
+	borderTop: () => {},
+	borderBottom: () => {},
+	borderLeft: () => {},
+	borderRight: () => {},
+	display: (n, v) => n.setDisplay(v != null && v !== "flex" ? Yoga.DISPLAY_NONE : Yoga.DISPLAY_FLEX),
+	overflow: (_n, _v) => {},
+	overflowX: (_n, _v) => {},
+	overflowY: (_n, _v) => {},
+	maxWidth: (n, v) => typeof v === "string" ? n.setMaxWidthPercent(Number.parseInt(v, 10)) : n.setMaxWidth(v == null ? NaN : v),
+	maxHeight: (n, v) => typeof v === "string" ? n.setMaxHeightPercent(Number.parseInt(v, 10)) : n.setMaxHeight(v == null ? NaN : v),
+	aspectRatio: (n, v) => v == null ? n.setAspectRatio(void 0) : n.setAspectRatio(v),
+	alignContent: (n, v) => v == null ? n.setAlignContent(Yoga.ALIGN_FLEX_START) : n.setAlignContent(toAlign(v)),
+	position: (n, v) => n.setPositionType(toPosition(v)),
+	top: (n, v) => typeof v === "string" ? n.setPositionPercent(Yoga.EDGE_TOP, Number.parseFloat(v)) : n.setPosition(Yoga.EDGE_TOP, v == null ? NaN : v),
+	right: (n, v) => typeof v === "string" ? n.setPositionPercent(Yoga.EDGE_RIGHT, Number.parseFloat(v)) : n.setPosition(Yoga.EDGE_RIGHT, v == null ? NaN : v),
+	bottom: (n, v) => typeof v === "string" ? n.setPositionPercent(Yoga.EDGE_BOTTOM, Number.parseFloat(v)) : n.setPosition(Yoga.EDGE_BOTTOM, v == null ? NaN : v),
+	left: (n, v) => typeof v === "string" ? n.setPositionPercent(Yoga.EDGE_LEFT, Number.parseFloat(v)) : n.setPosition(Yoga.EDGE_LEFT, v == null ? NaN : v)
+};
+function toFlexDirection(v) {
+	return {
+		row: Yoga.FLEX_DIRECTION_ROW,
+		"row-reverse": Yoga.FLEX_DIRECTION_ROW_REVERSE,
+		column: Yoga.FLEX_DIRECTION_COLUMN,
+		"column-reverse": Yoga.FLEX_DIRECTION_COLUMN_REVERSE
+	}[v];
+}
+function toFlexWrap(v) {
+	return {
+		nowrap: Yoga.WRAP_NO_WRAP,
+		wrap: Yoga.WRAP_WRAP,
+		"wrap-reverse": Yoga.WRAP_WRAP_REVERSE
+	}[v];
+}
+function toAlign(v) {
+	return {
+		auto: Yoga.ALIGN_AUTO,
+		"flex-start": Yoga.ALIGN_FLEX_START,
+		center: Yoga.ALIGN_CENTER,
+		"flex-end": Yoga.ALIGN_FLEX_END,
+		stretch: Yoga.ALIGN_STRETCH,
+		baseline: Yoga.ALIGN_BASELINE,
+		"space-between": Yoga.ALIGN_SPACE_BETWEEN,
+		"space-around": Yoga.ALIGN_SPACE_AROUND,
+		"space-evenly": Yoga.ALIGN_SPACE_EVENLY
+	}[v];
+}
+function toPosition(v) {
+	if (!v || v === "relative") return Yoga.POSITION_TYPE_RELATIVE;
+	if (v === "absolute") return Yoga.POSITION_TYPE_ABSOLUTE;
+	return Yoga.POSITION_TYPE_STATIC;
+}
+function toJustify(v) {
+	return {
+		"flex-start": Yoga.JUSTIFY_FLEX_START,
+		center: Yoga.JUSTIFY_CENTER,
+		"flex-end": Yoga.JUSTIFY_FLEX_END,
+		"space-between": Yoga.JUSTIFY_SPACE_BETWEEN,
+		"space-around": Yoga.JUSTIFY_SPACE_AROUND,
+		"space-evenly": Yoga.JUSTIFY_SPACE_EVENLY
+	}[v];
+}
+function isYogaProp(key) {
+	return Object.hasOwn(YOGA_PROP_SETTERS, key);
+}
+/** Props whose change requires recomputing the yoga border-edge widths. */
+const BORDER_PROPS = new Set([
+	"borderStyle",
+	"borderTop",
+	"borderBottom",
+	"borderLeft",
+	"borderRight"
+]);
+/**
+* Recompute all four yoga border-edge widths from a box's full prop set, mirroring
+* Ink's applyBorderStyles (styles.ts:729-763): the per-side width is
+* `borderStyle ? 1 : 0`, then each edge is forced to 0 when that edge's per-edge
+* prop is explicitly `false`. So a per-edge toggle can only SUBTRACT an edge — it
+* can NEVER add width without a borderStyle. This is the joint computation a
+* single yoga setter cannot do (it sees only one value), and it must run on ANY
+* border-prop change, including borderStyle flipping in EITHER direction
+* (set→unset re-zeroes, unset→set re-reserves) — otherwise a per-edge toggle made
+* while borderStyle stays unset would leave a spurious 1-cell inset with no border
+* drawn (the per-edge props default to `true`).
+*/
+function reconcileBorderEdges(node, props) {
+	const y = node.yoga;
+	const borderWidth = props["borderStyle"] ? 1 : 0;
+	y.setBorder(Yoga.EDGE_TOP, props["borderTop"] === false ? 0 : borderWidth);
+	y.setBorder(Yoga.EDGE_BOTTOM, props["borderBottom"] === false ? 0 : borderWidth);
+	y.setBorder(Yoga.EDGE_LEFT, props["borderLeft"] === false ? 0 : borderWidth);
+	y.setBorder(Yoga.EDGE_RIGHT, props["borderRight"] === false ? 0 : borderWidth);
+}
+/** Props whose change requires recomputing the yoga margin edges. */
+const MARGIN_PROPS = new Set([
+	"margin",
+	"marginX",
+	"marginY",
+	"marginTop",
+	"marginBottom",
+	"marginLeft",
+	"marginRight"
+]);
+/** Props whose change requires recomputing the yoga padding edges. */
+const PADDING_PROPS = new Set([
+	"padding",
+	"paddingX",
+	"paddingY",
+	"paddingTop",
+	"paddingBottom",
+	"paddingLeft",
+	"paddingRight"
+]);
+function present(props, key) {
+	const v = props[key];
+	return v != null && v !== "" && Number.isFinite(Number(v));
+}
+/**
+* Recompute all four PHYSICAL margin edges from a box's full prop set. Each edge
+* resolves with most-specific-wins precedence (specific edge → axis → all → 0):
+*   top = marginTop ?? marginY ?? margin ?? 0   (etc.)
+* then the four physical edges are set and the composite edges (ALL/HORIZONTAL/
+* VERTICAL) are ZEROED so nothing layers on top of them.
+*
+* Why this and not the obvious per-setter mapping (margin→EDGE_ALL, marginX→
+* EDGE_HORIZONTAL, marginTop→EDGE_TOP, …): an edge depends on up to THREE props
+* together and a single yoga setter sees only one. Per yoga edge precedence a more
+* specific edge OVERRIDES a composite EVEN WHEN SET TO 0, so resetting a withdrawn
+* `marginTop` to 0 (the old code) still beats a surviving `margin={5}` →
+* `getComputedMargin(TOP)` collapsed to 0 instead of 5. Resolving every physical
+* edge from el.props and zeroing the composites removes that layering entirely, so
+* a withdrawn override falls back to whatever shorthand still applies. Verified
+* against yoga-layout@3.2.1 to produce identical getComputedMargin for the SET path
+* as the old per-setter code across representative combinations. (G19)
+*
+* NOTE the EDGE_START/END (not LEFT/RIGHT) mapping for left/right is preserved from
+* the prior margin setters — margin uses start/end edges, padding uses left/right.
+*/
+function reconcileMarginEdges(node, props) {
+	const y = node.yoga;
+	const pick = (specific, axis) => {
+		if (present(props, specific)) return Number(props[specific]);
+		if (present(props, axis)) return Number(props[axis]);
+		if (present(props, "margin")) return Number(props["margin"]);
+		return 0;
+	};
+	y.setMargin(Yoga.EDGE_TOP, pick("marginTop", "marginY"));
+	y.setMargin(Yoga.EDGE_BOTTOM, pick("marginBottom", "marginY"));
+	y.setMargin(Yoga.EDGE_START, pick("marginLeft", "marginX"));
+	y.setMargin(Yoga.EDGE_END, pick("marginRight", "marginX"));
+	y.setMargin(Yoga.EDGE_ALL, 0);
+	y.setMargin(Yoga.EDGE_HORIZONTAL, 0);
+	y.setMargin(Yoga.EDGE_VERTICAL, 0);
+}
+/**
+* Padding analogue of {@link reconcileMarginEdges}. Same precedence and composite-
+* zeroing, but padding maps left/right to EDGE_LEFT/EDGE_RIGHT (margin uses
+* START/END) — preserving the prior padding setters' edge mapping. (G19)
+*/
+function reconcilePaddingEdges(node, props) {
+	const y = node.yoga;
+	const pick = (specific, axis) => {
+		if (present(props, specific)) return Number(props[specific]);
+		if (present(props, axis)) return Number(props[axis]);
+		if (present(props, "padding")) return Number(props["padding"]);
+		return 0;
+	};
+	y.setPadding(Yoga.EDGE_TOP, pick("paddingTop", "paddingY"));
+	y.setPadding(Yoga.EDGE_BOTTOM, pick("paddingBottom", "paddingY"));
+	y.setPadding(Yoga.EDGE_LEFT, pick("paddingLeft", "paddingX"));
+	y.setPadding(Yoga.EDGE_RIGHT, pick("paddingRight", "paddingX"));
+	y.setPadding(Yoga.EDGE_ALL, 0);
+	y.setPadding(Yoga.EDGE_HORIZONTAL, 0);
+	y.setPadding(Yoga.EDGE_VERTICAL, 0);
+}
+const RESETTABLE_PROPS = new Set([
+	"width",
+	"height",
+	"maxWidth",
+	"maxHeight",
+	"aspectRatio",
+	"alignContent",
+	"top",
+	"right",
+	"bottom",
+	"left",
+	"minWidth",
+	"minHeight",
+	"flexGrow",
+	"flexShrink",
+	"flexBasis",
+	"flexDirection",
+	"flexWrap",
+	"alignItems",
+	"alignSelf",
+	"justifyContent",
+	"gap",
+	"columnGap",
+	"rowGap",
+	"margin",
+	"marginX",
+	"marginY",
+	"marginTop",
+	"marginBottom",
+	"marginLeft",
+	"marginRight",
+	"padding",
+	"paddingX",
+	"paddingY",
+	"paddingTop",
+	"paddingBottom",
+	"paddingLeft",
+	"paddingRight",
+	"position",
+	"display"
+]);
+function applyYogaProp(node, key, value, prev) {
+	const setter = YOGA_PROP_SETTERS[key];
+	if (!setter) return;
+	if (value == null) if (key === "borderStyle") {} else if (RESETTABLE_PROPS.has(key) && prev !== null && prev !== void 0) {} else return;
+	setter(node.yoga, value);
+}
+function bindTextMeasure(text) {
+	text.yoga.setMeasureFunc((availableWidth) => {
+		const raw = flattenLeaves(text);
+		text.measuredCache = raw;
+		if (raw === "") return {
+			width: 0,
+			height: 0
+		};
+		const natural = measureTextNatural(raw);
+		if (natural.width <= availableWidth) return natural;
+		if (natural.width >= 1 && availableWidth > 0 && availableWidth < 1) return natural;
+		return measureTextNatural(wrapText(raw, availableWidth, text.props.wrap ?? "wrap").join("\n"));
+	});
+}
+function markTextDirty(text) {
+	text.yoga.markDirty();
+}
+function bindTransformMeasure(node) {
+	node.yoga.setMeasureFunc((availableWidth) => {
+		const raw = flattenTransformLeaves(node);
+		if (raw === "") return {
+			width: 0,
+			height: 0
+		};
+		const natural = measureTextNatural(raw);
+		if (natural.width <= availableWidth) return natural;
+		if (natural.width >= 1 && availableWidth > 0 && availableWidth < 1) return natural;
+		return measureTextNatural(wrapText(raw, availableWidth, "wrap").join("\n"));
+	});
+}
+function markTransformDirty(node) {
+	node.yoga.markDirty();
+}
+//#endregion
+//#region src/host/node-ops.ts
+const STYLE_PROPS = new Set([
+	"color",
+	"backgroundColor",
+	"dimColor",
+	"bold",
+	"italic",
+	"underline",
+	"strikethrough",
+	"inverse",
+	"wrap",
+	"borderStyle",
+	"borderColor",
+	"borderDimColor",
+	"borderTopColor",
+	"borderBottomColor",
+	"borderLeftColor",
+	"borderRightColor",
+	"borderTopDimColor",
+	"borderBottomDimColor",
+	"borderLeftDimColor",
+	"borderRightDimColor",
+	"borderBackgroundColor",
+	"borderTopBackgroundColor",
+	"borderBottomBackgroundColor",
+	"borderLeftBackgroundColor",
+	"borderRightBackgroundColor",
+	"borderTop",
+	"borderBottom",
+	"borderLeft",
+	"borderRight",
+	"overflow",
+	"overflowX",
+	"overflowY",
+	"margin",
+	"marginX",
+	"marginY",
+	"marginTop",
+	"marginBottom",
+	"marginLeft",
+	"marginRight",
+	"padding",
+	"paddingX",
+	"paddingY",
+	"paddingTop",
+	"paddingBottom",
+	"paddingLeft",
+	"paddingRight"
+]);
+/** Walk up the DOM tree to find the root node. */
+function findRoot(node) {
+	let current = node;
+	while (current) {
+		if (current.type === "root") return current;
+		current = current.parent;
+	}
+	return null;
+}
+/**
+* Walk up the DOM tree to check if we're inside a text context. Treats a
+* <Transform> as a text context too: Ink models <Transform> as an ink-text host
+* (its reconciler sets isInsideText for ink-text), so this is the solid-tui
+* equivalent of Ink's hostContext.isInsideText. It governs BOTH text-context
+* guards, exactly as Ink's single isInsideText flag does:
+*
+*  - a bare-string / <Newline> child directly inside a <Transform> is valid
+*    inline text and must NOT trip the "text must be rendered inside <Text>"
+*    guard (G58); and
+*  - a <Box> directly inside a <Transform> MUST throw the same dev error as a
+*    <Box> inside a <Text> (Ink reconciler.ts:205 throws for any isInsideText
+*    context, ink-text included) (G58 should-fix).
+*/
+function isInsideTextOrTransformContext(node) {
+	let current = node;
+	while (current) {
+		if (current.type === "tui-text" || current.type === "tui-virtual-text" || current.type === "tui-transform") return true;
+		current = current.parent;
+	}
+	return false;
+}
+/**
+* Find the nearest ancestor (inclusive of `start`) that OWNS the yoga measure
+* func used to size inline text — i.e. the node yoga must re-measure when a
+* descendant text-leaf changes. Mirrors Ink's findClosestYogaNode (dom.ts:248),
+* adapted for the fact that solid-tui attaches a yoga node to every <Transform>:
+*
+* - A <Text> always owns its measure func.
+* - A <Transform> owns the measure func ONLY when it is STANDALONE: it has no
+*   yoga-bearing child (so it still carries bindTransformMeasure) AND it is not
+*   itself nested in a text/transform context (an inline transform is squashed
+*   into the enclosing measure owner, just as Ink's ink-virtual-text — which has
+*   no yoga node — is climbed past). An inline transform is therefore skipped and
+*   the walk continues to the enclosing <Text>/standalone <Transform>. (G58)
+*/
+function findMeasureOwner(start) {
+	let p = start;
+	while (p) {
+		if (p.type === "tui-text") return p;
+		if (p.type === "tui-transform") {
+			const inlineInTextContext = p.parent != null && isContainer(p.parent) && isInsideTextOrTransformContext(p.parent);
+			if (!transformHasYogaChild(p) && !inlineInTextContext) return p;
+		}
+		p = p.parent;
+	}
+	return null;
+}
+/**
+* Dirty the measure owner of a text-context parent after a STRUCTURAL change to
+* its children (insert / remove / move). Mirrors Ink marking the parent dirty in
+* appendChildNode / insertBeforeNode / removeChildNode for ink-text AND
+* ink-virtual-text parents (dom.ts:132,165,185) then climbing to the closest
+* yoga node (findClosestYogaNode, dom.ts:248). A no-op when `parent` is not a
+* text context (box / root / static structural changes are sized by yoga
+* directly, no measure func to invalidate).
+*/
+function dirtyTextMeasureOwner(parent) {
+	if (parent.type !== "tui-text" && parent.type !== "tui-virtual-text" && parent.type !== "tui-transform") return;
+	const owner = findMeasureOwner(parent);
+	if (owner?.type === "tui-transform") markTransformDirty(owner);
+	else if (owner?.type === "tui-text") markTextDirty(owner);
+}
+/**
+* Whether a text-leaf carrying `value` would be REJECTED by the text-context
+* guard if inserted into `parent`. A bare string must live inside a <Text>
+* context; an EMPTY text-leaf is exempt (Solid uses empty text-leaves as fragment
+* anchors / its common clear path). Shared by `insert()` (its existing guard)
+* and `setElementText()` (its pre-remove validation) so the two cannot drift —
+* the condition must stay identical in both call sites.
+*/
+function rejectsTextLeaf(parent, value) {
+	return value !== "" && (parent.type === "tui-box" || parent.type === "root" || parent.type === "tui-static") && !isInsideTextOrTransformContext(parent);
+}
+function buildNodeOps(options) {
+	const { onCommit } = options;
+	function createElement(type) {
+		switch (type) {
+			case "tui-box": {
+				const n = createBox();
+				attachYoga(n);
+				return n;
+			}
+			case "tui-text": {
+				const n = createText();
+				attachYoga(n);
+				bindTextMeasure(n);
+				return n;
+			}
+			case "tui-virtual-text": return createVirtualText();
+			case "tui-static": {
+				const n = createStatic();
+				attachYoga(n);
+				return n;
+			}
+			case "tui-transform": {
+				const n = createTransform((line) => line);
+				attachYoga(n);
+				return n;
+			}
+			default: throw new Error(`Unknown solid-tui element type: ${type}`);
+		}
+	}
+	function createTextNode(text) {
+		return createTextLeaf(text);
+	}
+	function setText(node, text) {
+		if (node.type !== "text-leaf") throw new Error(`Cannot setText on ${node.type}`);
+		node.value = typeof text === "string" ? text : String(text);
+		const parent = node.parent;
+		if (parent != null && isContainer(parent) && rejectsTextLeaf(parent, node.value)) throw new Error(`Text string "${node.value}" must be rendered inside <Text> component`);
+		const owner = findMeasureOwner(node.parent);
+		if (owner?.type === "tui-text") markTextDirty(owner);
+		else if (owner?.type === "tui-transform") markTransformDirty(owner);
+		onCommit();
+	}
+	function insert(child, parent, anchor) {
+		if (!isContainer(parent)) throw new Error(`Cannot insert into ${parent.type}`);
+		const parentC = parent;
+		if (child.type === "tui-box" && isInsideTextOrTransformContext(parentC)) throw new Error("<Box> can’t be nested inside <Text> component");
+		if (child.type === "text-leaf" && rejectsTextLeaf(parentC, child.value)) throw new Error(`Text string "${child.value}" must be rendered inside <Text> component`);
+		if (child.parent) {
+			const oldParent = child.parent;
+			const oldIdx = oldParent.children.indexOf(child);
+			if (oldIdx >= 0) oldParent.children.splice(oldIdx, 1);
+			removeYogaChild(oldParent, child);
+			dirtyTextMeasureOwner(oldParent);
+		}
+		const idx = anchor ? parentC.children.indexOf(anchor) : parentC.children.length;
+		parentC.children.splice(idx < 0 ? parentC.children.length : idx, 0, child);
+		child.parent = parentC;
+		insertYogaChild(parentC, child, idx);
+		dirtyTextMeasureOwner(parentC);
+		if (child.type === "tui-static") {
+			const root = findRoot(child);
+			if (root) root.staticNode = child;
+		}
+		onCommit();
+	}
+	function remove(child) {
+		const parent = child.parent;
+		if (!parent) return;
+		if (child.type === "tui-static") {
+			const root = findRoot(child);
+			if (root && root.staticNode === child) root.staticNode = void 0;
+		}
+		const idx = parent.children.indexOf(child);
+		if (idx >= 0) parent.children.splice(idx, 1);
+		removeYogaChild(parent, child);
+		freeSubtreeYoga(child);
+		child.parent = null;
+		dirtyTextMeasureOwner(parent);
+		onCommit();
+	}
+	/** Recursively free yoga nodes for all yoga-carrying descendants, then the node itself. */
+	function freeSubtreeYoga(node) {
+		if (isContainer(node)) for (const child of node.children) freeSubtreeYoga(child);
+		if (node.type === "tui-box" || node.type === "tui-text" || node.type === "tui-static" || node.type === "tui-transform") detachYoga(node);
+	}
+	function parentNode(node) {
+		return node.parent ?? null;
+	}
+	function nextSibling(node) {
+		const p = node.parent;
+		if (!p) return null;
+		const i = p.children.indexOf(node);
+		if (i < 0) return null;
+		return p.children[i + 1] ?? null;
+	}
+	function patchProp(el, key, prev, next) {
+		if (el.type === "tui-transform") {
+			if (key === "transform" && typeof next === "function") el.transform = next;
+			onCommit();
+			return;
+		}
+		if (el.type === "tui-static" && key === "internal_onWritten") {
+			el.onWritten = typeof next === "function" ? next : void 0;
+			onCommit();
+			return;
+		}
+		if (el.type === "tui-box" || el.type === "tui-text" || el.type === "tui-static" || el.type === "root") {
+			if (isYogaProp(key)) {
+				applyYogaProp(el, key, next, prev);
+				if (STYLE_PROPS.has(key)) el.props[key] = next;
+				if (BORDER_PROPS.has(key)) reconcileBorderEdges(el, el.props);
+				if (MARGIN_PROPS.has(key)) reconcileMarginEdges(el, el.props);
+				if (PADDING_PROPS.has(key)) reconcilePaddingEdges(el, el.props);
+			} else if (STYLE_PROPS.has(key)) {
+				el.props[key] = next;
+				if (key === "wrap" && el.type === "tui-text") markTextDirty(el);
+			} else if (key === "aria-role" || key === "ariaRole") {
+				if (el.type === "tui-box") {
+					el.internal_accessibility ??= {};
+					el.internal_accessibility.role = next;
+				}
+			} else if (key === "aria-state" || key === "ariaState") {
+				if (el.type === "tui-box") {
+					el.internal_accessibility ??= {};
+					el.internal_accessibility.state = next;
+				}
+			} else if (key === "aria-label" || key === "ariaLabel" || key === "aria-hidden" || key === "ariaHidden" || key === "accessibilityLabel") {} else if (key === "key" || key === "ref" || key.startsWith("on")) {} else if (process.env["NODE_ENV"] !== "production") console.warn(`[solid-tui] unknown prop "${key}" on <${el.type}>`);
+			onCommit();
+			return;
+		}
+		if (el.type === "tui-virtual-text" && STYLE_PROPS.has(key)) {
+			el.props[key] = next;
+			onCommit();
+		}
+	}
+	return {
+		createElement,
+		createTextNode,
+		replaceText: setText,
+		isTextNode: (node) => node.type === "text-leaf",
+		setProperty: (node, name, value, prev) => patchProp(node, name, prev, value),
+		insertNode: (parent, node, anchor) => insert(node, parent, anchor ?? null),
+		removeNode: (_parent, node) => remove(node),
+		getParentNode: (node) => parentNode(node) ?? void 0,
+		getFirstChild: (node) => isContainer(node) ? node.children[0] : void 0,
+		getNextSibling: (node) => nextSibling(node) ?? void 0
+	};
+}
+//#endregion
+//#region src/renderer.ts
+let onCommit = () => {};
+function setRendererCommit(fn) {
+	const previous = onCommit;
+	onCommit = fn;
+	return () => {
+		onCommit = previous;
+	};
+}
+const tuiRenderer = createRenderer(buildNodeOps({ onCommit: () => onCommit() }));
+const renderSolidRoot = tuiRenderer.render;
+const createElement = tuiRenderer.createElement;
+const createTextNode = tuiRenderer.createTextNode;
+const insertNode = tuiRenderer.insertNode;
+const insert = tuiRenderer.insert;
+const spread = tuiRenderer.spread;
+const setProp = tuiRenderer.setProp;
+const mergeProps = tuiRenderer.mergeProps;
+const effect = tuiRenderer.effect;
+const memo = tuiRenderer.memo;
+const createComponent = tuiRenderer.createComponent;
+const use = tuiRenderer.use;
+//#endregion
+//#region src/io/input-parser.ts
+const escape = "\x1B";
+const pasteStart = "\x1B[200~";
+const pasteEnd = "\x1B[201~";
+const isCsiParameterByte = (byte) => {
+	return byte >= 48 && byte <= 63;
+};
+const isCsiIntermediateByte = (byte) => {
+	return byte >= 32 && byte <= 47;
+};
+const isCsiFinalByte = (byte) => {
+	return byte >= 64 && byte <= 126;
+};
+const parseCsiSequence = (input, startIndex, prefixLength) => {
+	const csiPayloadStart = startIndex + prefixLength + 1;
+	let index = csiPayloadStart;
+	for (; index < input.length; index++) {
+		const byte = input.codePointAt(index);
+		if (byte === void 0) return "pending";
+		if (isCsiParameterByte(byte) || isCsiIntermediateByte(byte)) continue;
+		if (byte === 91 && index === csiPayloadStart) continue;
+		if (isCsiFinalByte(byte)) return {
+			sequence: input.slice(startIndex, index + 1),
+			nextIndex: index + 1
+		};
+		return;
+	}
+	return "pending";
+};
+const parseSs3Sequence = (input, startIndex, prefixLength) => {
+	const nextIndex = startIndex + prefixLength + 2;
+	if (nextIndex > input.length) return "pending";
+	const finalByte = input.codePointAt(nextIndex - 1);
+	if (finalByte === void 0 || !isCsiFinalByte(finalByte)) return;
+	return {
+		sequence: input.slice(startIndex, nextIndex),
+		nextIndex
+	};
+};
+const parseControlSequence = (input, startIndex, prefixLength) => {
+	const sequenceType = input[startIndex + prefixLength];
+	if (sequenceType === void 0) return "pending";
+	if (sequenceType === "[") return parseCsiSequence(input, startIndex, prefixLength);
+	if (sequenceType === "O") return parseSs3Sequence(input, startIndex, prefixLength);
+};
+const parseEscapedCodePoint = (input, escapeIndex) => {
+	const nextCodePoint = input.codePointAt(escapeIndex + 1);
+	const nextCodePointLength = nextCodePoint !== void 0 && nextCodePoint > 65535 ? 2 : 1;
+	const nextIndex = escapeIndex + 1 + nextCodePointLength;
+	return {
+		sequence: input.slice(escapeIndex, nextIndex),
+		nextIndex
+	};
+};
+const parseEscapeSequence = (input, escapeIndex) => {
+	if (escapeIndex === input.length - 1) return "pending";
+	if (input[escapeIndex + 1] === escape) {
+		if (escapeIndex + 2 >= input.length) return "pending";
+		const doubleEscapeSequence = parseControlSequence(input, escapeIndex, 2);
+		if (doubleEscapeSequence === "pending") return "pending";
+		if (doubleEscapeSequence) return doubleEscapeSequence;
+		return {
+			sequence: input.slice(escapeIndex, escapeIndex + 2),
+			nextIndex: escapeIndex + 2
+		};
+	}
+	const controlSequence = parseControlSequence(input, escapeIndex, 1);
+	if (controlSequence === "pending") return "pending";
+	if (controlSequence) return controlSequence;
+	return parseEscapedCodePoint(input, escapeIndex);
+};
+/**
+* Split a chunk of non-escape text so that backspace bytes (`0x7F` and `0x08`)
+* become individual events. When a user holds the backspace key, the terminal
+* sends repeated bytes in a single stdin chunk. Without splitting,
+* `parseKeypress` receives the multi-byte string and fails to recognize it as a
+* key event, corrupting the input state.
+*
+* Other control characters like `\r` and `\t` are NOT split because they can
+* legitimately appear inside pasted text.
+*/
+const splitBackspaceBytes = (text, events) => {
+	let textSegmentStart = 0;
+	for (let index = 0; index < text.length; index++) {
+		const character = text[index];
+		if (character === "" || character === "\b") {
+			if (index > textSegmentStart) events.push(text.slice(textSegmentStart, index));
+			events.push(character);
+			textSegmentStart = index + 1;
+		}
+	}
+	if (textSegmentStart < text.length) events.push(text.slice(textSegmentStart));
+};
+const parseKeypresses = (input) => {
+	const events = [];
+	let index = 0;
+	const pendingFrom = (pendingStartIndex) => ({
+		events,
+		pending: input.slice(pendingStartIndex)
+	});
+	while (index < input.length) {
+		const escapeIndex = input.indexOf(escape, index);
+		if (escapeIndex === -1) {
+			splitBackspaceBytes(input.slice(index), events);
+			return {
+				events,
+				pending: ""
+			};
+		}
+		if (escapeIndex > index) splitBackspaceBytes(input.slice(index, escapeIndex), events);
+		const parsedEscapeSequence = parseEscapeSequence(input, escapeIndex);
+		if (parsedEscapeSequence === "pending") return pendingFrom(escapeIndex);
+		if (parsedEscapeSequence.sequence === pasteStart) {
+			const afterStart = parsedEscapeSequence.nextIndex;
+			const endIndex = input.indexOf(pasteEnd, afterStart);
+			if (endIndex === -1) return pendingFrom(escapeIndex);
+			events.push({ paste: input.slice(afterStart, endIndex) });
+			index = endIndex + 6;
+			continue;
+		}
+		events.push(parsedEscapeSequence.sequence);
+		index = parsedEscapeSequence.nextIndex;
+	}
+	return {
+		events,
+		pending: ""
+	};
+};
+const createInputParser = () => {
+	let pending = "";
+	return {
+		push(chunk) {
+			const parsedInput = parseKeypresses(pending + chunk);
+			pending = parsedInput.pending;
+			return parsedInput.events;
+		},
+		hasPendingEscape() {
+			return pending.startsWith(escape) && !pending.startsWith(pasteStart) && pending !== "\x1B[200";
+		},
+		flushPendingEscape() {
+			if (!pending.startsWith(escape)) return;
+			const pendingEscape = pending;
+			pending = "";
+			return pendingEscape;
+		},
+		reset() {
+			pending = "";
+		}
+	};
+};
+//#endregion
+//#region src/io/kitty-keyboard.ts
+const textEncoder = new TextEncoder();
+const kittyFlags = {
+	disambiguateEscapeCodes: 1,
+	reportEventTypes: 2,
+	reportAlternateKeys: 4,
+	reportAllKeysAsEscapeCodes: 8,
+	reportAssociatedText: 16
+};
+const kittyModifiers = {
+	shift: 1,
+	alt: 2,
+	ctrl: 4,
+	super: 8,
+	hyper: 16,
+	meta: 32,
+	capsLock: 64,
+	numLock: 128
+};
+function resolveFlags(flags) {
+	let result = 0;
+	for (const flag of flags) result |= kittyFlags[flag];
+	return result;
+}
+const ESC = 27;
+const OPEN_BRACKET = 91;
+const QUESTION_MARK = 63;
+const LETTER_U = 117;
+const ZERO = 48;
+const NINE = 57;
+const isDigitByte = (byte) => byte >= ZERO && byte <= NINE;
+function matchKittyQueryResponse(buffer, startIndex) {
+	if (buffer[startIndex] !== ESC || buffer[startIndex + 1] !== OPEN_BRACKET || buffer[startIndex + 2] !== QUESTION_MARK) return;
+	let index = startIndex + 3;
+	const digitsStart = index;
+	while (index < buffer.length && isDigitByte(buffer[index])) index++;
+	if (index === digitsStart) return;
+	if (index === buffer.length) return { state: "partial" };
+	if (buffer[index] === LETTER_U) return {
+		state: "complete",
+		endIndex: index
+	};
+}
+function hasCompleteKittyQueryResponse(buffer) {
+	for (let index = 0; index < buffer.length; index++) if (matchKittyQueryResponse(buffer, index)?.state === "complete") return true;
+	return false;
+}
+function stripKittyQueryResponsesAndTrailingPartial(buffer) {
+	const kept = [];
+	let index = 0;
+	while (index < buffer.length) {
+		const match = matchKittyQueryResponse(buffer, index);
+		if (match?.state === "complete") {
+			index = match.endIndex + 1;
+			continue;
+		}
+		if (match?.state === "partial") break;
+		kept.push(buffer[index]);
+		index++;
+	}
+	return kept;
+}
+function createKittyKeyboardController(stdin, stdout) {
+	let enabled = false;
+	let disposed = false;
+	let cancelDetection;
+	function enableProtocol(flags) {
+		stdout.write(`\x1b[>${resolveFlags(flags)}u`);
+		enabled = true;
+	}
+	function confirmKittySupport(flags) {
+		let responseBuffer = [];
+		const cleanup = () => {
+			cancelDetection = void 0;
+			clearTimeout(timer);
+			stdin.removeListener("data", onData);
+			const remaining = stripKittyQueryResponsesAndTrailingPartial(responseBuffer);
+			responseBuffer = [];
+			if (remaining.length > 0) stdin.unshift(Uint8Array.from(remaining));
+		};
+		const onData = (data) => {
+			const chunk = typeof data === "string" ? textEncoder.encode(data) : data;
+			for (const byte of chunk) responseBuffer.push(byte);
+			if (hasCompleteKittyQueryResponse(responseBuffer)) {
+				cleanup();
+				if (!disposed) enableProtocol(flags);
+			}
+		};
+		stdin.on("data", onData);
+		const timer = setTimeout(cleanup, 200);
+		cancelDetection = cleanup;
+		stdout.write("\x1B[?u");
+	}
+	return {
+		get isEnabled() {
+			return enabled;
+		},
+		init(options, interactive) {
+			if (!options) return;
+			const mode = options.mode ?? "auto";
+			if (mode === "disabled") return;
+			const flags = options.flags ?? ["disambiguateEscapeCodes"];
+			if (mode === "enabled") {
+				if (stdin.isTTY && stdout.isTTY) enableProtocol(flags);
+				return;
+			}
+			if (!interactive || !stdin.isTTY || !stdout.isTTY) return;
+			confirmKittySupport(flags);
+		},
+		dispose(sync = false) {
+			disposed = true;
+			if (cancelDetection) cancelDetection();
+			if (enabled) {
+				if (sync) try {
+					const streamFd = stdout.fd;
+					writeSync(typeof streamFd === "number" ? streamFd : 1, "\x1B[<u");
+				} catch {}
+				else if (!stdout.destroyed && !stdout.writableEnded) stdout.write("\x1B[<u");
+				enabled = false;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/io/parse-keypress.ts
+const textDecoder = new TextDecoder();
+const metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
+const fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
+const kittyQueryResponseRe = /^\x1b\[\?\d+u$/;
+const keyName = {
+	OP: "f1",
+	OQ: "f2",
+	OR: "f3",
+	OS: "f4",
+	"[P": "f1",
+	"[Q": "f2",
+	"[R": "f3",
+	"[S": "f4",
+	"[11~": "f1",
+	"[12~": "f2",
+	"[13~": "f3",
+	"[14~": "f4",
+	"[[A": "f1",
+	"[[B": "f2",
+	"[[C": "f3",
+	"[[D": "f4",
+	"[[E": "f5",
+	"[15~": "f5",
+	"[17~": "f6",
+	"[18~": "f7",
+	"[19~": "f8",
+	"[20~": "f9",
+	"[21~": "f10",
+	"[23~": "f11",
+	"[24~": "f12",
+	"[A": "up",
+	"[B": "down",
+	"[C": "right",
+	"[D": "left",
+	"[E": "clear",
+	"[F": "end",
+	"[H": "home",
+	OA: "up",
+	OB: "down",
+	OC: "right",
+	OD: "left",
+	OE: "clear",
+	OF: "end",
+	OH: "home",
+	"[1~": "home",
+	"[2~": "insert",
+	"[3~": "delete",
+	"[4~": "end",
+	"[5~": "pageup",
+	"[6~": "pagedown",
+	"[[5~": "pageup",
+	"[[6~": "pagedown",
+	"[7~": "home",
+	"[8~": "end",
+	"[a": "up",
+	"[b": "down",
+	"[c": "right",
+	"[d": "left",
+	"[e": "clear",
+	"[2$": "insert",
+	"[3$": "delete",
+	"[5$": "pageup",
+	"[6$": "pagedown",
+	"[7$": "home",
+	"[8$": "end",
+	Oa: "up",
+	Ob: "down",
+	Oc: "right",
+	Od: "left",
+	Oe: "clear",
+	"[2^": "insert",
+	"[3^": "delete",
+	"[5^": "pageup",
+	"[6^": "pagedown",
+	"[7^": "home",
+	"[8^": "end",
+	"[Z": "tab"
+};
+const nonAlphanumericKeys = [...Object.values(keyName), "backspace"];
+const isShiftKey = (code) => {
+	return [
+		"[a",
+		"[b",
+		"[c",
+		"[d",
+		"[e",
+		"[2$",
+		"[3$",
+		"[5$",
+		"[6$",
+		"[7$",
+		"[8$",
+		"[Z"
+	].includes(code);
+};
+const isCtrlKey = (code) => {
+	return [
+		"Oa",
+		"Ob",
+		"Oc",
+		"Od",
+		"Oe",
+		"[2^",
+		"[3^",
+		"[5^",
+		"[6^",
+		"[7^",
+		"[8^"
+	].includes(code);
+};
+const kittyKeyRe = /^\x1b\[(\d+)(?:;(\d+)(?::(\d+))?(?:;([\d:]+))?)?u$/;
+const kittySpecialKeyRe = /^\x1b\[(\d+);(\d+):(\d+)([A-Za-z~])$/;
+const kittySpecialLetterKeys = {
+	A: "up",
+	B: "down",
+	C: "right",
+	D: "left",
+	E: "clear",
+	F: "end",
+	H: "home",
+	P: "f1",
+	Q: "f2",
+	R: "f3",
+	S: "f4"
+};
+const kittySpecialNumberKeys = {
+	2: "insert",
+	3: "delete",
+	5: "pageup",
+	6: "pagedown",
+	7: "home",
+	8: "end",
+	11: "f1",
+	12: "f2",
+	13: "f3",
+	14: "f4",
+	15: "f5",
+	17: "f6",
+	18: "f7",
+	19: "f8",
+	20: "f9",
+	21: "f10",
+	23: "f11",
+	24: "f12"
+};
+const kittyCodepointNames = {
+	27: "escape",
+	9: "tab",
+	127: "backspace",
+	8: "backspace",
+	57358: "capslock",
+	57359: "scrolllock",
+	57360: "numlock",
+	57361: "printscreen",
+	57362: "pause",
+	57363: "menu",
+	57376: "f13",
+	57377: "f14",
+	57378: "f15",
+	57379: "f16",
+	57380: "f17",
+	57381: "f18",
+	57382: "f19",
+	57383: "f20",
+	57384: "f21",
+	57385: "f22",
+	57386: "f23",
+	57387: "f24",
+	57388: "f25",
+	57389: "f26",
+	57390: "f27",
+	57391: "f28",
+	57392: "f29",
+	57393: "f30",
+	57394: "f31",
+	57395: "f32",
+	57396: "f33",
+	57397: "f34",
+	57398: "f35",
+	57399: "kp0",
+	57400: "kp1",
+	57401: "kp2",
+	57402: "kp3",
+	57403: "kp4",
+	57404: "kp5",
+	57405: "kp6",
+	57406: "kp7",
+	57407: "kp8",
+	57408: "kp9",
+	57409: "kpdecimal",
+	57410: "kpdivide",
+	57411: "kpmultiply",
+	57412: "kpsubtract",
+	57413: "kpadd",
+	57414: "kpenter",
+	57415: "kpequal",
+	57416: "kpseparator",
+	57417: "kpleft",
+	57418: "kpright",
+	57419: "kpup",
+	57420: "kpdown",
+	57421: "kppageup",
+	57422: "kppagedown",
+	57423: "kphome",
+	57424: "kpend",
+	57425: "kpinsert",
+	57426: "kpdelete",
+	57427: "kpbegin",
+	57428: "mediaplay",
+	57429: "mediapause",
+	57430: "mediaplaypause",
+	57431: "mediareverse",
+	57432: "mediastop",
+	57433: "mediafastforward",
+	57434: "mediarewind",
+	57435: "mediatracknext",
+	57436: "mediatrackprevious",
+	57437: "mediarecord",
+	57438: "lowervolume",
+	57439: "raisevolume",
+	57440: "mutevolume",
+	57441: "leftshift",
+	57442: "leftcontrol",
+	57443: "leftalt",
+	57444: "leftsuper",
+	57445: "lefthyper",
+	57446: "leftmeta",
+	57447: "rightshift",
+	57448: "rightcontrol",
+	57449: "rightalt",
+	57450: "rightsuper",
+	57451: "righthyper",
+	57452: "rightmeta",
+	57453: "isoLevel3Shift",
+	57454: "isoLevel5Shift"
+};
+const isValidCodepoint = (cp) => cp >= 0 && cp <= 1114111 && !(cp >= 55296 && cp <= 57343);
+const safeFromCodePoint = (cp) => isValidCodepoint(cp) ? String.fromCodePoint(cp) : "?";
+function resolveEventType(value) {
+	if (value === 3) return "release";
+	if (value === 2) return "repeat";
+	return "press";
+}
+function parseKittyModifiers(modifiers) {
+	return {
+		ctrl: !!(modifiers & kittyModifiers.ctrl),
+		shift: !!(modifiers & kittyModifiers.shift),
+		meta: !!(modifiers & (kittyModifiers.meta | kittyModifiers.alt)),
+		super: !!(modifiers & kittyModifiers.super),
+		hyper: !!(modifiers & kittyModifiers.hyper),
+		capsLock: !!(modifiers & kittyModifiers.capsLock),
+		numLock: !!(modifiers & kittyModifiers.numLock)
+	};
+}
+const parseKittyKeypress = (s) => {
+	const match = kittyKeyRe.exec(s);
+	if (!match) return null;
+	const codepoint = parseInt(match[1], 10);
+	const modifiers = match[2] ? Math.max(0, parseInt(match[2], 10) - 1) : 0;
+	const eventType = match[3] ? parseInt(match[3], 10) : 1;
+	const textField = match[4];
+	if (!isValidCodepoint(codepoint)) return null;
+	let text;
+	if (textField) text = textField.split(":").map((cp) => safeFromCodePoint(parseInt(cp, 10))).join("");
+	let name;
+	let isPrintable;
+	if (codepoint === 32) {
+		name = "space";
+		isPrintable = true;
+	} else if (codepoint === 13) {
+		name = "return";
+		isPrintable = true;
+	} else if (kittyCodepointNames[codepoint]) {
+		name = kittyCodepointNames[codepoint];
+		isPrintable = false;
+	} else if (codepoint >= 1 && codepoint <= 26) {
+		name = String.fromCodePoint(codepoint + 96);
+		isPrintable = false;
+	} else {
+		name = safeFromCodePoint(codepoint).toLowerCase();
+		isPrintable = true;
+	}
+	if (isPrintable && !text) text = safeFromCodePoint(codepoint);
+	return {
+		name,
+		...parseKittyModifiers(modifiers),
+		eventType: resolveEventType(eventType),
+		sequence: s,
+		raw: s,
+		isKittyProtocol: true,
+		isPrintable,
+		text
+	};
+};
+const parseKittySpecialKey = (s) => {
+	const match = kittySpecialKeyRe.exec(s);
+	if (!match) return null;
+	const number = parseInt(match[1], 10);
+	const modifiers = Math.max(0, parseInt(match[2], 10) - 1);
+	const eventType = parseInt(match[3], 10);
+	const terminator = match[4];
+	const name = terminator === "~" ? kittySpecialNumberKeys[number] : kittySpecialLetterKeys[terminator];
+	if (!name) return null;
+	return {
+		name,
+		...parseKittyModifiers(modifiers),
+		eventType: resolveEventType(eventType),
+		sequence: s,
+		raw: s,
+		isKittyProtocol: true,
+		isPrintable: false
+	};
+};
+function parseKeypress(s = "") {
+	let parts;
+	if (s instanceof Uint8Array) if (s[0] > 127 && s[1] === void 0) {
+		s[0] -= 128;
+		s = "\x1B" + textDecoder.decode(s);
+	} else s = textDecoder.decode(s);
+	else if (s !== void 0 && typeof s !== "string") s = String(s);
+	else if (!s) s = "";
+	if (kittyQueryResponseRe.test(s)) return {
+		name: "",
+		ctrl: false,
+		meta: false,
+		shift: false,
+		sequence: s,
+		raw: s,
+		ignore: true
+	};
+	const kittyResult = parseKittyKeypress(s);
+	if (kittyResult) return kittyResult;
+	const kittySpecialResult = parseKittySpecialKey(s);
+	if (kittySpecialResult) return kittySpecialResult;
+	if (kittyKeyRe.test(s)) return {
+		name: "",
+		ctrl: false,
+		meta: false,
+		shift: false,
+		sequence: s,
+		raw: s,
+		isKittyProtocol: true,
+		isPrintable: false
+	};
+	const key = {
+		name: "",
+		ctrl: false,
+		meta: false,
+		shift: false,
+		sequence: s,
+		raw: s
+	};
+	key.sequence = key.sequence || s || key.name;
+	if (s === "\r" || s === "\x1B\r") {
+		key.raw = void 0;
+		key.name = "return";
+		key.meta = s.length === 2;
+	} else if (s === "\n") key.name = "enter";
+	else if (s === "	") key.name = "tab";
+	else if (s === "\b" || s === "\x1B\b") {
+		key.name = "backspace";
+		key.meta = s.charAt(0) === "\x1B";
+	} else if (s === "" || s === "\x1B") {
+		key.name = "backspace";
+		key.meta = s.charAt(0) === "\x1B";
+	} else if (s === "\x1B" || s === "\x1B\x1B") {
+		key.name = "escape";
+		key.meta = s.length === 2;
+	} else if (s === " " || s === "\x1B ") {
+		key.name = "space";
+		key.meta = s.length === 2;
+	} else if (s.length === 1 && s <= "") {
+		key.name = String.fromCharCode(s.charCodeAt(0) + "a".charCodeAt(0) - 1);
+		key.ctrl = true;
+	} else if (s.length === 1 && s >= "0" && s <= "9") key.name = "number";
+	else if (s.length === 1 && s >= "a" && s <= "z") key.name = s;
+	else if (s.length === 1 && s >= "A" && s <= "Z") {
+		key.name = s.toLowerCase();
+		key.shift = true;
+	} else if (parts = metaKeyCodeRe.exec(s)) {
+		key.name = parts[1].toLowerCase();
+		key.meta = true;
+		key.shift = /^[A-Z]$/.test(parts[1]);
+	} else if (parts = fnKeyRe.exec(s)) {
+		const segs = [...s];
+		if (segs[0] === "\x1B" && segs[1] === "\x1B") key.meta = true;
+		const code = [
+			parts[1],
+			parts[2],
+			parts[4],
+			parts[6]
+		].filter(Boolean).join("");
+		const modifier = (parts[3] || parts[5] || 1) - 1;
+		key.ctrl = !!(modifier & 4);
+		key.meta = key.meta || !!(modifier & 10);
+		key.shift = !!(modifier & 1);
+		key.code = code;
+		key.name = keyName[code] ?? "";
+		key.shift = isShiftKey(code) || key.shift;
+		key.ctrl = isCtrlKey(code) || key.ctrl;
+	}
+	return key;
+}
+//#endregion
+//#region src/host/layout-guards.ts
+function hasYoga(node) {
+	return node.type === "root" || node.type === "tui-box" || node.type === "tui-text" || node.type === "tui-static" || node.type === "tui-transform";
+}
+function hasChildren(node) {
+	return node.type === "root" || node.type === "tui-box" || node.type === "tui-text" || node.type === "tui-static" || node.type === "tui-transform";
+}
+function getBoxInnerSize(node) {
+	const layout = node.yoga.getComputedLayout();
+	const width = Math.max(0, Math.floor(layout.width));
+	const height = Math.max(0, Math.floor(layout.height));
+	const left = node.yoga.getComputedBorder(Yoga.EDGE_LEFT) + node.yoga.getComputedPadding(Yoga.EDGE_LEFT);
+	const right = node.yoga.getComputedBorder(Yoga.EDGE_RIGHT) + node.yoga.getComputedPadding(Yoga.EDGE_RIGHT);
+	const top = node.yoga.getComputedBorder(Yoga.EDGE_TOP) + node.yoga.getComputedPadding(Yoga.EDGE_TOP);
+	const bottom = node.yoga.getComputedBorder(Yoga.EDGE_BOTTOM) + node.yoga.getComputedPadding(Yoga.EDGE_BOTTOM);
+	return {
+		width: Math.max(0, Math.floor(width - left - right)),
+		height: Math.max(0, Math.floor(height - top - bottom))
+	};
+}
+function hideYogaChild(child, guarded) {
+	if (!hasYoga(child)) return false;
+	if (guarded.has(child.yoga)) return false;
+	const display = child.yoga.getDisplay();
+	if (display === Yoga.DISPLAY_NONE) return false;
+	guarded.set(child.yoga, display);
+	child.yoga.setDisplay(Yoga.DISPLAY_NONE);
+	return true;
+}
+function applyZeroContentGuards(node, guarded) {
+	if (hasYoga(node) && node.yoga.getDisplay() === Yoga.DISPLAY_NONE) return false;
+	let changed = false;
+	if (node.type === "tui-box") {
+		const inner = getBoxInnerSize(node);
+		if (inner.width === 0 || inner.height === 0) {
+			for (const child of node.children) {
+				if (hasYoga(child) && child.yoga.getPositionType() === Yoga.POSITION_TYPE_ABSOLUTE) continue;
+				changed = hideYogaChild(child, guarded) || changed;
+			}
+			return changed;
+		}
+	}
+	if (!hasChildren(node)) return changed;
+	for (const child of node.children) changed = applyZeroContentGuards(child, guarded) || changed;
+	return changed;
+}
+function calculateLayoutWithContentGuards(root, width, height, direction = Yoga.DIRECTION_LTR) {
+	const guarded = /* @__PURE__ */ new Map();
+	const restore = () => {
+		for (const [node, display] of [...guarded].reverse()) node.setDisplay(display);
+	};
+	try {
+		for (;;) {
+			root.yoga.calculateLayout(width, height, direction);
+			if (!applyZeroContentGuards(root, guarded)) break;
+		}
+	} catch (err) {
+		restore();
+		throw err;
+	}
+	return restore;
+}
+//#endregion
+//#region src/scheduler.ts
+function createCommitScheduler(commit, options) {
+	const immediate = options.immediate ?? false;
+	const throttleMs = options.throttleMs;
+	let scheduled = false;
+	let flushResolvers = [];
+	function drainFlushResolvers() {
+		if (flushResolvers.length === 0) return;
+		const resolvers = flushResolvers;
+		flushResolvers = [];
+		for (const resolve of resolvers) resolve();
+	}
+	let trailingTimer = null;
+	let hasPendingFlag = false;
+	let pendingAt = null;
+	function doCommit() {
+		scheduled = false;
+		hasPendingFlag = false;
+		pendingAt = null;
+		try {
+			commit();
+		} finally {
+			drainFlushResolvers();
+		}
+	}
+	function armTrailingWindow() {
+		if (trailingTimer) clearTimeout(trailingTimer);
+		trailingTimer = setTimeout(() => {
+			trailingTimer = null;
+			if (hasPendingFlag) doCommit();
+		}, throttleMs);
+	}
+	function schedule() {
+		if (scheduled) return;
+		scheduled = true;
+		queueMicrotask(() => {
+			if (!scheduled) return;
+			scheduled = false;
+			if (immediate) {
+				doCommit();
+				return;
+			}
+			const now = Date.now();
+			if (pendingAt === null) pendingAt = now;
+			if (now - pendingAt >= throttleMs) {
+				doCommit();
+				pendingAt = Date.now();
+				armTrailingWindow();
+				return;
+			}
+			const isWindowActive = trailingTimer !== null;
+			armTrailingWindow();
+			if (isWindowActive) hasPendingFlag = true;
+			else doCommit();
+		});
+	}
+	function flush() {
+		if (!scheduled && !hasPendingFlag) return Promise.resolve();
+		return new Promise((resolve) => {
+			flushResolvers.push(resolve);
+		});
+	}
+	function hasPending() {
+		return hasPendingFlag;
+	}
+	function cancel() {
+		if (trailingTimer) {
+			clearTimeout(trailingTimer);
+			trailingTimer = null;
+		}
+		hasPendingFlag = false;
+		scheduled = false;
+		pendingAt = null;
+		drainFlushResolvers();
+	}
+	return {
+		schedule,
+		flush,
+		hasPending,
+		cancel
+	};
+}
+//#endregion
+//#region src/animation-scheduler.ts
+const DEFAULT_INTERVAL = 100;
+const MAX_TIMER_INTERVAL = 2147483647;
+function normalizeInterval(interval) {
+	if (interval === void 0 || !Number.isFinite(interval)) return DEFAULT_INTERVAL;
+	return Math.min(Math.max(1, interval), MAX_TIMER_INTERVAL);
+}
+function createAnimationScheduler(renderThrottleMs = 0) {
+	const subscribers = /* @__PURE__ */ new Set();
+	let timer;
+	let scheduledDueTime = Number.POSITIVE_INFINITY;
+	let isDispatching = false;
+	const pending = [];
+	function clearTimer() {
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+		scheduledDueTime = Number.POSITIVE_INFINITY;
+	}
+	function schedule() {
+		clearTimer();
+		let earliest = Number.POSITIVE_INFINITY;
+		for (const s of subscribers) if (!s.cancelled) earliest = Math.min(earliest, s.nextDueTime);
+		if (earliest === Number.POSITIVE_INFINITY) return;
+		scheduledDueTime = earliest;
+		const delay = Math.ceil(Math.max(0, earliest - performance.now()));
+		timer = setTimeout(onTick, delay);
+	}
+	function onTick() {
+		timer = void 0;
+		scheduledDueTime = Number.POSITIVE_INFINITY;
+		const now = performance.now();
+		isDispatching = true;
+		try {
+			for (const s of subscribers) {
+				if (s.cancelled || now < s.nextDueTime) continue;
+				const elapsedFrames = Math.floor((now - s.startTime) / s.interval) + 1;
+				s.nextDueTime = s.startTime + elapsedFrames * s.interval;
+				s.callback(now);
+			}
+		} finally {
+			isDispatching = false;
+			if (pending.length > 0) for (const op of pending.splice(0)) op();
+			schedule();
+		}
+	}
+	function subscribe(callback, intervalRaw) {
+		const interval = normalizeInterval(intervalRaw);
+		const startTime = performance.now();
+		const sub = {
+			callback,
+			interval,
+			startTime,
+			nextDueTime: startTime + interval,
+			cancelled: false
+		};
+		const add = () => {
+			subscribers.add(sub);
+			if (timer === void 0 || sub.nextDueTime < scheduledDueTime) schedule();
+		};
+		if (isDispatching) pending.push(add);
+		else add();
+		return {
+			startTime,
+			unsubscribe() {
+				sub.cancelled = true;
+				const remove = () => {
+					subscribers.delete(sub);
+					if (subscribers.size === 0) clearTimer();
+					else schedule();
+				};
+				if (isDispatching) pending.push(remove);
+				else remove();
+			}
+		};
+	}
+	function dispose() {
+		clearTimer();
+		subscribers.clear();
+		pending.length = 0;
+	}
+	return {
+		renderThrottleMs,
+		subscribe,
+		dispose
+	};
+}
+function createNoOpAnimationScheduler() {
+	return {
+		renderThrottleMs: 0,
+		subscribe() {
+			return {
+				startTime: 0,
+				unsubscribe() {}
+			};
+		},
+		dispose() {}
+	};
+}
+//#endregion
+//#region src/paint/text-style.ts
+const rgbRegex = /^rgb\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/;
+const ansi256Regex = /^ansi256\(\s?(\d+)\s?\)$/;
+function applyColor(c, color, bg) {
+	if (typeof color !== "string") return c;
+	const named = c[bg ? bgKey(color) : color];
+	if (typeof named === "function") return named;
+	if (color.startsWith("#")) return bg ? c.bgHex(color) : c.hex(color);
+	if (color.startsWith("ansi256")) {
+		const m = ansi256Regex.exec(color);
+		if (!m) return c;
+		const n = Number(m[1]);
+		return bg ? c.bgAnsi256(n) : c.ansi256(n);
+	}
+	if (color.startsWith("rgb")) {
+		const m = rgbRegex.exec(color);
+		if (!m) return c;
+		const [r, g, b] = [
+			Number(m[1]),
+			Number(m[2]),
+			Number(m[3])
+		];
+		return bg ? c.bgRgb(r, g, b) : c.rgb(r, g, b);
+	}
+	return c;
+}
+function bgKey(name) {
+	return "bg" + name.charAt(0).toUpperCase() + name.slice(1);
+}
+/**
+* Detect a backgroundColor value that Ink's `colorize` would THROW on.
+*
+* Ink colorize.ts (commit 40b3a75): for a BACKGROUND it tests `isNamedColor` =
+* `color in chalk`; if so it builds `bg${Capitalize(color)}` and calls
+* `chalk[methodName]`. A chalk MODIFIER name (`bold`/`dim`/`italic`/`underline`/
+* `inverse`/`hidden`/`strikethrough`/`reset`/`overline`/`visible`) is `in chalk`
+* but has NO `bg*` method, so the call is `chalk[undefined-method](str)` and throws
+* "chalk.bgBold is not a function". A chalk COLOR name resolves to a real `bg*`
+* method (works); a string NOT in chalk falls through to bare text (no throw).
+*
+* solid-tui mirrors that throw, but VALIDATES here at component-render time (not in
+* paint): a raw throw in the post-flush paint pass unwinds through Solid's
+* flushPostFlushCbs and wedges the scheduler, where onErrorCaptured can't catch it
+* (cf. the borderStyle fix #124). Returning a flag lets the component throw during
+* render so solid-tui's error boundary (onErrorCaptured → ErrorOverview) handles it.
+*
+* Only the in-chalk-but-no-bg-method case is rejected; valid colors, hex,
+* ansi256, rgb strings, and unknown non-chalk strings all return false.
+*/
+function isInvalidBackgroundColor(color) {
+	if (typeof color !== "string" || color.length === 0) return false;
+	if (!(color in chalk)) return false;
+	return typeof chalk[bgKey(color)] !== "function";
+}
+/**
+* Detect a foreground color value that Ink's `colorize` would THROW on.
+*
+* Ink's foreground path calls `chalk[color](str)` when `color in chalk`. That
+* works for real colors and modifiers (`red`, `bold`) but throws for non-method
+* chalk properties such as `level`.
+*/
+function isInvalidForegroundColor(color) {
+	if (typeof color !== "string" || color.length === 0) return false;
+	const method = chalk[color];
+	return color in chalk && typeof method !== "function";
+}
+/**
+* Throw (during component render) if `color` is a chalk-modifier-name
+* backgroundColor — the exact case Ink's colorize.ts throws on. No-op for every
+* valid background form. `label` names the offending prop in the message.
+*/
+function assertValidBackgroundColor(color, label = "backgroundColor") {
+	if (isInvalidBackgroundColor(color)) throw new Error(`Invalid ${label}: ${JSON.stringify(color)} (chalk has no bg method for it — it is a text modifier, not a background color)`);
+}
+/**
+* Throw during component render for foreground color names that Ink's paint path
+* would throw on. `label` names the offending prop in the message.
+*/
+function assertValidForegroundColor(color, label = "color") {
+	if (isInvalidForegroundColor(color)) throw new Error(`Invalid ${label}: ${JSON.stringify(color)} (chalk has this key but it is not a color method)`);
+}
+function applyChalk(text, props) {
+	let s = text;
+	if (props.dimColor) s = chalk.dim(s);
+	if (props.color) s = applyColor(chalk, props.color, false)(s);
+	if (props.backgroundColor) s = applyColor(chalk, props.backgroundColor, true)(s);
+	if (props.bold) s = chalk.bold(s);
+	if (props.italic) s = chalk.italic(s);
+	if (props.underline) s = chalk.underline(s);
+	if (props.strikethrough) s = chalk.strikethrough(s);
+	if (props.inverse) s = chalk.inverse(s);
+	return s;
+}
+//#endregion
+//#region src/paint/paint.ts
+var OutputCaches = class {
+	constructor() {
+		this.widths = /* @__PURE__ */ new Map();
+		this.blockWidths = /* @__PURE__ */ new Map();
+		this.styledCharsCache = /* @__PURE__ */ new Map();
+	}
+	getStyledChars(line) {
+		let cached = this.styledCharsCache.get(line);
+		if (cached === void 0) {
+			cached = styledCharsFromTokens(tokenize(line));
+			this.styledCharsCache.set(line, cached);
+		}
+		return cached;
+	}
+	getStringWidth(text) {
+		let cached = this.widths.get(text);
+		if (cached === void 0) {
+			cached = stringWidth(text);
+			this.widths.set(text, cached);
+		}
+		return cached;
+	}
+	getWidestLine(text) {
+		let cached = this.blockWidths.get(text);
+		if (cached === void 0) {
+			let lineWidth = 0;
+			for (const line of text.split("\n")) lineWidth = Math.max(lineWidth, this.getStringWidth(line));
+			cached = lineWidth;
+			this.blockWidths.set(text, cached);
+		}
+		return cached;
+	}
+};
+var Output = class {
+	constructor(width, height) {
+		this.ops = [];
+		this.caches = new OutputCaches();
+		this.width = width;
+		this.height = height;
+	}
+	write(x, y, lines, transformers) {
+		this.ops.push({
+			type: "write",
+			x,
+			y,
+			lines,
+			transformers
+		});
+	}
+	clip(rect) {
+		this.ops.push({
+			type: "clip",
+			clip: rect
+		});
+	}
+	unclip() {
+		this.ops.push({ type: "unclip" });
+	}
+	get() {
+		const output = [];
+		for (let y = 0; y < this.height; y++) {
+			const row = [];
+			for (let x = 0; x < this.width; x++) row.push({
+				type: "char",
+				value: " ",
+				fullWidth: false,
+				styles: []
+			});
+			output.push(row);
+		}
+		const clips = [];
+		for (const op of this.ops) {
+			if (op.type === "clip") {
+				clips.push(op.clip);
+				continue;
+			}
+			if (op.type === "unclip") {
+				clips.pop();
+				continue;
+			}
+			const { transformers } = op;
+			let { x, y } = op;
+			let lines = op.lines;
+			const clip = clips.at(-1);
+			if (clip) {
+				const clipV = typeof clip.y1 === "number" && typeof clip.y2 === "number";
+				if (clipV) {
+					const height = lines.length;
+					if (y + height < clip.y1 || y > clip.y2) continue;
+				}
+				if (clipV) {
+					const from = y < clip.y1 ? clip.y1 - y : 0;
+					const height = lines.length;
+					const to = y + height > clip.y2 ? clip.y2 - y : height;
+					lines = lines.slice(from, to);
+					if (y < clip.y1) y = clip.y1;
+				}
+			}
+			const clipH = clip && typeof clip.x1 === "number" && typeof clip.x2 === "number" ? {
+				x1: clip.x1,
+				x2: clip.x2
+			} : null;
+			if (clipH && x > clipH.x2) continue;
+			let offsetY = 0;
+			for (let [index, line] of lines.entries()) {
+				const currentLine = output[y + offsetY];
+				if (!currentLine) continue;
+				let lineX = x;
+				if (clipH) {
+					const lineWidth = this.caches.getStringWidth(line);
+					if (lineX + lineWidth < clipH.x1 || lineX > clipH.x2) {
+						offsetY++;
+						continue;
+					}
+					const from = lineX < clipH.x1 ? clipH.x1 - lineX : 0;
+					const to = lineX + lineWidth > clipH.x2 ? clipH.x2 - lineX : lineWidth;
+					if (lineX < clipH.x1) lineX = clipH.x1;
+					const maxWidth = clipH.x2 - lineX;
+					line = safeSliceEnd(sliceAnsi(line, from, to), maxWidth);
+				}
+				for (const transformer of transformers) line = transformer(line, index);
+				const characters = this.caches.getStyledChars(line);
+				let offsetX = lineX;
+				if (characters.length === 0) {
+					offsetY++;
+					continue;
+				}
+				const spaceCell = {
+					type: "char",
+					value: " ",
+					fullWidth: false,
+					styles: []
+				};
+				if (currentLine[offsetX]?.value === "" && offsetX > 0 && this.caches.getStringWidth(currentLine[offsetX - 1]?.value ?? "") > 1) currentLine[offsetX - 1] = spaceCell;
+				for (const character of characters) {
+					const characterWidth = Math.max(1, this.caches.getStringWidth(character.value));
+					currentLine[offsetX] = character;
+					if (characterWidth > 1) for (let i = 1; i < characterWidth; i++) currentLine[offsetX + i] = {
+						type: "char",
+						value: "",
+						fullWidth: false,
+						styles: character.styles
+					};
+					offsetX += characterWidth;
+				}
+				if (currentLine[offsetX]?.value === "") currentLine[offsetX] = spaceCell;
+				offsetY++;
+			}
+		}
+		return {
+			output: output.map((line) => {
+				return styledCharsToString(line.filter((item) => item !== void 0)).trimEnd();
+			}).join("\n"),
+			height: output.length
+		};
+	}
+};
+function renderTextWithInlineStyles(node, inheritedBg) {
+	if (!node.children || node.children.length === 0) return "";
+	const inner = squashInlineChildren(node.children, inheritedBg);
+	return sanitizeAnsi(applyOwnStyle(node.props, inner, inheritedBg));
+}
+function applyOwnStyle(props, inner, inheritedBg) {
+	if (inner.length === 0) return inner;
+	const defined = Object.fromEntries(Object.entries(props).filter(([, v]) => v !== void 0));
+	const ownBg = defined.backgroundColor;
+	const effectiveBg = typeof ownBg === "string" ? ownBg : inheritedBg;
+	return applyChalk(inner, {
+		...defined,
+		backgroundColor: effectiveBg
+	});
+}
+function squashInlineChildren(children, inheritedBg) {
+	let out = "";
+	let transformIndex = 0;
+	for (const child of children) {
+		out += squashTransformChild(child, transformIndex, inheritedBg);
+		if (advancesLineIndex(child)) transformIndex++;
+	}
+	return out;
+}
+function renderTransformAsText(node, inheritedBg) {
+	if (!node.children || node.children.length === 0) return "";
+	return sanitizeAnsi(squashInlineChildren(node.children, inheritedBg));
+}
+function squashTransformChild(child, index, inheritedBg) {
+	if (child.type === "text-leaf") return child.value;
+	if (child.type === "tui-virtual-text" || child.type === "tui-text") return renderTextWithInlineStyles(child, inheritedBg);
+	if (child.type === "tui-transform") {
+		let innerText = "";
+		let grandIndex = 0;
+		for (const grandchild of child.children) {
+			innerText += squashTransformChild(grandchild, grandIndex, inheritedBg);
+			if (advancesLineIndex(grandchild)) grandIndex++;
+		}
+		if (innerText.length > 0 && child.transform) innerText = child.transform(innerText, index);
+		return innerText;
+	}
+	return "";
+}
+function drawBorder(output, x, y, w, h, props, transformers) {
+	const style = props["borderStyle"];
+	if (!style) return;
+	const chars = typeof style === "string" ? cliBoxes[style] : style;
+	if (!chars) return;
+	if (w < 1 || h < 1) return;
+	const top = props["borderTop"] !== false;
+	const bottom = props["borderBottom"] !== false;
+	const left = props["borderLeft"] !== false;
+	const right = props["borderRight"] !== false;
+	const stringProp = (name) => {
+		const value = props[name];
+		return typeof value === "string" ? value : void 0;
+	};
+	const borderColor = stringProp("borderColor");
+	const generalDim = props["borderDimColor"];
+	const borderBackgroundColor = stringProp("borderBackgroundColor");
+	function colorizeEdge(s, edge) {
+		const capEdge = edge.charAt(0).toUpperCase() + edge.slice(1);
+		const edgeColor = stringProp(`border${capEdge}Color`) ?? borderColor;
+		const edgeDim = props[`border${capEdge}DimColor`] ?? generalDim;
+		const edgeBg = stringProp(`border${capEdge}BackgroundColor`) ?? borderBackgroundColor;
+		let styled = s;
+		if (edgeColor) styled = applyColor(chalk, edgeColor, false)(styled);
+		if (edgeBg) styled = applyColor(chalk, edgeBg, true)(styled);
+		if (edgeDim) styled = chalk.dim(styled);
+		return styled;
+	}
+	if (top) {
+		const tl = left ? chars.topLeft : chars.top;
+		const tr = right ? chars.topRight : chars.top;
+		const fill = Math.max(0, w - stringWidth(tl) - stringWidth(tr));
+		const raw = tl + chars.top.repeat(fill) + tr;
+		output.write(x, y, [colorizeEdge(safeSliceEnd(raw, w), "top")], transformers);
+	}
+	if (bottom) {
+		const bl = left ? chars.bottomLeft : chars.bottom;
+		const br = right ? chars.bottomRight : chars.bottom;
+		const fill = Math.max(0, w - stringWidth(bl) - stringWidth(br));
+		const raw = bl + chars.bottom.repeat(fill) + br;
+		output.write(x, y + h - 1, [colorizeEdge(safeSliceEnd(raw, w), "bottom")], transformers);
+	}
+	const offsetY = top ? 1 : 0;
+	const verticalRun = Math.max(0, h - (top ? 1 : 0) - (bottom ? 1 : 0));
+	for (let i = 0; i < verticalRun; i++) {
+		if (left) output.write(x, y + offsetY + i, [colorizeEdge(chars.left, "left")], transformers);
+		if (right) output.write(x + w - 1, y + offsetY + i, [colorizeEdge(chars.right, "right")], transformers);
+	}
+}
+function getBoxContentMetrics(node, w, h) {
+	const left = node.yoga.getComputedBorder(Yoga.EDGE_LEFT) + node.yoga.getComputedPadding(Yoga.EDGE_LEFT);
+	const right = node.yoga.getComputedBorder(Yoga.EDGE_RIGHT) + node.yoga.getComputedPadding(Yoga.EDGE_RIGHT);
+	const top = node.yoga.getComputedBorder(Yoga.EDGE_TOP) + node.yoga.getComputedPadding(Yoga.EDGE_TOP);
+	const bottom = node.yoga.getComputedBorder(Yoga.EDGE_BOTTOM) + node.yoga.getComputedPadding(Yoga.EDGE_BOTTOM);
+	const frameWidth = left + right;
+	const frameHeight = top + bottom;
+	return {
+		width: Math.max(0, Math.floor(w - frameWidth)),
+		height: Math.max(0, Math.floor(h - frameHeight))
+	};
+}
+function fillBackground(output, x, y, w, h, color, transformers) {
+	if (!color) return;
+	const width = Math.max(0, Math.floor(w));
+	const height = Math.max(0, Math.floor(h));
+	if (width === 0 || height === 0) return;
+	const line = applyChalk(" ".repeat(width), { backgroundColor: color });
+	for (let i = 0; i < height; i++) output.write(x, y + i, [line], transformers);
+}
+function paint(root) {
+	if (root.type !== "root") throw new Error("paint expects TuiRoot");
+	const layout = root.yoga.getComputedLayout();
+	const out = new Output(Math.max(1, Math.floor(layout.width)), Math.max(1, Math.floor(layout.height)));
+	paintNode(root, out, 0, 0, []);
+	return out.get().output;
+}
+function paintNode(node, output, x0, y0, transformers, inheritedBg) {
+	if (node.yoga?.getDisplay?.() === Yoga.DISPLAY_NONE) return;
+	switch (node.type) {
+		case "root":
+			for (const child of node.children) paintNode(child, output, x0, y0, transformers);
+			return;
+		case "tui-box": {
+			const layout = node.yoga.getComputedLayout();
+			const x = x0 + layout.left;
+			const y = y0 + layout.top;
+			const w = Math.max(0, Math.floor(layout.width));
+			const h = Math.max(0, Math.floor(layout.height));
+			const rawBg = node.props["backgroundColor"];
+			const ownBg = typeof rawBg === "string" ? rawBg : void 0;
+			const childBg = ownBg ? ownBg : inheritedBg;
+			if (node.props["borderStyle"]) drawBorder(output, x, y, w, h, node.props, transformers);
+			if (ownBg) {
+				const hasBorder = !!node.props["borderStyle"];
+				const bt = hasBorder && node.props["borderTop"] !== false ? 1 : 0;
+				const bb = hasBorder && node.props["borderBottom"] !== false ? 1 : 0;
+				const bl = hasBorder && node.props["borderLeft"] !== false ? 1 : 0;
+				const br = hasBorder && node.props["borderRight"] !== false ? 1 : 0;
+				fillBackground(output, x + bl, y + bt, w - bl - br, h - bt - bb, ownBg, transformers);
+			}
+			let clipped = false;
+			const overflow = node.props["overflow"];
+			const clipH = overflow === "hidden" || node.props["overflowX"] === "hidden";
+			const clipV = overflow === "hidden" || node.props["overflowY"] === "hidden";
+			if (clipH || clipV) {
+				const bl = node.yoga.getComputedBorder(Yoga.EDGE_LEFT);
+				const br = node.yoga.getComputedBorder(Yoga.EDGE_RIGHT);
+				const bt = node.yoga.getComputedBorder(Yoga.EDGE_TOP);
+				const bb = node.yoga.getComputedBorder(Yoga.EDGE_BOTTOM);
+				output.clip({
+					x1: clipH ? x + bl : void 0,
+					x2: clipH ? x + w - br : void 0,
+					y1: clipV ? y + bt : void 0,
+					y2: clipV ? y + h - bb : void 0
+				});
+				clipped = true;
+			}
+			const contentMetrics = getBoxContentMetrics(node, w, h);
+			if (contentMetrics.width === 0 || contentMetrics.height === 0) {
+				for (const child of node.children) if (child.yoga?.getPositionType?.() === Yoga.POSITION_TYPE_ABSOLUTE) paintNode(child, output, x, y, transformers, childBg);
+				if (clipped) output.unclip();
+				return;
+			}
+			for (const child of node.children) paintNode(child, output, x, y, transformers, childBg);
+			if (clipped) output.unclip();
+			return;
+		}
+		case "tui-text": {
+			const layout = node.yoga.getComputedLayout();
+			const text = renderTextWithInlineStyles(node, inheritedBg);
+			if (text === "") return;
+			const wrapWidth = Math.floor(layout.width);
+			const wrapped = wrapText(text, wrapWidth, node.props.wrap ?? "wrap");
+			if (inheritedBg) {
+				const padProps = { backgroundColor: inheritedBg };
+				for (let i = 0; i < wrapped.length; i++) {
+					const pad = wrapWidth - stringWidth(wrapped[i]);
+					if (pad > 0) wrapped[i] = wrapped[i] + applyChalk(" ".repeat(pad), padProps);
+				}
+			}
+			output.write(x0 + layout.left, y0 + layout.top, wrapped, transformers);
+			return;
+		}
+		case "tui-static": return;
+		case "tui-transform": {
+			const layout = node.yoga.getComputedLayout();
+			const x = x0 + layout.left;
+			const y = y0 + layout.top;
+			const next = [node.transform, ...transformers];
+			if (!transformHasYogaChild(node)) {
+				const text = renderTransformAsText(node, inheritedBg);
+				if (text === "") return;
+				const wrapped = wrapText(text, Math.max(1, Math.floor(layout.width)), "wrap");
+				output.write(x, y, wrapped, next);
+				return;
+			}
+			for (const child of node.children) paintNode(child, output, x, y, next, inheritedBg);
+			return;
+		}
+		case "tui-virtual-text":
+		case "text-leaf":
+		case "comment": return;
+	}
+}
+function paintIsolated(nodes, width, staticNode) {
+	if (!staticNode) return paintUnderRoot(nodes, width, (iso) => iso.yoga.setWidth(width));
+	const iso = createRoot({});
+	attachYoga(iso);
+	iso.yoga.setWidth(width);
+	const staticBox = createBox();
+	attachYoga(staticBox);
+	staticBox.yoga.copyStyle(staticNode.yoga);
+	staticBox.yoga.setDisplay(Yoga.DISPLAY_FLEX);
+	staticBox.yoga.setPositionType(Yoga.POSITION_TYPE_ABSOLUTE);
+	iso.yoga.insertChild(staticBox.yoga, 0);
+	iso.children.push(staticBox);
+	const yogaAdded = [];
+	let yIdx = 0;
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		staticBox.children.push(node);
+		const yCarrier = node;
+		if (!yCarrier.yoga || typeof yCarrier.yoga === "symbol") continue;
+		const yParent = yCarrier.yoga.getParent ? yCarrier.yoga.getParent() : null;
+		const origIndex = yParent ? findYogaIndex(yParent, yCarrier.yoga) : 0;
+		if (yParent) yParent.removeChild(yCarrier.yoga);
+		staticBox.yoga.insertChild(yCarrier.yoga, yIdx);
+		yogaAdded.push({
+			yc: yCarrier,
+			origParent: yParent,
+			origIndex
+		});
+		yIdx++;
+	}
+	let restoreLayoutGuards = () => {};
+	try {
+		restoreLayoutGuards = calculateLayoutWithContentGuards(iso, width, void 0, Yoga.DIRECTION_LTR);
+		const boxLayout = staticBox.yoga.getComputedLayout();
+		const out = new Output(Math.max(1, Math.floor(boxLayout.width)), Math.max(1, Math.floor(boxLayout.height)));
+		const x0 = -Math.floor(boxLayout.left);
+		const y0 = -Math.floor(boxLayout.top);
+		for (const child of staticBox.children) paintNode(child, out, x0, y0, []);
+		return out.get().output;
+	} finally {
+		restoreLayoutGuards();
+		for (const { yc, origParent, origIndex } of yogaAdded.slice().reverse()) {
+			staticBox.yoga.removeChild(yc.yoga);
+			if (origParent) origParent.insertChild(yc.yoga, origIndex);
+		}
+		staticBox.children.length = 0;
+		iso.yoga.removeChild(staticBox.yoga);
+		detachYoga(staticBox);
+		iso.children.length = 0;
+		detachYoga(iso);
+	}
+}
+function paintUnderRoot(nodes, width, configureRoot) {
+	const iso = createRoot({});
+	attachYoga(iso);
+	configureRoot(iso);
+	const yogaAdded = [];
+	let yIdx = 0;
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		iso.children.push(node);
+		const yCarrier = node;
+		if (!yCarrier.yoga || typeof yCarrier.yoga === "symbol") continue;
+		const yParent = yCarrier.yoga.getParent ? yCarrier.yoga.getParent() : null;
+		const origIndex = yParent ? findYogaIndex(yParent, yCarrier.yoga) : 0;
+		if (yParent) yParent.removeChild(yCarrier.yoga);
+		iso.yoga.insertChild(yCarrier.yoga, yIdx);
+		yogaAdded.push({
+			yc: yCarrier,
+			origParent: yParent,
+			origIndex
+		});
+		yIdx++;
+	}
+	let restoreLayoutGuards = () => {};
+	try {
+		restoreLayoutGuards = calculateLayoutWithContentGuards(iso, width, void 0, Yoga.DIRECTION_LTR);
+		return paint(iso);
+	} finally {
+		restoreLayoutGuards();
+		for (const { yc, origParent, origIndex } of yogaAdded.slice().reverse()) {
+			iso.yoga.removeChild(yc.yoga);
+			if (origParent) origParent.insertChild(yc.yoga, origIndex);
+		}
+		iso.children.length = 0;
+		detachYoga(iso);
+	}
+}
+function findYogaIndex(parent, child) {
+	for (let i = 0; i < parent.getChildCount(); i++) if (parent.getChild(i) === child) return i;
+	return 0;
+}
+//#endregion
+//#region src/paint/screen-reader.ts
+/**
+* Squash a single child of a text/transform context into plain SR text,
+* recursing GENERICALLY into transform-typed children to ANY depth and APPLYING
+* each CHILD transform's own fn. This is the SR twin of paint.ts /
+* text-measure.ts squashTransformChild and mirrors Ink's squashTextNodes
+* (squash-text-nodes.ts:22-39): it applies `internal_transform` for child nodes
+* (line 34) but NEVER for the top-level node it is handed — that node's own fn is
+* applied by the caller (Output), not by squash. So a nested <Transform>'s own fn
+* IS applied here (it is a child), while a STANDALONE <Transform>'s own fn is left
+* to the transform-branch caller below. (G58 MF3 / G32)
+*/
+function squashChildSR(child, index) {
+	if (child.type === "text-leaf") return child.value;
+	if (child.type === "tui-virtual-text" || child.type === "tui-text") return squashTextContent(child);
+	if (child.type === "tui-transform") {
+		let innerText = "";
+		let grandIndex = 0;
+		for (const grandchild of child.children) {
+			innerText += squashChildSR(grandchild, grandIndex);
+			if (advancesLineIndex(grandchild)) grandIndex++;
+		}
+		if (innerText.length > 0 && child.transform) innerText = child.transform(innerText, index);
+		return innerText;
+	}
+	return "";
+}
+/**
+* Squash text content from a text/virtual-text node tree into plain text
+* (no ANSI styling), suitable for screen reader output.
+*/
+function squashTextContent(node) {
+	let text = "";
+	let index = 0;
+	for (const child of node.children) {
+		text += squashChildSR(child, index);
+		if (advancesLineIndex(child)) index++;
+	}
+	return sanitizeAnsi(text);
+}
+/**
+* Resolve a box node's flexDirection as the string form the SR separator logic
+* compares against ("row" | "row-reverse" | "column" | "column-reverse").
+*
+* Prefer an explicit `props.flexDirection` when present (used by unit-test
+* fixtures that build nodes directly without a live yoga layout), otherwise read
+* the resolved direction back from the yoga node. node-ops applies flexDirection
+* to yoga but does NOT mirror it into `props` (it is not in STYLE_PROPS), and the
+* yoga node holds the Box default of row (host/yoga.ts sets FLEX_DIRECTION_ROW).
+* Mirrors static-channel.ts's resolvedFlexDirection so both SR linearization
+* paths derive the separator identically. (Ink parity, G39.)
+*/
+function resolveBoxFlexDirection(node) {
+	const fromProps = node.props["flexDirection"];
+	if (fromProps !== void 0) return fromProps;
+	switch (node.yoga.getFlexDirection()) {
+		case Yoga.FLEX_DIRECTION_ROW: return "row";
+		case Yoga.FLEX_DIRECTION_ROW_REVERSE: return "row-reverse";
+		case Yoga.FLEX_DIRECTION_COLUMN_REVERSE: return "column-reverse";
+		default: return "column";
+	}
+}
+/**
+* Render a TUI node tree to a plain-text string suitable for screen readers.
+*
+* Ported from Ink's `renderNodeToScreenReaderOutput`.
+*
+* - `display: none` nodes are skipped.
+* - Text nodes have their content squashed (no ANSI).
+* - Box/root nodes recursively render children, joined by separator based on flexDirection.
+* - Nodes with `internal_accessibility` get role and state info prepended.
+*/
+function renderScreenReaderOutput(node, options = {}) {
+	if (options.skipStaticElements && node.type === "tui-static") return "";
+	if ((node.type === "tui-box" || node.type === "tui-text" || node.type === "root" || node.type === "tui-transform") && node.yoga.getDisplay() === Yoga.DISPLAY_NONE) return "";
+	let output = "";
+	if (node.type === "tui-text") output = squashTextContent(node);
+	else if (node.type === "tui-box" || node.type === "root") {
+		const flexDirection = node.type === "tui-box" ? resolveBoxFlexDirection(node) : void 0;
+		const separator = flexDirection === "row" || flexDirection === "row-reverse" ? " " : "\n";
+		const children = flexDirection === "row-reverse" || flexDirection === "column-reverse" ? [...node.children].reverse() : node.children;
+		const parentRole = node.internal_accessibility?.role;
+		output = children.map((childNode) => renderScreenReaderOutput(childNode, {
+			parentRole,
+			skipStaticElements: options.skipStaticElements
+		})).filter(Boolean).join(separator);
+	} else if (node.type === "tui-transform") {
+		let index = 0;
+		let squashed = "";
+		for (const childNode of node.children) {
+			squashed += squashChildSR(childNode, index);
+			if (advancesLineIndex(childNode)) index++;
+		}
+		output = sanitizeAnsi(squashed);
+	}
+	if (node.type === "tui-box") {
+		const accessibility = node.internal_accessibility;
+		if (accessibility) {
+			const { role, state } = accessibility;
+			if (state) {
+				const stateDescription = Object.keys(state).filter((key) => state[key]).join(", ");
+				if (stateDescription) output = `(${stateDescription}) ${output}`;
+			}
+			if (role && role !== options.parentRole) output = `${role}: ${output}`;
+		}
+	}
+	return output;
+}
+//#endregion
+//#region src/paint/static-channel.ts
+/**
+* Read a static node's resolved flexDirection as the string form
+* screen-reader.ts compares against ("row" | "row-reverse" | "column" |
+* "column-reverse"). node-ops applies flexDirection to yoga but does NOT mirror
+* it into `props` (it's not in STYLE_PROPS), so we read it back from the yoga
+* node — which holds the resolved direction including the <Static> default of
+* column. This keeps separator/order derivation identical to how
+* screen-reader.ts (screen-reader.ts:73-82) would linearize a container.
+*/
+function resolvedFlexDirection(stat) {
+	switch (stat.yoga.getFlexDirection()) {
+		case Yoga.FLEX_DIRECTION_ROW: return "row";
+		case Yoga.FLEX_DIRECTION_ROW_REVERSE: return "row-reverse";
+		case Yoga.FLEX_DIRECTION_COLUMN_REVERSE: return "column-reverse";
+		default: return "column";
+	}
+}
+function findStatics(root, out = []) {
+	if (root.type === "tui-static") out.push(root);
+	if (root.type !== "text-leaf" && root.type !== "comment") {
+		const containerChildren = root.children;
+		for (const child of containerChildren) findStatics(child, out);
+	}
+	return out;
+}
+function isInertStaticAnchor(child) {
+	return child.type === "comment" || child.type === "text-leaf" && child.value === "";
+}
+/**
+* Paint the not-yet-written children of a single <Static> node and record them
+* as written. Returns the painted frame (without trailing "\n"), or "" when
+* there is nothing fresh to write.
+*
+* Static items are write-once. `stat.children` only ever holds the currently-
+* mounted (un-written) items because the <Static> component slices written ones
+* out — but between a write and the component's cursor advance, the just-written
+* children are still mounted, so we must skip any child already in `writtenNodes`
+* (identity-tracked, since one item = several host nodes incl. fragment anchors).
+* After painting the fresh children we call `onWritten` so the component advances
+* its cursor and unmounts them (the post-commit step mirroring Ink's
+* `useLayoutEffect(setIndex)`).
+*/
+function paintStaticNode(stat, columns, isScreenReaderEnabled = false) {
+	const fresh = stat.children.filter((child) => !stat.writtenNodes.has(child));
+	const paintableFresh = fresh.filter((child) => !isInertStaticAnchor(child));
+	let frame = "";
+	if (paintableFresh.length > 0) {
+		if (isScreenReaderEnabled) {
+			const flexDirection = resolvedFlexDirection(stat);
+			const separator = flexDirection === "row" || flexDirection === "row-reverse" ? " " : "\n";
+			frame = (flexDirection === "row-reverse" || flexDirection === "column-reverse" ? [...paintableFresh].reverse() : paintableFresh).map((child) => renderScreenReaderOutput(child, { skipStaticElements: false })).filter(Boolean).join(separator);
+		} else frame = paintIsolated(paintableFresh, columns, stat);
+		for (const child of paintableFresh) stat.writtenNodes.add(child);
+	}
+	for (const child of fresh) if (isInertStaticAnchor(child)) stat.writtenNodes.add(child);
+	if (stat.writtenNodes.size > stat.children.length) {
+		const live = new Set(stat.children);
+		for (const node of stat.writtenNodes) if (!live.has(node)) stat.writtenNodes.delete(node);
+	}
+	stat.onWritten?.();
+	return frame;
+}
+//#endregion
+//#region src/io/cursor-helpers.ts
+const showCursorEscape = "\x1B[?25h";
+const hideCursorEscape = "\x1B[?25l";
+/**
+* Compare two cursor positions. Returns true if they differ.
+*/
+const cursorPositionChanged = (a, b) => a?.x !== b?.x || a?.y !== b?.y;
+/**
+* Build escape sequence to move cursor from bottom of output to the target
+* position and show it.
+*
+* The starting row depends on the trailing newline. A frame written WITH a
+* trailing newline leaves the cursor on the blank row just past the content
+* (row `visibleLineCount`); a fullscreen frame is written WITHOUT a trailing
+* newline (render.ts:962 `isFullscreen ? output : output + "\n"`), so the cursor
+* stays on the LAST visible row (`visibleLineCount - 1`). `hasTrailingNewline`
+* selects the correct basis — using `visibleLineCount` for a no-trailing-newline
+* frame would move up one row too many, misplacing the declared caret and then
+* desyncing the next frame's buildReturnToBottom (it would undershoot the true
+* bottom, leaving stale rows). Defaults to true to preserve the trailing-newline
+* callers byte-for-byte.
+*
+* The position is clamped to the visible region before emitting: under the
+* persistent-declaration re-emit (the caret is re-asserted every commit until
+* the declaration changes), a stale {x,y} left over from a larger frame —
+* after a resize, overflow, or content shrink — must not produce an
+* out-of-range move. `y` is clamped to `[0, cursorRow]` (so a y past the
+* shrunk content lands on the last visible line, never below it) and `x` to
+* `[0, width - 1]` when `width` is known (so a column past the terminal edge
+* lands at the rightmost cell, not beyond it). This is D5 in the cursor design
+* study; D1 (a stale-but-in-range coordinate that no longer tracks content) is
+* accepted residue, not corrected here.
+*/
+const buildCursorSuffix = (visibleLineCount, cursorPosition, width, hasTrailingNewline = true) => {
+	if (!cursorPosition) return "";
+	const cursorRow = hasTrailingNewline ? visibleLineCount : Math.max(0, visibleLineCount - 1);
+	const clampedY = Math.max(0, Math.min(cursorPosition.y, cursorRow));
+	const clampedX = width !== void 0 && width > 0 ? Math.max(0, Math.min(cursorPosition.x, width - 1)) : Math.max(0, cursorPosition.x);
+	const moveUp = cursorRow - clampedY;
+	return (moveUp > 0 ? ansiEscapes.cursorUp(moveUp) : "") + ansiEscapes.cursorTo(clampedX) + showCursorEscape;
+};
+/**
+* Build escape sequence to move cursor from previousCursorPosition back to the
+* bottom of output.
+* This must be done before eraseLines or any operation that assumes cursor is
+* at the bottom.
+*/
+const buildReturnToBottom = (previousLineCount, previousCursorPosition) => {
+	if (!previousCursorPosition) return "";
+	const bottomLine = previousLineCount - 1;
+	const down = bottomLine - Math.max(0, Math.min(previousCursorPosition.y, bottomLine));
+	return (down > 0 ? ansiEscapes.cursorDown(down) : "") + ansiEscapes.cursorTo(0);
+};
+/**
+* Build the escape sequence for cursor-only updates (output unchanged, cursor
+* moved). Hides cursor if it was previously shown, returns to bottom, then
+* repositions.
+*/
+const buildCursorOnlySequence = (input) => {
+	const hidePrefix = input.cursorWasShown ? hideCursorEscape : "";
+	const returnToBottom = buildReturnToBottom(input.previousLineCount, input.previousCursorPosition);
+	const cursorSuffix = buildCursorSuffix(input.visibleLineCount, input.cursorPosition, input.width, input.hasTrailingNewline ?? true);
+	return hidePrefix + returnToBottom + cursorSuffix;
+};
+/**
+* Build the prefix that hides cursor and returns to bottom before erasing or
+* rewriting. Returns empty string if cursor was not shown.
+*/
+const buildReturnToBottomPrefix = (cursorWasShown, previousLineCount, previousCursorPosition) => {
+	if (!cursorWasShown) return "";
+	return hideCursorEscape + buildReturnToBottom(previousLineCount, previousCursorPosition);
+};
+//#endregion
+//#region src/io/log-update.ts
+const visibleLineCount = (lines, str) => str.endsWith("\n") ? lines.length - 1 : lines.length;
+const isTtyStream = (stream) => Boolean(stream.isTTY);
+const streamWidth = (stream) => stream.columns;
+const canWriteToStream = (stream) => !stream.destroyed && !stream.writableEnded;
+const hideCursor = (stream) => {
+	if (!isTtyStream(stream) || !canWriteToStream(stream)) return;
+	stream.write(hideCursorEscape);
+};
+const showCursor = (stream) => {
+	if (!isTtyStream(stream) || !canWriteToStream(stream)) return;
+	stream.write(showCursorEscape);
+};
+const createStandard = (stream, { showCursor: showCursorOption = false } = {}) => {
+	let previousLineCount = 0;
+	let previousOutput = "";
+	let hasHiddenCursor = false;
+	let cursorPosition;
+	let cursorDirty = false;
+	let previousCursorPosition;
+	let cursorWasShown = false;
+	const getActiveCursor = () => cursorPosition;
+	const hasChanges = (str, activeCursor) => {
+		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+		return str !== previousOutput || cursorChanged;
+	};
+	const render = (str) => {
+		if (!showCursorOption && !hasHiddenCursor) {
+			hideCursor(stream);
+			hasHiddenCursor = true;
+		}
+		const activeCursor = getActiveCursor();
+		cursorDirty = false;
+		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+		if (!hasChanges(str, activeCursor)) return false;
+		const lines = str.split("\n");
+		const visibleCount = visibleLineCount(lines, str);
+		const hasTrailingNewline = str.endsWith("\n");
+		const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor, streamWidth(stream), hasTrailingNewline);
+		if (str === previousOutput && cursorChanged) stream.write(buildCursorOnlySequence({
+			cursorWasShown,
+			previousLineCount,
+			previousCursorPosition,
+			visibleLineCount: visibleCount,
+			cursorPosition: activeCursor,
+			width: streamWidth(stream),
+			hasTrailingNewline
+		}));
+		else {
+			previousOutput = str;
+			const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
+			stream.write(returnPrefix + ansiEscapes.eraseLines(previousLineCount) + str + cursorSuffix);
+			previousLineCount = lines.length;
+		}
+		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+		cursorWasShown = activeCursor !== void 0;
+		return true;
+	};
+	render.clear = () => {
+		const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
+		stream.write(prefix + ansiEscapes.eraseLines(previousLineCount));
+		previousOutput = "";
+		previousLineCount = 0;
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+	};
+	render.done = () => {
+		previousOutput = "";
+		previousLineCount = 0;
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+		if (!showCursorOption) {
+			showCursor(stream);
+			hasHiddenCursor = false;
+		}
+	};
+	render.reset = () => {
+		previousOutput = "";
+		previousLineCount = 0;
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+	};
+	render.sync = (str, options) => {
+		const activeCursor = options?.cursor === false ? void 0 : getActiveCursor();
+		cursorDirty = false;
+		const lines = str.split("\n");
+		previousOutput = str;
+		previousLineCount = lines.length;
+		if (!activeCursor && cursorWasShown) stream.write(hideCursorEscape);
+		if (activeCursor) stream.write(buildCursorSuffix(visibleLineCount(lines, str), activeCursor, streamWidth(stream), str.endsWith("\n")));
+		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+		cursorWasShown = activeCursor !== void 0;
+	};
+	render.setCursorPosition = (position) => {
+		cursorPosition = position;
+		cursorDirty = true;
+	};
+	render.isCursorDirty = () => cursorDirty;
+	render.willRender = (str) => hasChanges(str, getActiveCursor());
+	return render;
+};
+const createIncremental = (stream, { showCursor: showCursorOption = false } = {}) => {
+	let previousLines = [];
+	let previousOutput = "";
+	let hasHiddenCursor = false;
+	let cursorPosition;
+	let cursorDirty = false;
+	let previousCursorPosition;
+	let cursorWasShown = false;
+	const getActiveCursor = () => cursorPosition;
+	const hasChanges = (str, activeCursor) => {
+		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+		return str !== previousOutput || cursorChanged;
+	};
+	const render = (str) => {
+		if (!showCursorOption && !hasHiddenCursor) {
+			hideCursor(stream);
+			hasHiddenCursor = true;
+		}
+		const activeCursor = getActiveCursor();
+		cursorDirty = false;
+		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
+		if (!hasChanges(str, activeCursor)) return false;
+		const nextLines = str.split("\n");
+		const visibleCount = visibleLineCount(nextLines, str);
+		const previousVisible = visibleLineCount(previousLines, previousOutput);
+		if (str === previousOutput && cursorChanged) {
+			stream.write(buildCursorOnlySequence({
+				cursorWasShown,
+				previousLineCount: previousLines.length,
+				previousCursorPosition,
+				visibleLineCount: visibleCount,
+				cursorPosition: activeCursor,
+				width: streamWidth(stream),
+				hasTrailingNewline: str.endsWith("\n")
+			}));
+			previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+			cursorWasShown = activeCursor !== void 0;
+			return true;
+		}
+		const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
+		if (str === "\n" || previousOutput.length === 0) {
+			const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor, streamWidth(stream), str.endsWith("\n"));
+			stream.write(returnPrefix + ansiEscapes.eraseLines(previousLines.length) + str + cursorSuffix);
+			cursorWasShown = activeCursor !== void 0;
+			previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+			previousOutput = str;
+			previousLines = nextLines;
+			return true;
+		}
+		const hasTrailingNewline = str.endsWith("\n");
+		const buffer = [];
+		buffer.push(returnPrefix);
+		if (visibleCount < previousVisible) {
+			const extraSlot = previousOutput.endsWith("\n") ? 1 : 0;
+			buffer.push(ansiEscapes.eraseLines(previousVisible - visibleCount + extraSlot), ansiEscapes.cursorUp(visibleCount));
+		} else buffer.push(ansiEscapes.cursorUp(previousLines.length - 1));
+		for (let i = 0; i < visibleCount; i++) {
+			const isLastLine = i === visibleCount - 1;
+			if (nextLines[i] === previousLines[i]) {
+				if (!isLastLine || hasTrailingNewline) buffer.push(ansiEscapes.cursorNextLine);
+				continue;
+			}
+			buffer.push(ansiEscapes.cursorTo(0) + nextLines[i] + ansiEscapes.eraseEndLine + (isLastLine && !hasTrailingNewline ? "" : "\n"));
+		}
+		const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor, streamWidth(stream), hasTrailingNewline);
+		buffer.push(cursorSuffix);
+		stream.write(buffer.join(""));
+		cursorWasShown = activeCursor !== void 0;
+		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+		previousOutput = str;
+		previousLines = nextLines;
+		return true;
+	};
+	render.clear = () => {
+		const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
+		stream.write(prefix + ansiEscapes.eraseLines(previousLines.length));
+		previousOutput = "";
+		previousLines = [];
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+	};
+	render.done = () => {
+		previousOutput = "";
+		previousLines = [];
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+		if (!showCursorOption) {
+			showCursor(stream);
+			hasHiddenCursor = false;
+		}
+	};
+	render.reset = () => {
+		previousOutput = "";
+		previousLines = [];
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+	};
+	render.sync = (str, options) => {
+		const activeCursor = options?.cursor === false ? void 0 : getActiveCursor();
+		cursorDirty = false;
+		const lines = str.split("\n");
+		previousOutput = str;
+		previousLines = lines;
+		if (!activeCursor && cursorWasShown) stream.write(hideCursorEscape);
+		if (activeCursor) stream.write(buildCursorSuffix(visibleLineCount(lines, str), activeCursor, streamWidth(stream), str.endsWith("\n")));
+		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
+		cursorWasShown = activeCursor !== void 0;
+	};
+	render.setCursorPosition = (position) => {
+		cursorPosition = position;
+		cursorDirty = true;
+	};
+	render.isCursorDirty = () => cursorDirty;
+	render.willRender = (str) => hasChanges(str, getActiveCursor());
+	return render;
+};
+const create = (stream, { showCursor: showCursorOption = false, incremental = false } = {}) => {
+	if (incremental) return createIncremental(stream, { showCursor: showCursorOption });
+	return createStandard(stream, { showCursor: showCursorOption });
+};
+const logUpdate = { create };
+//#endregion
+//#region src/io/frame-writer.ts
+function createFrameWriter(stream, options) {
+	let lastFrame = null;
+	const debug = options.debug ?? false;
+	const log = debug ? null : logUpdate.create(stream, { incremental: options.incremental });
+	return {
+		write(frame) {
+			if (frame === lastFrame && !(log && log.isCursorDirty())) return;
+			lastFrame = frame;
+			if (debug) stream.write(frame + "\n");
+			else log(frame);
+		},
+		done() {
+			if (log) log.done();
+		},
+		clear() {
+			lastFrame = null;
+			if (log) log.clear();
+		},
+		sync(frame, options) {
+			lastFrame = frame;
+			if (log) log.sync(frame, options);
+		},
+		setCursorPosition(pos) {
+			if (log) log.setCursorPosition(pos);
+		},
+		isCursorDirty() {
+			return log ? log.isCursorDirty() : false;
+		},
+		willRender(frame) {
+			return log ? log.willRender(frame) : true;
+		}
+	};
+}
+//#endregion
+//#region src/io/frame-sink.ts
+/**
+* Symbol key for the internal frame sink on the mount options object. Unique
+* (created via `Symbol(...)`, not `Symbol.for(...)`) so it can never collide
+* with a user-supplied key and is invisible to normal property enumeration.
+*/
+const INTERNAL_FRAME_SINK = Symbol("solid-tui.internal.frameSink");
+//#endregion
+//#region src/io/write-synchronized.ts
+const bsu = "\x1B[?2026h";
+const esu = "\x1B[?2026l";
+function shouldSynchronize(stream, interactive) {
+	return "isTTY" in stream && stream.isTTY && (interactive ?? !isInCi);
+}
+//#endregion
+//#region src/context.ts
+const AppContextKey = createContext();
+const FocusContextKey = createContext();
+const StdinContextKey = createContext();
+const AnimationSchedulerKey = createContext();
+const TextContextKey = createContext(false);
+//#endregion
+//#region src/components/box-validate.ts
+const BOX_STYLE_GLYPHS = [
+	"top",
+	"bottom",
+	"left",
+	"right",
+	"topLeft",
+	"topRight",
+	"bottomLeft",
+	"bottomRight"
+];
+/**
+* True only when `value` is a real BoxStyle: an object carrying every glyph
+* paint reads, each a string. Rejects undefined (unknown preset name), the
+* cli-boxes `default` self-key / prototype members (objects without string
+* glyphs), partial custom objects, and truthy non-objects (e.g. a number).
+*/
+function isValidBoxStyleShape(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const box = value;
+	return BOX_STYLE_GLYPHS.every((glyph) => typeof box[glyph] === "string");
+}
+/**
+* Eager render-time validation for `<Box>`. Runs every render and throws into the
+* error boundary on invalid input — exactly as box.ts's render fn did. Returns
+* `true` so it can gate a `v-if`.
+*
+* Everything validated here is PAINT-TIME VISUAL input (own/border background colors,
+* per-edge border foreground colors, borderStyle shape) — it only matters when the
+* Box is actually painted. There is no structural validation here. So callers must
+* skip it whenever the Box's visuals are never painted:
+*   - a screen-reader-HIDDEN Box (a non-emitted node never colorizes — same ordering
+*     as box.ts), and
+*   - GLOBAL screen-reader mode (the whole tree is linearized to plain text; solid-tui,
+*     like Ink, never colorizes / draws borders for ANY node, so it never throws on an
+*     invalid color — verified against Ink v7.0.4). See box.ts.
+*/
+function assertBoxValid(props) {
+	assertValidBackgroundColor(props.backgroundColor);
+	if (props.borderStyle) {
+		const stringStyle = (value) => typeof value === "string" ? value : void 0;
+		const generalBg = stringStyle(props.borderBackgroundColor);
+		const generalFg = stringStyle(props.borderColor);
+		if (props.borderTop !== false) {
+			assertValidForegroundColor(stringStyle(props.borderTopColor) ?? generalFg, "borderTopColor");
+			assertValidBackgroundColor(stringStyle(props.borderTopBackgroundColor) ?? generalBg, "borderTopBackgroundColor");
+		}
+		if (props.borderBottom !== false) {
+			assertValidForegroundColor(stringStyle(props.borderBottomColor) ?? generalFg, "borderBottomColor");
+			assertValidBackgroundColor(stringStyle(props.borderBottomBackgroundColor) ?? generalBg, "borderBottomBackgroundColor");
+		}
+		if (props.borderLeft !== false) {
+			assertValidForegroundColor(stringStyle(props.borderLeftColor) ?? generalFg, "borderLeftColor");
+			assertValidBackgroundColor(stringStyle(props.borderLeftBackgroundColor) ?? generalBg, "borderLeftBackgroundColor");
+		}
+		if (props.borderRight !== false) {
+			assertValidForegroundColor(stringStyle(props.borderRightColor) ?? generalFg, "borderRightColor");
+			assertValidBackgroundColor(stringStyle(props.borderRightBackgroundColor) ?? generalBg, "borderRightBackgroundColor");
+		}
+	}
+	const borderStyle = props.borderStyle;
+	if (borderStyle) {
+		if (typeof borderStyle === "string") {
+			const resolved = cliBoxes[borderStyle];
+			if (!isValidBoxStyleShape(resolved)) throw new Error(`Unknown borderStyle: ${JSON.stringify(borderStyle)}`);
+		} else if (!isValidBoxStyleShape(borderStyle)) throw new Error(`Invalid borderStyle: ${JSON.stringify(borderStyle)}`);
+	}
+	return true;
+}
+//#endregion
+//#region src/components/box.ts
+function Box(props) {
+	const appCtx = useContext(AppContextKey);
+	const [local, rest] = splitProps(props, [
+		"children",
+		"ariaHidden",
+		"ariaLabel"
+	]);
+	const el = createElement("tui-box");
+	spread(el, rest, true);
+	insert(el, () => {
+		return (appCtx?.isScreenReaderEnabled ?? false) && local.ariaLabel ? local.ariaLabel : local.children;
+	});
+	return (() => {
+		const srEnabled = appCtx?.isScreenReaderEnabled ?? false;
+		if (srEnabled && local.ariaHidden) return null;
+		if (!srEnabled) assertBoxValid(props);
+		return el;
+	});
+}
+//#endregion
+//#region src/components/text.ts
+function Text(props) {
+	const insideText = useContext(TextContextKey);
+	const appCtx = useContext(AppContextKey);
+	const [local, rest] = splitProps(props, [
+		"children",
+		"ariaHidden",
+		"ariaLabel"
+	]);
+	const el = createElement(insideText ? "tui-virtual-text" : "tui-text");
+	const content = createComponent$1(TextContextKey.Provider, {
+		value: true,
+		get children() {
+			return local.children;
+		}
+	});
+	spread(el, () => ({
+		...rest,
+		wrap: rest.wrap ?? "wrap",
+		...insideText ? null : { flexShrink: 1 }
+	}), true);
+	insert(el, () => {
+		return (appCtx?.isScreenReaderEnabled ?? false) && local.ariaLabel ? local.ariaLabel : content;
+	});
+	return (() => {
+		const srEnabled = appCtx?.isScreenReaderEnabled ?? false;
+		if (srEnabled && local.ariaHidden) return null;
+		if (!srEnabled) {
+			assertValidForegroundColor(rest.color);
+			assertValidBackgroundColor(rest.backgroundColor);
+		}
+		return srEnabled && local.ariaLabel != null || local.children != null ? el : null;
+	});
+}
+//#endregion
+//#region src/components/error-overview.ts
+const cleanupPath = (path) => {
+	return path?.replace(`file://${cwd()}/`, "");
+};
+const stackUtils = new StackUtils({
+	cwd: cwd(),
+	internals: StackUtils.nodeInternals()
+});
+const safeString = (value) => {
+	try {
+		return String(value);
+	} catch {
+		return "[unserializable value]";
+	}
+};
+function messageForNonError(value) {
+	let message;
+	try {
+		message = value?.message;
+	} catch {
+		return safeString(value);
+	}
+	return typeof message === "string" ? message : safeString(value);
+}
+function isErrorInput(value) {
+	try {
+		return value instanceof Error || Object.prototype.toString.call(value) === "[object Error]";
+	} catch {
+		return false;
+	}
+}
+function ErrorOverview(props) {
+	return createComponent$1(Box, {
+		flexDirection: "column",
+		padding: 1,
+		get children() {
+			const error = props.error;
+			let errorStack;
+			try {
+				const rawStack = error?.stack;
+				errorStack = typeof rawStack === "string" ? rawStack : void 0;
+			} catch {
+				errorStack = void 0;
+			}
+			const errorMessage = messageForNonError(error);
+			const stack = errorStack ? errorStack.split("\n").slice(1) : void 0;
+			const origin = stack ? stackUtils.parseLine(stack[0]) : void 0;
+			const filePath = cleanupPath(origin?.file);
+			let excerpt;
+			let lineWidth = 0;
+			if (filePath && origin?.line && fs.existsSync(filePath)) try {
+				excerpt = codeExcerpt(fs.readFileSync(filePath, "utf8"), origin.line);
+				if (excerpt) for (const { line } of excerpt) lineWidth = Math.max(lineWidth, String(line).length);
+			} catch {
+				excerpt = void 0;
+			}
+			const parts = [createComponent$1(Box, { get children() {
+				return [createComponent$1(Text, {
+					backgroundColor: "red",
+					color: "white",
+					children: " ERROR "
+				}), createComponent$1(Text, { children: ` ${errorMessage}` })];
+			} })];
+			if (origin && filePath) parts.push(createComponent$1(Box, {
+				marginTop: 1,
+				get children() {
+					return createComponent$1(Text, {
+						dimColor: true,
+						children: `${filePath}:${origin.line}:${origin.column}`
+					});
+				}
+			}));
+			if (origin && excerpt) parts.push(createComponent$1(Box, {
+				marginTop: 1,
+				flexDirection: "column",
+				get children() {
+					return excerpt.map(({ line, value }) => createComponent$1(Box, { get children() {
+						return [createComponent$1(Box, {
+							width: lineWidth + 1,
+							get children() {
+								return createComponent$1(Text, {
+									dimColor: line !== origin.line,
+									backgroundColor: line === origin.line ? "red" : void 0,
+									color: line === origin.line ? "white" : void 0,
+									ariaLabel: line === origin.line ? `Line ${line}, error` : `Line ${line}`,
+									children: `${String(line).padStart(lineWidth, " ")}:`
+								});
+							}
+						}), createComponent$1(Text, {
+							backgroundColor: line === origin.line ? "red" : void 0,
+							color: line === origin.line ? "white" : void 0,
+							children: ` ${value}`
+						})];
+					} }));
+				}
+			}));
+			if (errorStack) parts.push(createComponent$1(Box, {
+				marginTop: 1,
+				flexDirection: "column",
+				get children() {
+					return errorStack.split("\n").slice(1).map((line) => {
+						const parsedLine = stackUtils.parseLine(line);
+						if (!parsedLine) return createComponent$1(Box, { get children() {
+							return [createComponent$1(Text, {
+								dimColor: true,
+								children: "- "
+							}), createComponent$1(Text, {
+								dimColor: true,
+								bold: true,
+								children: line + "\\t "
+							})];
+						} });
+						const file = cleanupPath(parsedLine.file) ?? "";
+						return createComponent$1(Box, { get children() {
+							return [
+								createComponent$1(Text, {
+									dimColor: true,
+									children: "- "
+								}),
+								createComponent$1(Text, {
+									dimColor: true,
+									bold: true,
+									children: parsedLine.function
+								}),
+								createComponent$1(Text, {
+									dimColor: true,
+									color: "gray",
+									ariaLabel: `at ${file} line ${parsedLine.line} column ${parsedLine.column}`,
+									children: ` (${file}:${parsedLine.line}:${parsedLine.column})`
+								})
+							];
+						} });
+					});
+				}
+			}));
+			return parts;
+		}
+	});
+}
+//#endregion
+//#region src/hooks/useWindowSize.ts
+function resolveSize(stdout) {
+	const cols = stdout.columns;
+	const rowsVal = stdout.rows;
+	if (cols && rowsVal) return {
+		columns: cols,
+		rows: rowsVal
+	};
+	const fallback = terminalSize();
+	return {
+		columns: cols || fallback.columns || 80,
+		rows: rowsVal || fallback.rows || 24
+	};
+}
+function useWindowSize() {
+	const ctx = useContext(AppContextKey);
+	if (!ctx) throw new Error("useWindowSize() must be called inside a solid-tui render tree");
+	const appCtx = ctx;
+	const initial = resolveSize(appCtx.stdout);
+	const [columns, setColumns] = createSignal(initial.columns);
+	const [rows, setRows] = createSignal(initial.rows);
+	function onResize() {
+		const size = resolveSize(appCtx.stdout);
+		setColumns(size.columns);
+		setRows(size.rows);
+	}
+	appCtx.stdout.on("resize", onResize);
+	onCleanup(() => appCtx.stdout.off("resize", onResize));
+	return {
+		columns,
+		rows
+	};
+}
+//#endregion
+//#region src/hmr.ts
+const [readDevState, writeDevState] = createSignal({ type: "ok" });
+const DevStateKey = createContext();
+const devState = {
+	get value() {
+		return readDevState();
+	},
+	set value(next) {
+		writeDevState(next);
+	},
+	read: readDevState
+};
+const realHot = import.meta.hot;
+let bridgedHot;
+let currentDevAppTeardown;
+let pendingResetTimer;
+let devConnected = false;
+function registerDevApp(teardown) {
+	currentDevAppTeardown = teardown;
+}
+function unregisterDevApp(teardown) {
+	if (currentDevAppTeardown === teardown) currentDevAppTeardown = void 0;
+}
+function initHmrBridge(hot = realHot) {
+	if (!hot || hot === bridgedHot) return;
+	bridgedHot = hot;
+	hot.on("vite:error", (payload) => {
+		if (pendingResetTimer !== void 0) {
+			clearTimeout(pendingResetTimer);
+			pendingResetTimer = void 0;
+		}
+		devState.value = {
+			type: "error",
+			error: payload.err
+		};
+	});
+	hot.on("vite:beforeUpdate", (payload) => {
+		if (pendingResetTimer !== void 0) {
+			clearTimeout(pendingResetTimer);
+			pendingResetTimer = void 0;
+		}
+		devState.value = {
+			type: "update",
+			paths: payload.updates.map((u) => u.path)
+		};
+		const timer = setTimeout(() => {
+			pendingResetTimer = void 0;
+			if (devState.value.type === "update") devState.value = { type: "ok" };
+		}, 2e3);
+		pendingResetTimer = timer;
+		timer.unref?.();
+	});
+	hot.on("vite:beforeFullReload", () => {
+		currentDevAppTeardown?.();
+		currentDevAppTeardown = void 0;
+		hot.send("solid-tui:request-reload");
+	});
+}
+function isDevConnected() {
+	return devConnected;
+}
+function connectDevtools(hot) {
+	devConnected = true;
+	initHmrBridge(hot);
+}
+function notifyDevExit() {
+	bridgedHot?.send("solid-tui:exit");
+}
+function resetDevState() {
+	devState.value = { type: "ok" };
+}
+//#endregion
+//#region src/overlay.ts
+function ErrorDisplay(props) {
+	return createComponent$1(Box, {
+		flexDirection: "column",
+		borderStyle: "single",
+		borderColor: "red",
+		paddingX: 1,
+		get children() {
+			return [
+				createComponent$1(Text, {
+					color: "red",
+					bold: true,
+					children: "Build Error"
+				}),
+				createComponent$1(Text, { get children() {
+					return props.error.error.message;
+				} }),
+				props.error.error.loc ? createComponent$1(Text, {
+					dimColor: true,
+					get children() {
+						const loc = props.error.error.loc;
+						return `${loc.file}:${loc.line}:${loc.column}`;
+					}
+				}) : null
+			];
+		}
+	});
+}
+function StatusLine(props) {
+	return createComponent$1(Text, {
+		dimColor: true,
+		get children() {
+			return `[HMR] updated: ${props.paths.join(", ")}`;
+		}
+	});
+}
+function createDevOverlayWrapper(Root, rootProps) {
+	return function DevOverlayWrapper() {
+		const state = useContext(DevStateKey);
+		return (() => {
+			const current = state?.() ?? { type: "ok" };
+			if (current.type === "error") return createComponent$1(ErrorDisplay, { error: current });
+			return createComponent$1(Box, {
+				flexDirection: "column",
+				flexGrow: 1,
+				get children() {
+					return [createComponent$1(Box, {
+						flexGrow: 1,
+						get children() {
+							return createComponent$1(Root, rootProps ?? {});
+						}
+					}), current.type === "update" ? createComponent$1(StatusLine, { paths: current.paths }) : null];
+				}
+			});
+		});
+	};
+}
+//#endregion
+//#region src/render.ts
+const liveInstances = /* @__PURE__ */ new WeakMap();
+function getWritableStreamState(stdout) {
+	return {
+		canWriteToStdout: !stdout.destroyed && !stdout.writableEnded && (stdout.writable ?? true),
+		hasWritableState: stdout._writableState !== void 0 || stdout.writableLength !== void 0
+	};
+}
+function isComponent(value) {
+	return typeof value === "function";
+}
+function createApp(root, rootProps) {
+	let exitResolve;
+	let exitReject;
+	const exitPromise = new Promise((res, rej) => {
+		exitResolve = res;
+		exitReject = rej;
+	});
+	exitPromise.catch(() => {});
+	let mountedRoot = null;
+	let mountedDispose = null;
+	let mountedScheduler = null;
+	let mountedAnimationScheduler = null;
+	let mountedStdinController = null;
+	let mountedKittyController = null;
+	let mountedRestoreRendererCommit = null;
+	let mountedRestoreConsole = null;
+	let mountedResizeHandler = null;
+	let mountedUnsubscribeExit = null;
+	let mountedExitListener = null;
+	let mountedDevTeardown = null;
+	let mountedClear = null;
+	let mountedAppContext = null;
+	let mountedStdout = null;
+	let mountedGetLastOutput = null;
+	let mountedAsOwner = false;
+	let teardownStarted = false;
+	let exitInitiated = false;
+	let pendingExitError;
+	let pendingExitResult;
+	function resolveExit() {
+		const finish = () => {
+			if (isErrorInput(pendingExitError)) exitReject(pendingExitError);
+			else exitResolve(pendingExitResult);
+		};
+		const stdout = mountedAppContext?.stdout;
+		if (!stdout) {
+			setImmediate(finish);
+			return;
+		}
+		const { canWriteToStdout, hasWritableState } = getWritableStreamState(stdout);
+		if (canWriteToStdout && hasWritableState) stdout.write("", finish);
+		else setImmediate(finish);
+	}
+	function teardown() {
+		if (teardownStarted) return;
+		teardownStarted = true;
+		mountedScheduler?.cancel();
+		mountedRestoreRendererCommit?.();
+		mountedRestoreRendererCommit = null;
+		mountedClear = null;
+		mountedGetLastOutput = null;
+		if (mountedRestoreConsole) {
+			mountedRestoreConsole();
+			mountedRestoreConsole = null;
+		}
+		mountedDispose?.();
+		mountedDispose = null;
+		mountedAnimationScheduler?.dispose();
+		mountedAnimationScheduler = null;
+		mountedKittyController?.dispose();
+		mountedKittyController = null;
+		mountedStdinController?.dispose();
+		mountedStdinController = null;
+		if (mountedRoot) {
+			detachYoga(mountedRoot);
+			mountedRoot = null;
+		}
+		if (mountedResizeHandler && mountedAppContext) mountedAppContext.stdout.off("resize", mountedResizeHandler);
+		mountedResizeHandler = null;
+		if (mountedUnsubscribeExit) {
+			mountedUnsubscribeExit();
+			mountedUnsubscribeExit = null;
+		}
+		if (mountedExitListener) {
+			process.off("exit", mountedExitListener);
+			mountedExitListener = null;
+		}
+		if (mountedDevTeardown) {
+			unregisterDevApp(mountedDevTeardown);
+			mountedDevTeardown = null;
+		}
+		if (mountedAppContext?.interactive && mountedAppContext.stdout.isTTY) {
+			mountedAppContext.stdout.write("\x1B[?25h");
+			if (mountedAppContext.stdout.isTTY) mountedAppContext.stdout.write(ansiEscapes.exitAlternativeScreen);
+		}
+		if (mountedAsOwner && mountedStdout) {
+			liveInstances.delete(mountedStdout);
+			mountedAsOwner = false;
+		}
+	}
+	const app = {
+		mount(options = {}) {
+			if (mountedRoot) return {};
+			const stdout = options.stdout ?? process.stdout;
+			const stdin = options.stdin ?? process.stdin;
+			const stderr = options.stderr ?? process.stderr;
+			const debug = options.debug ?? false;
+			const frameSink = options[INTERNAL_FRAME_SINK];
+			if (liveInstances.has(stdout)) {
+				process.stderr.write("Warning: this stdout already has a live app, so this mount() was ignored. Unmount the existing app before mounting another one.\n");
+				return {};
+			}
+			liveInstances.set(stdout, app);
+			mountedAsOwner = true;
+			mountedStdout = stdout;
+			teardownStarted = false;
+			const interactive = options.interactive ?? (!isInCi && Boolean(stdout.isTTY));
+			const isScreenReaderEnabled = options.isScreenReaderEnabled ?? process.env["INK_SCREEN_READER"] === "true";
+			const maxFps = options.maxFps ?? 30;
+			const unthrottled = debug || isScreenReaderEnabled;
+			const renderThrottleMs = !unthrottled && maxFps > 0 ? Math.max(1, Math.ceil(1e3 / maxFps)) : 0;
+			const frameState = {
+				lastOutput: "",
+				lastOutputToRender: "",
+				outputHeight: 0,
+				fullStaticOutput: ""
+			};
+			mountedGetLastOutput = () => frameState.lastOutput;
+			let cursorPosition;
+			const writer = createFrameWriter(stdout, {
+				debug,
+				incremental: options.incrementalRendering
+			});
+			const synchronize = shouldSynchronize(stdout, interactive);
+			function writeToStdout(data) {
+				if (teardownStarted) return;
+				if (debug || !interactive) {
+					stdout.write(data);
+					return;
+				}
+				if (synchronize) stdout.write(bsu);
+				writer.clear();
+				stdout.write(data);
+				writer.write(frameState.lastOutputToRender || frameState.lastOutput + "\n");
+				if (synchronize) stdout.write(esu);
+			}
+			function writeToStderr(data) {
+				if (teardownStarted) return;
+				if (debug || !interactive) {
+					stderr.write(data);
+					return;
+				}
+				if (synchronize) stdout.write(bsu);
+				writer.clear();
+				stderr.write(data);
+				writer.write(frameState.lastOutputToRender || frameState.lastOutput + "\n");
+				if (synchronize) stdout.write(esu);
+			}
+			const appContext = {
+				exit(errorOrResult) {
+					if (exitInitiated || teardownStarted) return;
+					exitInitiated = true;
+					if (isErrorInput(errorOrResult)) pendingExitError = errorOrResult;
+					else pendingExitResult = errorOrResult;
+					queueMicrotask(() => {
+						teardown();
+						resolveExit();
+					});
+				},
+				waitUntilRenderFlush,
+				stdout,
+				stderr,
+				stdin,
+				debug,
+				interactive,
+				isScreenReaderEnabled,
+				isRawModeSupported: !!stdin.isTTY,
+				setRawMode(mode) {
+					const raw = stdin;
+					if (typeof raw.setRawMode === "function") raw.setRawMode(mode);
+				},
+				writeToStdout,
+				writeToStderr,
+				cursorPosition: void 0,
+				setCursorPosition(pos) {
+					cursorPosition = pos;
+					appContext.cursorPosition = pos;
+					writer.setCursorPosition(pos);
+				}
+			};
+			mountedAppContext = appContext;
+			const focusContext = createFocusController();
+			const stdinController = createStdinController(stdin, {
+				exitOnCtrlC: options.exitOnCtrlC ?? true,
+				appCtx: appContext,
+				focusContext
+			});
+			mountedStdinController = stdinController;
+			if ((options.rawMode ?? "always") === "always" && interactive && stdinController.isRawModeSupported) stdinController.holdRawModeForLifetime();
+			const kittyController = createKittyKeyboardController(stdin, stdout);
+			mountedKittyController = kittyController;
+			kittyController.init(options.kittyKeyboard, interactive);
+			const tuiRoot = createRoot(appContext);
+			attachYoga(tuiRoot);
+			tuiRoot.yoga.setWidth(resolveSize(stdout).columns);
+			mountedRoot = tuiRoot;
+			const animationScheduler = createAnimationScheduler(renderThrottleMs);
+			mountedAnimationScheduler = animationScheduler;
+			const [caughtError, setCaughtError] = createSignal();
+			const devConnected = isDevConnected();
+			let userRoot = root;
+			let userRootProps = rootProps;
+			if (devConnected) {
+				resetDevState();
+				userRoot = createDevOverlayWrapper(userRoot, userRootProps ?? void 0);
+				userRootProps = void 0;
+			}
+			const Root = () => catchError(() => createComponent$1(AppContextKey.Provider, {
+				value: appContext,
+				get children() {
+					const tree = () => createComponent$1(FocusContextKey.Provider, {
+						value: focusContext,
+						get children() {
+							return createComponent$1(StdinContextKey.Provider, {
+								value: stdinController,
+								get children() {
+									return createComponent$1(AnimationSchedulerKey.Provider, {
+										value: animationScheduler,
+										get children() {
+											const err = caughtError();
+											if (err !== void 0) return createComponent$1(ErrorOverview, { error: err });
+											return isComponent(userRoot) ? createComponent$1(userRoot, userRootProps ?? {}) : userRoot;
+										}
+									});
+								}
+							});
+						}
+					});
+					if (!devConnected) return tree();
+					return createComponent$1(DevStateKey.Provider, {
+						value: devState.read,
+						get children() {
+							return tree();
+						}
+					});
+				}
+			}), (err) => {
+				const error = isErrorInput(err) ? err : new Error(messageForNonError(err));
+				pendingExitError ??= error;
+				setCaughtError(err);
+				queueMicrotask(() => appContext.exit(error));
+			});
+			function renderFrame(width) {
+				if (!isScreenReaderEnabled) return paint(tuiRoot);
+				return wrapAnsi(renderScreenReaderOutput(tuiRoot, { skipStaticElements: true }), width, {
+					trim: false,
+					hard: true
+				});
+			}
+			function commit() {
+				const start = options.onRender ? performance.now() : 0;
+				const width = resolveSize(stdout).columns;
+				tuiRoot.yoga.setWidth(width);
+				const restoreLayoutGuards = calculateLayoutWithContentGuards(tuiRoot, width, void 0, Yoga.DIRECTION_LTR);
+				try {
+					emitLayoutListeners(tuiRoot);
+					let staticOutput = "";
+					for (const stat of findStatics(tuiRoot)) {
+						const staticFrame = paintStaticNode(stat, width, isScreenReaderEnabled);
+						if (staticFrame.length > 0) staticOutput += staticFrame + "\n";
+					}
+					if (staticOutput) frameState.fullStaticOutput += staticOutput;
+					const frame = renderFrame(width);
+					const outputHeight = frame === "" ? 0 : frame.split("\n").length;
+					frameState.lastOutput = frame;
+					frameState.outputHeight = outputHeight;
+					frameState.lastOutputToRender = interactive && !isScreenReaderEnabled ? frame + "\n" : frame;
+					if (options.onRender) options.onRender({ renderTime: performance.now() - start });
+					if (debug) {
+						if (frameState.fullStaticOutput) {
+							stdout.write(frameState.fullStaticOutput);
+							if (!teardownStarted) frameSink?.(frameState.fullStaticOutput);
+						}
+						stdout.write(frame);
+						if (!teardownStarted) frameSink?.(frame);
+						return;
+					}
+					if (!interactive) {
+						if (staticOutput) stdout.write(staticOutput);
+						return;
+					}
+					if (staticOutput) stdout.write(staticOutput);
+					if (cursorPosition) writer.setCursorPosition(cursorPosition);
+					const outputToRender = isScreenReaderEnabled ? frame : frame + "\n";
+					writer.write(outputToRender);
+				} finally {
+					restoreLayoutGuards();
+				}
+			}
+			const scheduler = createCommitScheduler(commit, {
+				immediate: unthrottled,
+				throttleMs: renderThrottleMs
+			});
+			mountedScheduler = scheduler;
+			mountedRestoreRendererCommit = setRendererCommit(scheduler.schedule);
+			if (options.alternateScreen && interactive && stdout.isTTY) {
+				stdout.write(ansiEscapes.enterAlternativeScreen);
+				stdout.write("\x1B[?25l");
+			}
+			if (options.patchConsole !== false && !debug) mountedRestoreConsole = patchConsoleFn((stream, data) => {
+				if (stream === "stdout") appContext.writeToStdout(data);
+				if (stream === "stderr") appContext.writeToStderr(data);
+			});
+			mountedClear = () => {
+				if (!interactive || debug) return;
+				writer.clear();
+			};
+			mountedDispose = renderSolidRoot(() => createComponent$1(Root, {}), tuiRoot);
+			scheduler.schedule();
+			if (devConnected) {
+				mountedDevTeardown = () => teardown();
+				registerDevApp(mountedDevTeardown);
+				exitPromise.finally(() => notifyDevExit()).catch(() => {});
+			}
+			if (interactive) {
+				const onResize = () => {
+					scheduler.cancel();
+					commit();
+				};
+				stdout.on("resize", onResize);
+				mountedResizeHandler = onResize;
+			}
+			mountedExitListener = () => teardown();
+			process.on("exit", mountedExitListener);
+			if (interactive) mountedUnsubscribeExit = onExit(() => teardown(), { alwaysLast: false });
+			return {};
+		},
+		unmount() {
+			if (!mountedAppContext) {
+				resolveExit();
+				return;
+			}
+			if (!mountedAppContext.interactive && !mountedAppContext.debug) {
+				const frame = mountedGetLastOutput?.() ?? "";
+				if (frame) mountedAppContext.stdout.write(frame + "\n");
+			}
+			teardown();
+			resolveExit();
+		},
+		waitUntilExit() {
+			return exitPromise;
+		},
+		waitUntilRenderFlush,
+		clear() {
+			mountedClear?.();
+		}
+	};
+	async function waitUntilRenderFlush() {
+		await mountedScheduler?.flush();
+		const stream = mountedAppContext?.stdout ?? process.stdout;
+		const { canWriteToStdout, hasWritableState } = getWritableStreamState(stream);
+		await new Promise((resolve) => {
+			if (!canWriteToStdout || !hasWritableState) {
+				setImmediate(resolve);
+				return;
+			}
+			try {
+				stream.write("", () => resolve());
+			} catch {
+				setImmediate(resolve);
+			}
+		});
+	}
+	return app;
+}
+function createFocusController() {
+	const focusables = [];
+	const subs = /* @__PURE__ */ new Map();
+	let activeFocusable = null;
+	let activeId = null;
+	const [activeIdValue, setActiveIdValue] = createSignal(null);
+	function notify(id, focused) {
+		subs.get(id)?.forEach((fn) => fn(focused));
+	}
+	function setActiveFocusable(next) {
+		if (next !== null && !focusables.includes(next)) next = null;
+		if (activeFocusable === next) return;
+		const prev = activeId;
+		activeFocusable = next;
+		activeId = next?.id ?? null;
+		ctx.activeId = activeId;
+		setActiveIdValue(activeId);
+		if (prev) notify(prev, false);
+		if (activeId) notify(activeId, true);
+	}
+	function findNextActive(startIdx, direction) {
+		const len = focusables.length;
+		for (let i = 0; i < len; i++) {
+			const idx = (startIdx + direction * (i + 1) + len * len) % len;
+			if (focusables[idx].isActive) return focusables[idx];
+		}
+		return null;
+	}
+	function startSearchIndex(direction) {
+		if (activeFocusable) {
+			const i = focusables.indexOf(activeFocusable);
+			if (i >= 0) return i;
+		}
+		if (activeId) {
+			const i = focusables.findIndex((f) => f.id === activeId);
+			if (i >= 0) return i;
+		}
+		return direction === 1 ? -1 : focusables.length;
+	}
+	const ctx = {
+		activeId: null,
+		activeIdValue,
+		enabled: true,
+		enableFocus() {
+			ctx.enabled = true;
+		},
+		disableFocus() {
+			ctx.enabled = false;
+		},
+		focusNext() {
+			if (focusables.length === 0) return;
+			setActiveFocusable(findNextActive(startSearchIndex(1), 1));
+		},
+		focusPrevious() {
+			if (focusables.length === 0) return;
+			setActiveFocusable(findNextActive(startSearchIndex(-1), -1));
+		},
+		focus(id) {
+			const entry = focusables.find((f) => f.id === id);
+			if (entry) setActiveFocusable(entry);
+		},
+		blur() {
+			setActiveFocusable(null);
+		},
+		add(id, options) {
+			const entry = {
+				id,
+				isActive: true
+			};
+			focusables.push(entry);
+			if (options.autoFocus && activeFocusable == null) setActiveFocusable(entry);
+		},
+		remove(id) {
+			const removingActive = activeFocusable?.id === id;
+			for (let i = focusables.length - 1; i >= 0; i--) if (focusables[i].id === id) focusables.splice(i, 1);
+			if (removingActive) setActiveFocusable(null);
+		},
+		activate(id) {
+			for (const entry of focusables) if (entry.id === id) entry.isActive = true;
+		},
+		deactivate(id) {
+			let changed = false;
+			for (const entry of focusables) if (entry.id === id) {
+				entry.isActive = false;
+				changed = true;
+			}
+			if (changed && activeFocusable?.id === id) setActiveFocusable(null);
+		},
+		subscribe(id, fn) {
+			let set = subs.get(id);
+			if (!set) {
+				set = /* @__PURE__ */ new Set();
+				subs.set(id, set);
+			}
+			set.add(fn);
+			return () => {
+				set.delete(fn);
+				if (set.size === 0 && subs.get(id) === set) subs.delete(id);
+			};
+		}
+	};
+	return Object.assign(ctx, { __subscriberMapSize: () => subs.size });
+}
+function createStdinController(stdin, opts) {
+	const { appCtx, focusContext } = opts;
+	const emitter = new EventEmitter();
+	emitter.setMaxListeners(Infinity);
+	const inputParser = createInputParser();
+	let refs = 0;
+	let bracketedPasteModeCount = 0;
+	let pendingFlushTimer;
+	const FLUSH_DELAY = 20;
+	function clearPendingFlush() {
+		if (pendingFlushTimer !== void 0) {
+			clearTimeout(pendingFlushTimer);
+			pendingFlushTimer = void 0;
+		}
+	}
+	function emitInput(input) {
+		if (opts.exitOnCtrlC) {
+			if (input === "") {
+				appCtx.exit();
+				return;
+			}
+			if (input.charCodeAt(0) === 27) {
+				const key = parseKeypress(input);
+				if (key.name === "c" && key.ctrl && !key.shift && key.eventType !== "release") {
+					appCtx.exit();
+					return;
+				}
+			}
+		}
+		if (input === "\x1B" && focusContext.enabled) focusContext.blur();
+		emitter.emit("input", input);
+	}
+	function schedulePendingFlush() {
+		clearPendingFlush();
+		pendingFlushTimer = setTimeout(() => {
+			pendingFlushTimer = void 0;
+			const pending = inputParser.flushPendingEscape();
+			if (pending) emitInput(pending);
+		}, FLUSH_DELAY);
+	}
+	function handleData(chunk) {
+		clearPendingFlush();
+		const data = typeof chunk === "string" ? chunk : chunk.toString();
+		const events = inputParser.push(data);
+		for (const event of events) if (typeof event === "string") emitInput(event);
+		else if (emitter.listenerCount("paste") > 0) emitter.emit("paste", event.paste);
+		else emitInput(event.paste);
+		if (inputParser.hasPendingEscape()) schedulePendingFlush();
+	}
+	const focusInputListener = (data) => {
+		if (!focusContext.enabled) return;
+		if (data === "	") focusContext.focusNext();
+		else if (data === "\x1B[Z") focusContext.focusPrevious();
+	};
+	emitter.on("input", focusInputListener);
+	const controller = {
+		stdin,
+		isRawModeSupported: appCtx.isRawModeSupported,
+		internal_eventEmitter: emitter,
+		internal_exitOnCtrlC: opts.exitOnCtrlC,
+		setRawMode(mode) {
+			if (!appCtx.isRawModeSupported) throw new Error("Raw mode is not supported on the configured stdin stream.");
+			if (mode) controller.acquireRawMode();
+			else controller.releaseRawMode();
+		},
+		acquireRawMode() {
+			if (!appCtx.isRawModeSupported) throw new Error("Raw mode is not supported on the configured stdin stream.");
+			if (refs === 0) {
+				appCtx.setRawMode(true);
+				if (typeof stdin.ref === "function") stdin.ref();
+				if (typeof stdin.setEncoding === "function") stdin.setEncoding("utf8");
+				stdin.on("data", handleData);
+			}
+			refs++;
+		},
+		releaseRawMode() {
+			if (!appCtx.isRawModeSupported || refs === 0) return;
+			refs--;
+			if (refs === 0) {
+				inputParser.reset();
+				clearPendingFlush();
+				stdin.off("data", handleData);
+				appCtx.setRawMode(false);
+				if (typeof stdin.unref === "function") stdin.unref();
+			}
+		},
+		holdRawModeForLifetime() {
+			controller.acquireRawMode();
+		},
+		setBracketedPasteMode(enabled) {
+			if (enabled) {
+				if (bracketedPasteModeCount === 0 && appCtx.stdout.isTTY) appCtx.stdout.write("\x1B[?2004h");
+				bracketedPasteModeCount++;
+			} else {
+				if (bracketedPasteModeCount === 0) return;
+				bracketedPasteModeCount--;
+				if (bracketedPasteModeCount === 0 && appCtx.stdout.isTTY) appCtx.stdout.write("\x1B[?2004l");
+			}
+		},
+		dispose() {
+			clearPendingFlush();
+			stdin.off("data", handleData);
+			emitter.off("input", focusInputListener);
+			if (bracketedPasteModeCount > 0 && appCtx.stdout.isTTY) appCtx.stdout.write("\x1B[?2004l");
+			bracketedPasteModeCount = 0;
+			if (refs > 0 && appCtx.isRawModeSupported) {
+				refs = 0;
+				appCtx.setRawMode(false);
+				if (typeof stdin.unref === "function") stdin.unref();
+			}
+		}
+	};
+	return controller;
+}
+//#endregion
+//#region src/render-to-string.ts
+function renderToString(component, options) {
+	return renderToStringInternal(component, options);
+}
+function renderToStringWithScreenReader(component, options) {
+	return renderToStringInternal(component, options);
+}
+function renderToStringInternal(component, options) {
+	const columns = options?.columns ?? 80;
+	const isScreenReaderEnabled = options?.isScreenReaderEnabled ?? false;
+	const appContext = createNoOpAppContext(isScreenReaderEnabled);
+	const root = createRoot(appContext);
+	attachYoga(root);
+	root.yoga.setWidth(columns);
+	let capturedStaticOutput = "";
+	let output = "";
+	let errored = false;
+	let caught;
+	const restoreCommit = setRendererCommit(() => {
+		const restoreLayoutGuards = calculateLayoutWithContentGuards(root, columns, void 0, Yoga.DIRECTION_LTR);
+		try {
+			for (const stat of findStatics(root)) {
+				const staticFrame = paintStaticNode(stat, columns, isScreenReaderEnabled);
+				if (staticFrame && staticFrame !== "\n") capturedStaticOutput += staticFrame + "\n";
+			}
+			output = isScreenReaderEnabled ? renderScreenReaderOutput(root, { skipStaticElements: true }) : paint(root);
+		} finally {
+			restoreLayoutGuards();
+		}
+	});
+	let dispose;
+	try {
+		const Root = () => catchError(() => createComponent$1(AppContextKey.Provider, {
+			value: appContext,
+			get children() {
+				return createComponent$1(FocusContextKey.Provider, {
+					value: createNoOpFocusContext(),
+					get children() {
+						return createComponent$1(StdinContextKey.Provider, {
+							value: createNoOpStdinContext(),
+							get children() {
+								return createComponent$1(AnimationSchedulerKey.Provider, {
+									value: createNoOpAnimationScheduler(),
+									get children() {
+										return createComponent$1(component, {});
+									}
+								});
+							}
+						});
+					}
+				});
+			}
+		}), (err) => {
+			errored = true;
+			caught = err;
+		});
+		dispose = renderSolidRoot(() => createComponent$1(Root, {}), root);
+		const restoreLayoutGuards = calculateLayoutWithContentGuards(root, columns, void 0, Yoga.DIRECTION_LTR);
+		try {
+			for (const stat of findStatics(root)) {
+				const staticFrame = paintStaticNode(stat, columns, isScreenReaderEnabled);
+				if (staticFrame && staticFrame !== "\n") capturedStaticOutput += staticFrame + "\n";
+			}
+			output = isScreenReaderEnabled ? renderScreenReaderOutput(root, { skipStaticElements: true }) : paint(root);
+		} finally {
+			restoreLayoutGuards();
+		}
+		dispose();
+		dispose = void 0;
+		root.yoga.freeRecursive();
+		if (errored) throw isErrorInput(caught) ? caught : new Error(messageForNonError(caught));
+		const normalizedStaticOutput = capturedStaticOutput.endsWith("\n") ? capturedStaticOutput.slice(0, -1) : capturedStaticOutput;
+		if (normalizedStaticOutput && output) return normalizedStaticOutput + "\n" + output;
+		return normalizedStaticOutput || output;
+	} finally {
+		restoreCommit();
+		try {
+			dispose?.();
+		} catch {}
+	}
+}
+function createNoOpAppContext(isScreenReaderEnabled = false) {
+	return {
+		exit: () => {},
+		waitUntilRenderFlush: async () => {},
+		stdout: process.stdout,
+		stderr: process.stderr,
+		stdin: process.stdin,
+		debug: false,
+		interactive: false,
+		isScreenReaderEnabled,
+		isRawModeSupported: false,
+		setRawMode: () => {},
+		writeToStdout: () => {},
+		writeToStderr: () => {},
+		cursorPosition: void 0,
+		setCursorPosition: () => {}
+	};
+}
+function createNoOpFocusContext() {
+	const [activeIdValue] = createSignal(null);
+	return {
+		activeId: null,
+		activeIdValue,
+		enabled: false,
+		enableFocus: () => {},
+		disableFocus: () => {},
+		focusNext: () => {},
+		focusPrevious: () => {},
+		focus: () => {},
+		blur: () => {},
+		add: () => {},
+		remove: () => {},
+		activate: () => {},
+		deactivate: () => {},
+		subscribe: () => () => {}
+	};
+}
+function createNoOpStdinContext() {
+	return {
+		stdin: process.stdin,
+		setRawMode: () => {},
+		isRawModeSupported: false,
+		internal_eventEmitter: new EventEmitter(),
+		internal_exitOnCtrlC: false,
+		acquireRawMode: () => {},
+		releaseRawMode: () => {},
+		setBracketedPasteMode: () => {}
+	};
+}
+//#endregion
+export { createMemo as $, createElement as A, attachYoga as B, hasCompleteKittyQueryResponse as C, resolveFlags as D, matchKittyQueryResponse as E, memo as F, createText as G, addLayoutListener as H, mergeProps as I, catchError as J, createTextLeaf as K, setProp as L, effect as M, insert as N, stripKittyQueryResponsesAndTrailingPartial as O, insertNode as P, createEffect as Q, spread as R, createKittyKeyboardController as S, kittyModifiers as T, createBox as U, yogaNodeTracker as V, createRoot as W, createComponent$1 as X, children as Y, createContext as Z, renderScreenReaderOutput as _, connectDevtools as a, splitProps as at, nonAlphanumericKeys as b, messageForNonError as c, AnimationSchedulerKey as d, createRenderEffect as et, AppContextKey as f, INTERNAL_FRAME_SINK as g, TextContextKey as h, createFocusController as i, onCleanup as it, createTextNode as j, createComponent as k, Text as l, StdinContextKey as m, renderToStringWithScreenReader as n, createSignal as nt, isDevConnected as o, untrack as ot, FocusContextKey as p, batch as q, createApp as r, on as rt, useWindowSize as s, useContext as st, renderToString as t, createRoot$1 as tt, Box as u, createAnimationScheduler as v, kittyFlags as w, parseKeypress as x, normalizeInterval as y, use as z };