@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.10

package/dist/index.js

@@ -0,0 +1,3209 @@
+import { C as bsu, S as ansiEscapes, V as esu, W as link, _ as CSI } from "./sgr-BhwaWAJB.js";
+import { h as tokenizeAnsi, p as graphemes } from "./tokenize-AjqbvtiT.js";
+import { t as stringWidth } from "./string-width-CijQwpIk.js";
+import { n as sliceAnsi, r as wrapAnsi } from "./truncate-D31fhU6i.js";
+import { _ as squashTextNodes, a as reconciler, c as kittyModifiers, d as FocusContext, f as Text, g as transformAnsiLine, h as emitLayoutListeners, i as useStdinContext, l as resolveFlags, m as createNode, n as useInput, o as detectKittySupport, p as addLayoutListener, r as useStdin, s as kittyFlags, t as useFocus, u as StdinContext, v as accessibilityContext } from "./use-focus-CcCIdCWA.js";
+import { a as isTty, i as isSigilDev, o as isWindows, r as isScreenReader, t as isInCi } from "./env-YVw64yZS.js";
+import { a as detectTerminal, i as detectHyperlinkSupport, n as detectCapabilities, o as detectUnicodeSupport, r as detectColorLevel, s as signalExit, t as createSupportsColor } from "./detect-B3dL4Q11.js";
+import { u as cliCursor } from "./osc-BFKKSqpg.js";
+import { a as registerTerminalIntegration, c as ensureTerminalQuery, f as queryTerminal, i as getCapabilities, l as getTerminalQuery, o as getRawModeStream, p as refreshTerminalQuery, r as capabilities, s as applyTerminalQuery, u as getTerminalQueryPromise } from "./color-policy-BAC9-TZX.js";
+import { a as buildCursorSuffix, c as hideCursorEscape, i as buildCursorOnlySequence, o as buildReturnToBottomPrefix, s as cursorPositionChanged, t as TerminalSession } from "./session-DDQ5V300.js";
+import { t as Yoga } from "./yoga-5jKhYCJC.js";
+import { r as createCell, t as cellAttributes } from "./cell-_ZVhbfl0.js";
+import { i as semanticTextStyleToCellStyle, n as mergeSemanticTextStyles, t as emptySemanticTextStyle } from "./semantic-text-style-DIMzC7xt.js";
+import { a as samplePaint } from "./sample-Cqw1bjUL.js";
+import { n as cellFromStyledChar, r as cellsFromAnsi, t as Screen } from "./screen-CiPytswf.js";
+import { t as colorProfileFromLevel } from "./color-profile-DHhQHY55.js";
+import { n as serializeScreen, t as serializeLine } from "./serialize-BTkAZgw1.js";
+import { t as stripAnsi } from "./strip-BvU4toXG.js";
+import "./color-CkbalRqK.js";
+import { PassThrough, Stream } from "node:stream";
+import { setImmediate as setImmediate$1 } from "node:timers/promises";
+import { isNativeError } from "node:util/types";
+import { PureComponent, createContext, useCallback, useContext, useEffect, useEffectEvent, useInsertionEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import "react-reconciler";
+import { ConcurrentRoot, LegacyRoot } from "react-reconciler/constants.js";
+import { EventEmitter } from "node:events";
+import { existsSync, readFileSync } from "node:fs";
+import { cwd } from "node:process";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Console } from "node:console";
+//#region src/components/AnimationContext.ts
+const animationContext = createContext({
+	renderThrottleMs: 0,
+	subscribe() {
+		return {
+			startTime: 0,
+			unsubscribe() {}
+		};
+	}
+});
+animationContext.displayName = "InternalAnimationContext";
+//#endregion
+//#region src/components/AppContext.ts
+/**
+`AppContext` is a React context that exposes lifecycle methods for the app.
+*/
+const noopSuspension = {
+	async resume() {},
+	async [Symbol.asyncDispose]() {}
+};
+const AppContext = createContext({
+	exit(_errorOrResult) {},
+	async waitUntilRenderFlush() {},
+	suspendTerminal: (async (callback) => {
+		if (callback) {
+			await callback();
+			return;
+		}
+		return noopSuspension;
+	})
+});
+AppContext.displayName = "InternalAppContext";
+//#endregion
+//#region src/components/CursorContext.ts
+const CursorContext = createContext({ setCursorPosition() {} });
+CursorContext.displayName = "InternalCursorContext";
+//#endregion
+//#region src/code-excerpt.ts
+const tabsToSpaces = (input, spaces = 2) => input.replaceAll(/^\t+/gm, (tabs) => " ".repeat(tabs.length * spaces));
+const generateLineNumbers = (line, around) => {
+	const lineNumbers = [];
+	for (let lineNumber = line - around; lineNumber <= line + around; lineNumber++) lineNumbers.push(lineNumber);
+	return lineNumbers;
+};
+const codeExcerpt = (source, line, options = {}) => {
+	if (!line || line < 1) throw new TypeError("Line number must start from `1`.");
+	const lines = tabsToSpaces(source).split(/\r?\n/);
+	if (line > lines.length) return;
+	return generateLineNumbers(line, options.around ?? 3).filter((lineNumber) => lines[lineNumber - 1] !== void 0).map((lineNumber) => ({
+		line: lineNumber,
+		value: lines[lineNumber - 1]
+	}));
+};
+//#endregion
+//#region src/glyphs.ts
+const BOXES = {
+	single: {
+		topLeft: "┌",
+		top: "─",
+		topRight: "┐",
+		right: "│",
+		bottomRight: "┘",
+		bottom: "─",
+		bottomLeft: "└",
+		left: "│"
+	},
+	double: {
+		topLeft: "╔",
+		top: "═",
+		topRight: "╗",
+		right: "║",
+		bottomRight: "╝",
+		bottom: "═",
+		bottomLeft: "╚",
+		left: "║"
+	},
+	round: {
+		topLeft: "╭",
+		top: "─",
+		topRight: "╮",
+		right: "│",
+		bottomRight: "╯",
+		bottom: "─",
+		bottomLeft: "╰",
+		left: "│"
+	},
+	bold: {
+		topLeft: "┏",
+		top: "━",
+		topRight: "┓",
+		right: "┃",
+		bottomRight: "┛",
+		bottom: "━",
+		bottomLeft: "┗",
+		left: "┃"
+	},
+	singleDouble: {
+		topLeft: "╓",
+		top: "─",
+		topRight: "╖",
+		right: "║",
+		bottomRight: "╜",
+		bottom: "─",
+		bottomLeft: "╙",
+		left: "║"
+	},
+	doubleSingle: {
+		topLeft: "╒",
+		top: "═",
+		topRight: "╕",
+		right: "│",
+		bottomRight: "╛",
+		bottom: "═",
+		bottomLeft: "╘",
+		left: "│"
+	},
+	classic: {
+		topLeft: "+",
+		top: "-",
+		topRight: "+",
+		right: "|",
+		bottomRight: "+",
+		bottom: "-",
+		bottomLeft: "+",
+		left: "|"
+	},
+	arrow: {
+		topLeft: "↘",
+		top: "↓",
+		topRight: "↙",
+		right: "←",
+		bottomRight: "↖",
+		bottom: "↑",
+		bottomLeft: "↗",
+		left: "→"
+	}
+};
+//#endregion
+//#region src/components/Box.tsx
+/** @jsxImportSource react */
+/**
+`<Box>` is an essential Ink component to build your layout. It's like `<div style="display: flex">` in the browser.
+*/
+function Box({ children, ref, backgroundColor, "aria-label": ariaLabel, "aria-hidden": ariaHidden, "aria-role": role, "aria-state": ariaState, ...style }) {
+	const { isScreenReaderEnabled } = useContext(accessibilityContext);
+	const label = ariaLabel ? /* @__PURE__ */ jsx("ink-text", { children: ariaLabel }) : void 0;
+	if (isScreenReaderEnabled && ariaHidden) return null;
+	return /* @__PURE__ */ jsx("ink-box", {
+		ref,
+		style: {
+			flexWrap: "nowrap",
+			flexDirection: "row",
+			flexGrow: 0,
+			flexShrink: 1,
+			...style,
+			backgroundColor,
+			overflowX: style.overflowX ?? style.overflow ?? "visible",
+			overflowY: style.overflowY ?? style.overflow ?? "visible"
+		},
+		internal_accessibility: {
+			role,
+			state: ariaState
+		},
+		children: isScreenReaderEnabled && label ? label : children
+	});
+}
+//#endregion
+//#region src/parse-stack-line.ts
+const lineRegExp = new RegExp("^" + String.raw`(?:\s*at )?` + "(?:(new) )?" + String.raw`(?:(.*?) \()?` + String.raw`(?:eval at ([^ ]+) \((.+?):(\d+):(\d+)\), )?` + String.raw`(?:(.+?):(\d+):(\d+)|(native))` + String.raw`(\)?)$`);
+const methodRegExp = /^(.*?) \[as (.*?)]$/;
+const cwd$1 = process.cwd().replaceAll("\\", "/");
+const setFile = (result, filename) => {
+	if (filename) {
+		filename = filename.replaceAll("\\", "/");
+		if (filename.startsWith(`${cwd$1}/`)) filename = filename.slice(cwd$1.length + 1);
+		result.file = filename;
+	}
+};
+const parseStackLine = (line) => {
+	const match = lineRegExp.exec(line);
+	if (!match) return;
+	let functionName = match[2];
+	const evalOrigin = match[3];
+	const evalFile = match[4];
+	const evalLine = Number(match[5]);
+	const evalColumn = Number(match[6]);
+	let file = match[7];
+	const lineNumber = match[8];
+	const columnNumber = match[9];
+	const native = match[10] === "native";
+	const closeParen = match[11] === ")";
+	let method;
+	const result = {};
+	if (lineNumber) result.line = Number(lineNumber);
+	if (columnNumber) result.column = Number(columnNumber);
+	if (closeParen && file) {
+		let closes = 0;
+		for (let index = file.length - 1; index > 0; index--) if (file.charAt(index) === ")") closes++;
+		else if (file.charAt(index) === "(" && file.charAt(index - 1) === " ") {
+			closes--;
+			if (closes === -1 && file.charAt(index - 1) === " ") {
+				const before = file.slice(0, index - 1);
+				file = file.slice(index + 1);
+				functionName += ` (${before}`;
+				break;
+			}
+		}
+	}
+	if (functionName) {
+		const methodMatch = methodRegExp.exec(functionName);
+		if (methodMatch) {
+			functionName = methodMatch[1];
+			method = methodMatch[2];
+		}
+	}
+	if (file) setFile(result, file);
+	if (evalOrigin) {
+		result.evalOrigin = evalOrigin;
+		result.evalLine = evalLine;
+		result.evalColumn = evalColumn;
+		result.evalFile = evalFile?.replaceAll("\\", "/");
+	}
+	if (native) result.native = true;
+	if (functionName) result.function = functionName;
+	if (method && functionName !== method) result.method = method;
+	return result;
+};
+//#endregion
+//#region src/components/ErrorOverview.tsx
+/** @jsxImportSource react */
+const cleanupPath = (path) => {
+	return path?.replace(`file://${cwd()}/`, "");
+};
+function ErrorOverview({ error }) {
+	const stack = error.stack ? error.stack.split("\n").slice(1) : void 0;
+	const origin = stack ? parseStackLine(stack[0]) : void 0;
+	const filePath = cleanupPath(origin?.file);
+	let excerpt;
+	let lineWidth = 0;
+	const stackLineCounts = /* @__PURE__ */ new Map();
+	if (filePath && origin?.line && existsSync(filePath)) {
+		const sourceCode = readFileSync(filePath, "utf8");
+		excerpt = codeExcerpt(sourceCode, origin.line);
+		if (excerpt) for (const { line } of excerpt) lineWidth = Math.max(lineWidth, String(line).length);
+	}
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		padding: 1,
+		children: [
+			/* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsxs(Text, {
+				backgroundColor: "red",
+				color: "white",
+				children: [
+					" ",
+					"ERROR",
+					" "
+				]
+			}), /* @__PURE__ */ jsxs(Text, { children: [" ", error.message] })] }),
+			origin && filePath ? /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				children: /* @__PURE__ */ jsxs(Text, {
+					dimColor: true,
+					children: [
+						filePath,
+						":",
+						origin.line,
+						":",
+						origin.column
+					]
+				})
+			}) : null,
+			origin && excerpt ? /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				flexDirection: "column",
+				children: excerpt.map(({ line, value }) => /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Box, {
+					width: lineWidth + 1,
+					children: /* @__PURE__ */ jsxs(Text, {
+						dimColor: line !== origin.line,
+						backgroundColor: line === origin.line ? "red" : void 0,
+						color: line === origin.line ? "white" : void 0,
+						"aria-label": line === origin.line ? `Line ${line}, error` : `Line ${line}`,
+						children: [String(line).padStart(lineWidth, " "), ":"]
+					})
+				}), /* @__PURE__ */ jsx(Text, {
+					backgroundColor: line === origin.line ? "red" : void 0,
+					color: line === origin.line ? "white" : void 0,
+					children: " " + value
+				}, line)] }, line))
+			}) : null,
+			error.stack ? /* @__PURE__ */ jsx(Box, {
+				marginTop: 1,
+				flexDirection: "column",
+				children: error.stack.split("\n").slice(1).map((line) => {
+					const parsedLine = parseStackLine(line);
+					const lineCount = stackLineCounts.get(line) ?? 0;
+					stackLineCounts.set(line, lineCount + 1);
+					const key = `${line}-${lineCount}`;
+					if (!parsedLine?.file || !parsedLine.line || !parsedLine.column) return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(Text, {
+						dimColor: true,
+						children: "- "
+					}), /* @__PURE__ */ jsxs(Text, {
+						dimColor: true,
+						bold: true,
+						children: [
+							line,
+							"\\t",
+							" "
+						]
+					})] }, key);
+					return /* @__PURE__ */ jsxs(Box, { children: [
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							children: "- "
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							dimColor: true,
+							bold: true,
+							children: parsedLine.function
+						}),
+						/* @__PURE__ */ jsxs(Text, {
+							dimColor: true,
+							color: "gray",
+							"aria-label": `at ${cleanupPath(parsedLine.file) ?? ""} line ${parsedLine.line} column ${parsedLine.column}`,
+							children: [
+								" ",
+								"(",
+								cleanupPath(parsedLine.file) ?? "",
+								":",
+								parsedLine.line,
+								":",
+								parsedLine.column,
+								")"
+							]
+						})
+					] }, key);
+				})
+			}) : null
+		]
+	});
+}
+//#endregion
+//#region src/components/ErrorBoundary.tsx
+/** @jsxImportSource react */
+var ErrorBoundary = class extends PureComponent {
+	static displayName = "InternalErrorBoundary";
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	state = { error: void 0 };
+	componentDidCatch(error) {
+		this.props.onError(error);
+	}
+	render() {
+		if (this.state.error) return /* @__PURE__ */ jsx(ErrorOverview, { error: this.state.error });
+		return this.props.children;
+	}
+};
+//#endregion
+//#region src/components/StderrContext.ts
+/**
+`StderrContext` is a React context that exposes the stderr stream.
+*/
+const StderrContext = createContext({
+	stderr: process.stderr,
+	write() {}
+});
+StderrContext.displayName = "InternalStderrContext";
+//#endregion
+//#region src/components/StdoutContext.ts
+/**
+`StdoutContext` is a React context that exposes the stdout stream where Ink renders your app.
+*/
+const StdoutContext = createContext({
+	stdout: process.stdout,
+	write() {}
+});
+StdoutContext.displayName = "InternalStdoutContext";
+//#endregion
+//#region src/components/App.tsx
+/** @jsxImportSource react */
+const tab = "	";
+const shiftTab = `${CSI}Z`;
+const escape = "\x1B";
+function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, exitOnCtrlC, onExit, onWaitUntilRenderFlush, onSuspendTerminal, onRegisterInputControl, setCursorPosition, interactive, renderThrottleMs, terminalInput }) {
+	const [isFocusEnabled, setIsFocusEnabled] = useState(true);
+	const [activeFocusId, setActiveFocusId] = useState(void 0);
+	const [, setFocusables] = useState([]);
+	const focusablesCountRef = useRef(0);
+	const animationSubscribersRef = useRef(/* @__PURE__ */ new Map());
+	const animationTimerRef = useRef(void 0);
+	const rawModeEnabledCount = useRef(0);
+	const pendingDisableRawModeRef = useRef(false);
+	const bracketedPasteModeEnabledCount = useRef(0);
+	const internal_eventEmitter = useRef(new EventEmitter());
+	internal_eventEmitter.current.setMaxListeners(Infinity);
+	const readableListenerRef = useRef(void 0);
+	const isMountedRef = useRef(true);
+	const pendingInputFlushRef = useRef(void 0);
+	const pendingInputFlushDelayMilliseconds = 20;
+	const clearPendingInputFlush = useCallback(() => {
+		if (!pendingInputFlushRef.current) return;
+		clearTimeout(pendingInputFlushRef.current);
+		pendingInputFlushRef.current = void 0;
+	}, []);
+	const clearAnimationTimer = useCallback(() => {
+		if (!animationTimerRef.current) return;
+		clearTimeout(animationTimerRef.current);
+		animationTimerRef.current = void 0;
+	}, []);
+	const scheduleAnimationTick = useCallback(() => {
+		clearAnimationTimer();
+		if (animationSubscribersRef.current.size === 0) return;
+		let nextDueTime = Number.POSITIVE_INFINITY;
+		for (const subscriber of animationSubscribersRef.current.values()) nextDueTime = Math.min(nextDueTime, subscriber.nextDueTime);
+		const delay = Math.max(0, nextDueTime - performance.now());
+		animationTimerRef.current = setTimeout(() => {
+			animationTimerRef.current = void 0;
+			const currentTime = performance.now();
+			for (const subscriber of animationSubscribersRef.current.values()) {
+				if (currentTime < subscriber.nextDueTime) continue;
+				subscriber.callback(currentTime);
+				const elapsedTime = currentTime - subscriber.startTime;
+				const elapsedFrames = Math.floor(elapsedTime / subscriber.interval) + 1;
+				subscriber.nextDueTime = subscriber.startTime + elapsedFrames * subscriber.interval;
+			}
+			scheduleAnimationTick();
+		}, delay);
+	}, [clearAnimationTimer]);
+	const animationSubscribe = useCallback((callback, interval) => {
+		const startTime = performance.now();
+		animationSubscribersRef.current.set(callback, {
+			callback,
+			interval,
+			startTime,
+			nextDueTime: startTime + interval
+		});
+		scheduleAnimationTick();
+		return {
+			startTime,
+			unsubscribe() {
+				animationSubscribersRef.current.delete(callback);
+				if (animationSubscribersRef.current.size === 0) {
+					clearAnimationTimer();
+					return;
+				}
+				scheduleAnimationTick();
+			}
+		};
+	}, [clearAnimationTimer, scheduleAnimationTick]);
+	useEffect(() => {
+		return () => {
+			clearAnimationTimer();
+		};
+	}, [clearAnimationTimer]);
+	const rawModeStdin = getRawModeStream(stdin);
+	const isRawModeSupported = rawModeStdin !== void 0;
+	const detachReadableListener = useCallback(() => {
+		if (!readableListenerRef.current) return;
+		stdin.removeListener("readable", readableListenerRef.current);
+		readableListenerRef.current = void 0;
+	}, [stdin]);
+	const clearInputState = useCallback(() => {
+		terminalInput.reset();
+		clearPendingInputFlush();
+		detachReadableListener();
+	}, [
+		clearPendingInputFlush,
+		detachReadableListener,
+		terminalInput
+	]);
+	const disableRawMode = useCallback(() => {
+		if (!rawModeStdin) return;
+		pendingDisableRawModeRef.current = false;
+		rawModeStdin.setRawMode(false);
+		rawModeStdin.unref?.();
+		rawModeEnabledCount.current = 0;
+		clearInputState();
+	}, [rawModeStdin, clearInputState]);
+	const handleExit = useCallback((errorOrResult) => {
+		if (isRawModeSupported && (rawModeEnabledCount.current > 0 || pendingDisableRawModeRef.current)) disableRawMode();
+		onExit(errorOrResult);
+	}, [
+		isRawModeSupported,
+		disableRawMode,
+		onExit
+	]);
+	const handleInput = useCallback((input) => {
+		if (input === "" && exitOnCtrlC) {
+			handleExit();
+			return;
+		}
+		if (input === escape && isFocusEnabled) setActiveFocusId(void 0);
+	}, [
+		exitOnCtrlC,
+		handleExit,
+		isFocusEnabled
+	]);
+	const emitInput = useCallback((input) => {
+		handleInput(input);
+		internal_eventEmitter.current.emit("input", input);
+	}, [handleInput]);
+	const schedulePendingInputFlush = useCallback(() => {
+		clearPendingInputFlush();
+		pendingInputFlushRef.current = setTimeout(() => {
+			pendingInputFlushRef.current = void 0;
+			const pendingEscape = terminalInput.flushPendingEscape();
+			if (!pendingEscape) return;
+			emitInput(pendingEscape);
+		}, pendingInputFlushDelayMilliseconds);
+	}, [
+		clearPendingInputFlush,
+		emitInput,
+		terminalInput
+	]);
+	const handleReadable = useCallback(() => {
+		clearPendingInputFlush();
+		let chunk;
+		while ((chunk = stdin.read()) !== null) {
+			const inputEvents = terminalInput.push(chunk);
+			for (const event of inputEvents) if (typeof event === "string") emitInput(event);
+			else {
+				if (internal_eventEmitter.current.listenerCount("paste") === 0) {
+					emitInput(event.paste);
+					continue;
+				}
+				internal_eventEmitter.current.emit("paste", event.paste);
+			}
+		}
+		if (terminalInput.hasPendingEscape()) schedulePendingInputFlush();
+	}, [
+		stdin,
+		emitInput,
+		clearPendingInputFlush,
+		schedulePendingInputFlush,
+		terminalInput
+	]);
+	const attachReadableListener = useCallback(() => {
+		if (readableListenerRef.current) return;
+		readableListenerRef.current = handleReadable;
+		stdin.addListener("readable", handleReadable);
+	}, [stdin, handleReadable]);
+	const handleSetRawMode = useCallback((isEnabled) => {
+		if (!rawModeStdin) {
+			if (stdin === process.stdin) throw new Error("Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported");
+			else throw new Error("Raw mode is not supported on the stdin provided to Ink.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported");
+		}
+		rawModeStdin.setEncoding("utf8");
+		if (isEnabled) {
+			if (rawModeEnabledCount.current === 0) {
+				const isRawModeAlreadyEnabled = pendingDisableRawModeRef.current;
+				pendingDisableRawModeRef.current = false;
+				if (!isRawModeAlreadyEnabled) {
+					rawModeStdin.ref?.();
+					rawModeStdin.setRawMode(true);
+				}
+				attachReadableListener();
+			}
+			rawModeEnabledCount.current++;
+			return;
+		}
+		if (rawModeEnabledCount.current === 0) return;
+		if (--rawModeEnabledCount.current === 0) {
+			clearInputState();
+			pendingDisableRawModeRef.current = true;
+			queueMicrotask(() => {
+				if (!pendingDisableRawModeRef.current) return;
+				disableRawMode();
+			});
+		}
+	}, [
+		rawModeStdin,
+		stdin,
+		attachReadableListener,
+		clearInputState,
+		disableRawMode
+	]);
+	const handleQueryTerminal = useCallback(async ({ refresh = false } = {}) => {
+		if (!interactive || !isRawModeSupported || !stdout.isTTY) return;
+		if (!refresh) {
+			const existing = getTerminalQueryPromise(stdout);
+			if (existing) return existing;
+		}
+		handleSetRawMode(true);
+		detachReadableListener();
+		try {
+			return await (refresh ? refreshTerminalQuery(stdin, stdout) : ensureTerminalQuery(stdin, stdout));
+		} finally {
+			if (isMountedRef.current) attachReadableListener();
+			handleSetRawMode(false);
+		}
+	}, [
+		interactive,
+		isRawModeSupported,
+		stdin,
+		stdout,
+		handleSetRawMode,
+		detachReadableListener,
+		attachReadableListener
+	]);
+	const reportFeedActiveRef = useRef(false);
+	const handleSetReportFeed = useCallback((active) => {
+		if (active === reportFeedActiveRef.current || !isRawModeSupported) return;
+		reportFeedActiveRef.current = active;
+		handleSetRawMode(active);
+	}, [isRawModeSupported, handleSetRawMode]);
+	useInsertionEffect(() => {
+		const unregister = registerTerminalIntegration(stdout, {
+			runQuery: handleQueryTerminal,
+			setReportFeed: handleSetReportFeed
+		});
+		return () => {
+			unregister();
+			handleSetReportFeed(false);
+		};
+	}, [
+		stdout,
+		handleQueryTerminal,
+		handleSetReportFeed
+	]);
+	const handleSetBracketedPasteMode = useCallback((isEnabled) => {
+		if (!stdout.isTTY) return;
+		if (isEnabled) {
+			if (bracketedPasteModeEnabledCount.current === 0) stdout.write(ansiEscapes.enableBracketedPaste);
+			bracketedPasteModeEnabledCount.current++;
+			return;
+		}
+		if (bracketedPasteModeEnabledCount.current === 0) return;
+		if (--bracketedPasteModeEnabledCount.current === 0) stdout.write(ansiEscapes.disableBracketedPaste);
+	}, [stdout]);
+	const suspendedInputStateRef = useRef({
+		rawMode: false,
+		bracketedPaste: false
+	});
+	const pauseInput = useCallback(() => {
+		const wasRawMode = isRawModeSupported && rawModeEnabledCount.current > 0;
+		const wasBracketedPaste = bracketedPasteModeEnabledCount.current > 0;
+		suspendedInputStateRef.current = {
+			rawMode: wasRawMode,
+			bracketedPaste: wasBracketedPaste
+		};
+		if (wasBracketedPaste && stdout.isTTY) try {
+			stdout.write(ansiEscapes.disableBracketedPaste);
+		} catch {}
+		if (wasRawMode) {
+			rawModeStdin?.setRawMode(false);
+			rawModeStdin?.unref?.();
+			clearInputState();
+		}
+	}, [
+		isRawModeSupported,
+		rawModeStdin,
+		stdout,
+		clearInputState
+	]);
+	const resumeInput = useCallback(() => {
+		const { rawMode, bracketedPaste } = suspendedInputStateRef.current;
+		if (rawMode) {
+			rawModeStdin?.setEncoding("utf8");
+			rawModeStdin?.ref?.();
+			rawModeStdin?.setRawMode(true);
+			attachReadableListener();
+		}
+		if (bracketedPaste && stdout.isTTY) try {
+			stdout.write(ansiEscapes.enableBracketedPaste);
+		} catch {}
+	}, [
+		rawModeStdin,
+		stdout,
+		attachReadableListener
+	]);
+	useInsertionEffect(() => {
+		onRegisterInputControl(pauseInput, resumeInput);
+	}, [
+		onRegisterInputControl,
+		pauseInput,
+		resumeInput
+	]);
+	const findNextFocusable = useCallback((currentFocusables, currentActiveFocusId) => {
+		const activeIndex = currentFocusables.findIndex((focusable) => {
+			return focusable.id === currentActiveFocusId;
+		});
+		for (let index = activeIndex + 1; index < currentFocusables.length; index++) {
+			const focusable = currentFocusables[index];
+			if (focusable?.isActive) return focusable.id;
+		}
+	}, []);
+	const findPreviousFocusable = useCallback((currentFocusables, currentActiveFocusId) => {
+		const activeIndex = currentFocusables.findIndex((focusable) => {
+			return focusable.id === currentActiveFocusId;
+		});
+		for (let index = activeIndex - 1; index >= 0; index--) {
+			const focusable = currentFocusables[index];
+			if (focusable?.isActive) return focusable.id;
+		}
+	}, []);
+	const focusNext = useCallback(() => {
+		setFocusables((currentFocusables) => {
+			setActiveFocusId((currentActiveFocusId) => {
+				const firstFocusableId = currentFocusables.find((focusable) => focusable.isActive)?.id;
+				return findNextFocusable(currentFocusables, currentActiveFocusId) ?? firstFocusableId;
+			});
+			return currentFocusables;
+		});
+	}, [findNextFocusable]);
+	const focusPrevious = useCallback(() => {
+		setFocusables((currentFocusables) => {
+			setActiveFocusId((currentActiveFocusId) => {
+				const lastFocusableId = currentFocusables.findLast((focusable) => focusable.isActive)?.id;
+				return findPreviousFocusable(currentFocusables, currentActiveFocusId) ?? lastFocusableId;
+			});
+			return currentFocusables;
+		});
+	}, [findPreviousFocusable]);
+	useEffect(() => {
+		const handleTabNavigation = (input) => {
+			if (!isFocusEnabled || focusablesCountRef.current === 0) return;
+			if (input === tab) focusNext();
+			if (input === shiftTab) focusPrevious();
+		};
+		internal_eventEmitter.current.on("input", handleTabNavigation);
+		const emitter = internal_eventEmitter.current;
+		return () => {
+			emitter.off("input", handleTabNavigation);
+		};
+	}, [
+		isFocusEnabled,
+		focusNext,
+		focusPrevious
+	]);
+	const enableFocus = useCallback(() => {
+		setIsFocusEnabled(true);
+	}, []);
+	const disableFocus = useCallback(() => {
+		setIsFocusEnabled(false);
+	}, []);
+	const focus = useCallback((id) => {
+		setFocusables((currentFocusables) => {
+			if (currentFocusables.some((focusable) => focusable?.id === id)) setActiveFocusId(id);
+			return currentFocusables;
+		});
+	}, []);
+	const addFocusable = useCallback((id, { autoFocus }) => {
+		setFocusables((currentFocusables) => {
+			focusablesCountRef.current = currentFocusables.length + 1;
+			return [...currentFocusables, {
+				id,
+				isActive: true
+			}];
+		});
+		if (autoFocus) setActiveFocusId((currentActiveFocusId) => {
+			if (!currentActiveFocusId) return id;
+			return currentActiveFocusId;
+		});
+	}, []);
+	const removeFocusable = useCallback((id) => {
+		setActiveFocusId((currentActiveFocusId) => {
+			if (currentActiveFocusId === id) return;
+			return currentActiveFocusId;
+		});
+		setFocusables((currentFocusables) => {
+			const filtered = currentFocusables.filter((focusable) => {
+				return focusable.id !== id;
+			});
+			focusablesCountRef.current = filtered.length;
+			return filtered;
+		});
+	}, []);
+	const activateFocusable = useCallback((id) => {
+		setFocusables((currentFocusables) => currentFocusables.map((focusable) => {
+			if (focusable.id !== id) return focusable;
+			return {
+				id,
+				isActive: true
+			};
+		}));
+	}, []);
+	const deactivateFocusable = useCallback((id) => {
+		setActiveFocusId((currentActiveFocusId) => {
+			if (currentActiveFocusId === id) return;
+			return currentActiveFocusId;
+		});
+		setFocusables((currentFocusables) => currentFocusables.map((focusable) => {
+			if (focusable.id !== id) return focusable;
+			return {
+				id,
+				isActive: false
+			};
+		}));
+	}, []);
+	useEffect(() => {
+		isMountedRef.current = true;
+		return () => {
+			isMountedRef.current = false;
+			const canWriteToStdout = !stdout.destroyed && !stdout.writableEnded;
+			if (interactive && canWriteToStdout) cliCursor.show(stdout);
+			if (isRawModeSupported && (rawModeEnabledCount.current > 0 || pendingDisableRawModeRef.current)) disableRawMode();
+			if (bracketedPasteModeEnabledCount.current > 0) {
+				if (stdout.isTTY && canWriteToStdout) stdout.write(ansiEscapes.disableBracketedPaste);
+				bracketedPasteModeEnabledCount.current = 0;
+			}
+		};
+	}, [
+		stdout,
+		isRawModeSupported,
+		disableRawMode,
+		interactive
+	]);
+	const appContextValue = useMemo(() => ({
+		exit: handleExit,
+		waitUntilRenderFlush: onWaitUntilRenderFlush,
+		suspendTerminal: onSuspendTerminal
+	}), [
+		handleExit,
+		onWaitUntilRenderFlush,
+		onSuspendTerminal
+	]);
+	const stdinContextValue = useMemo(() => ({
+		stdin,
+		setRawMode: handleSetRawMode,
+		setBracketedPasteMode: handleSetBracketedPasteMode,
+		isRawModeSupported,
+		internal_exitOnCtrlC: exitOnCtrlC,
+		internal_eventEmitter: internal_eventEmitter.current
+	}), [
+		stdin,
+		handleSetRawMode,
+		handleSetBracketedPasteMode,
+		isRawModeSupported,
+		exitOnCtrlC
+	]);
+	const stdoutContextValue = useMemo(() => ({
+		stdout,
+		write: writeToStdout
+	}), [stdout, writeToStdout]);
+	const stderrContextValue = useMemo(() => ({
+		stderr,
+		write: writeToStderr
+	}), [stderr, writeToStderr]);
+	const cursorContextValue = useMemo(() => ({ setCursorPosition }), [setCursorPosition]);
+	const focusContextValue = useMemo(() => ({
+		activeId: activeFocusId,
+		add: addFocusable,
+		remove: removeFocusable,
+		activate: activateFocusable,
+		deactivate: deactivateFocusable,
+		enableFocus,
+		disableFocus,
+		focusNext,
+		focusPrevious,
+		focus
+	}), [
+		activeFocusId,
+		addFocusable,
+		removeFocusable,
+		activateFocusable,
+		deactivateFocusable,
+		enableFocus,
+		disableFocus,
+		focusNext,
+		focusPrevious,
+		focus
+	]);
+	const animationContextValue = useMemo(() => ({
+		renderThrottleMs,
+		subscribe: animationSubscribe
+	}), [animationSubscribe, renderThrottleMs]);
+	return /* @__PURE__ */ jsx(AppContext.Provider, {
+		value: appContextValue,
+		children: /* @__PURE__ */ jsx(StdinContext.Provider, {
+			value: stdinContextValue,
+			children: /* @__PURE__ */ jsx(StdoutContext.Provider, {
+				value: stdoutContextValue,
+				children: /* @__PURE__ */ jsx(StderrContext.Provider, {
+					value: stderrContextValue,
+					children: /* @__PURE__ */ jsx(FocusContext.Provider, {
+						value: focusContextValue,
+						children: /* @__PURE__ */ jsx(animationContext.Provider, {
+							value: animationContextValue,
+							children: /* @__PURE__ */ jsx(CursorContext.Provider, {
+								value: cursorContextValue,
+								children: /* @__PURE__ */ jsx(ErrorBoundary, {
+									onError: handleExit,
+									children
+								})
+							})
+						})
+					})
+				})
+			})
+		})
+	});
+}
+App.displayName = "InternalApp";
+//#endregion
+//#region src/components/TerminalOscContext.ts
+const noop$1 = () => {};
+const TerminalOscContext = createContext({
+	publishProgress: noop$1,
+	copyToClipboard: noop$1,
+	publishTitle: noop$1,
+	setWorkingDirectory: noop$1,
+	notify: noop$1,
+	setPointerShape: noop$1
+});
+TerminalOscContext.displayName = "InternalTerminalOscContext";
+//#endregion
+//#region src/instances.ts
+const instances = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region src/patch-console.ts
+const consoleMethods = [
+	"assert",
+	"count",
+	"countReset",
+	"debug",
+	"dir",
+	"dirxml",
+	"error",
+	"group",
+	"groupCollapsed",
+	"groupEnd",
+	"info",
+	"log",
+	"table",
+	"time",
+	"timeEnd",
+	"timeLog",
+	"trace",
+	"warn"
+];
+const patchConsole = (callback) => {
+	const stdout = new PassThrough();
+	const stderr = new PassThrough();
+	stdout.write = (data) => {
+		callback("stdout", String(data));
+		return true;
+	};
+	stderr.write = (data) => {
+		callback("stderr", String(data));
+		return true;
+	};
+	const internalConsole = new Console(stdout, stderr);
+	const originalMethods = /* @__PURE__ */ new Map();
+	for (const method of consoleMethods) {
+		originalMethods.set(method, console[method]);
+		console[method] = internalConsole[method];
+	}
+	return () => {
+		for (const method of consoleMethods) console[method] = originalMethods.get(method);
+		originalMethods.clear();
+	};
+};
+const patchStreamWrite = (stream, onData) => {
+	const originalWrite = stream.write;
+	const patchedWrite = (chunk, encodingOrCallback, callback) => {
+		onData(typeof chunk === "string" ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk).toString() : String(chunk));
+		(typeof encodingOrCallback === "function" ? encodingOrCallback : typeof callback === "function" ? callback : void 0)?.();
+		return true;
+	};
+	stream.write = patchedWrite;
+	return () => {
+		stream.write = originalWrite;
+	};
+};
+//#endregion
+//#region src/get-max-width.ts
+const getMaxWidth = (yogaNode) => {
+	return yogaNode.getComputedWidth() - yogaNode.getComputedPadding(Yoga.EDGE_LEFT) - yogaNode.getComputedPadding(Yoga.EDGE_RIGHT) - yogaNode.getComputedBorder(Yoga.EDGE_LEFT) - yogaNode.getComputedBorder(Yoga.EDGE_RIGHT);
+};
+//#endregion
+//#region src/render-background.ts
+const renderBackground = (x, y, node, output) => {
+	if (node.style.backgroundColor === void 0) return;
+	const width = node.yogaNode.getComputedWidth();
+	const height = node.yogaNode.getComputedHeight();
+	const leftBorderWidth = node.style.borderStyle && node.style.borderLeft !== false ? 1 : 0;
+	const rightBorderWidth = node.style.borderStyle && node.style.borderRight !== false ? 1 : 0;
+	const topBorderHeight = node.style.borderStyle && node.style.borderTop !== false ? 1 : 0;
+	const bottomBorderHeight = node.style.borderStyle && node.style.borderBottom !== false ? 1 : 0;
+	const contentWidth = width - leftBorderWidth - rightBorderWidth;
+	const contentHeight = height - topBorderHeight - bottomBorderHeight;
+	if (!(contentWidth > 0 && contentHeight > 0)) return;
+	const bounds = {
+		x: x + leftBorderWidth,
+		y: y + topBorderHeight,
+		width: contentWidth,
+		height: contentHeight
+	};
+	const lines = Array.from({ length: contentHeight }, (_unused, row) => Array.from({ length: contentWidth }, (_empty, column) => {
+		const resetBackground = node.style.backgroundColor === "";
+		const background = resetBackground ? void 0 : samplePaint(node.style.backgroundColor, bounds.x + column, bounds.y + row, bounds, output.paintContext);
+		return createCell(" ", 1, {
+			...background ? { background } : {},
+			underline: "none",
+			attributes: cellAttributes.none
+		}, void 0, resetBackground ? { background: true } : void 0);
+	}));
+	output.writeCells(bounds.x, bounds.y, lines);
+};
+//#endregion
+//#region src/render-border.ts
+const stylePiece = (segment, x, y, bounds, context, fg, bg, dim) => {
+	let column = x;
+	return [...graphemes(segment)].map((grapheme) => {
+		const foreground = fg ? samplePaint(fg, column, y, bounds, context) : void 0;
+		const background = bg ? samplePaint(bg, column, y, bounds, context) : void 0;
+		const width = Math.max(1, stringWidth(grapheme));
+		column += width;
+		return createCell(grapheme, width, {
+			...foreground ? { foreground } : {},
+			...background ? { background } : {},
+			underline: "none",
+			attributes: dim ? cellAttributes.faint : cellAttributes.none
+		});
+	});
+};
+const renderBorder = (x, y, node, output) => {
+	if (node.style.borderStyle) {
+		const width = node.yogaNode.getComputedWidth();
+		const height = node.yogaNode.getComputedHeight();
+		const bounds = {
+			x,
+			y,
+			width,
+			height
+		};
+		const box = typeof node.style.borderStyle === "string" ? BOXES[node.style.borderStyle] : node.style.borderStyle;
+		const topBorderColor = node.style.borderTopColor ?? node.style.borderColor;
+		const bottomBorderColor = node.style.borderBottomColor ?? node.style.borderColor;
+		const leftBorderColor = node.style.borderLeftColor ?? node.style.borderColor;
+		const rightBorderColor = node.style.borderRightColor ?? node.style.borderColor;
+		const topBorderBackgroundColor = node.style.borderTopBackgroundColor ?? node.style.borderBackgroundColor;
+		const bottomBorderBackgroundColor = node.style.borderBottomBackgroundColor ?? node.style.borderBackgroundColor;
+		const leftBorderBackgroundColor = node.style.borderLeftBackgroundColor ?? node.style.borderBackgroundColor;
+		const rightBorderBackgroundColor = node.style.borderRightBackgroundColor ?? node.style.borderBackgroundColor;
+		const dimTopBorderColor = node.style.borderTopDimColor ?? node.style.borderDimColor;
+		const dimBottomBorderColor = node.style.borderBottomDimColor ?? node.style.borderDimColor;
+		const dimLeftBorderColor = node.style.borderLeftDimColor ?? node.style.borderDimColor;
+		const dimRightBorderColor = node.style.borderRightDimColor ?? node.style.borderDimColor;
+		const showTopBorder = node.style.borderTop !== false;
+		const showBottomBorder = node.style.borderBottom !== false;
+		const showLeftBorder = node.style.borderLeft !== false;
+		const showRightBorder = node.style.borderRight !== false;
+		const contentWidth = width - (showLeftBorder ? 1 : 0) - (showRightBorder ? 1 : 0);
+		const topBorder = showTopBorder ? (showLeftBorder ? box.topLeft : "") + box.top.repeat(contentWidth) + (showRightBorder ? box.topRight : "") : void 0;
+		let verticalBorderHeight = height;
+		if (showTopBorder) verticalBorderHeight -= 1;
+		if (showBottomBorder) verticalBorderHeight -= 1;
+		const offsetY = showTopBorder ? 1 : 0;
+		const bottomBorder = showBottomBorder ? (showLeftBorder ? box.bottomLeft : "") + box.bottom.repeat(contentWidth) + (showRightBorder ? box.bottomRight : "") : void 0;
+		if (topBorder) output.writeCells(x, y, [stylePiece(topBorder, x, y, bounds, output.paintContext, topBorderColor, topBorderBackgroundColor, dimTopBorderColor)]);
+		if (showLeftBorder) output.writeCells(x, y + offsetY, Array.from({ length: verticalBorderHeight }, (_, row) => stylePiece(box.left, x, y + offsetY + row, bounds, output.paintContext, leftBorderColor, leftBorderBackgroundColor, dimLeftBorderColor)));
+		if (showRightBorder) output.writeCells(x + width - 1, y + offsetY, Array.from({ length: verticalBorderHeight }, (_, row) => stylePiece(box.right, x + width - 1, y + offsetY + row, bounds, output.paintContext, rightBorderColor, rightBorderBackgroundColor, dimRightBorderColor)));
+		if (bottomBorder) output.writeCells(x, y + height - 1, [stylePiece(bottomBorder, x, y + height - 1, bounds, output.paintContext, bottomBorderColor, bottomBorderBackgroundColor, dimBottomBorderColor)]);
+	}
+};
+//#endregion
+//#region src/structured-text.ts
+/** Whether a text subtree must retain the ANSI compatibility pipeline. */
+function hasCompatibilityText(node) {
+	if (node.internal_transform && !node.internal_textStyle) return true;
+	return node.childNodes.some((child) => child.nodeName !== "#text" && hasCompatibilityText(child));
+}
+/** Rasterizes an unwrapped native Text subtree into semantic cell lines. */
+function structuredTextLines(node) {
+	const lines = [[]];
+	appendNode(node, emptySemanticTextStyle, lines, false);
+	return lines;
+}
+/** Samples semantic paints only after wrapping and final layout are known. */
+function sampleStructuredText(lines, bounds, context) {
+	return lines.map((line, row) => {
+		let column = 0;
+		return line.map((cell) => {
+			const foreground = cell.foregroundPaint ? samplePaint(cell.foregroundPaint, bounds.x + column, bounds.y + row, bounds, context) : cell.style.foreground;
+			const background = cell.backgroundPaint ? samplePaint(cell.backgroundPaint, bounds.x + column, bounds.y + row, bounds, context) : cell.style.background;
+			column += cell.width;
+			return createCell(cell.grapheme, cell.width, {
+				...cell.style,
+				...foreground ? { foreground } : {},
+				...background ? { background } : {}
+			}, cell.hyperlink, cell.reset);
+		});
+	});
+}
+function structuredTextBaseStyle(node) {
+	return semanticTextStyleToCellStyle(mergeSemanticTextStyles(emptySemanticTextStyle, node.internal_textStyle));
+}
+/** Wraps or truncates semantic cells without converting them through ANSI. */
+function wrapStructuredText(input, maxWidth, wrap, baseStyle) {
+	if (wrap === "none") return input.map((line) => [...line]);
+	if (maxWidth < 1) return [[]];
+	return input.flatMap((line) => {
+		if (lineWidth(line) <= maxWidth) return [[...line]];
+		if (wrap === "hard") return hardWrap(line, maxWidth);
+		if (wrap === "wrap") return wordWrap(line, maxWidth);
+		return [truncate(line, maxWidth, wrap, baseStyle)];
+	});
+}
+function wordWrap(line, maxWidth) {
+	const words = [[]];
+	const spaces = [];
+	for (const cell of line) if (cell.grapheme === " ") {
+		spaces.push(cell);
+		words.push([]);
+	} else words.at(-1).push(cell);
+	const output = [[]];
+	appendHard(output, words[0], maxWidth);
+	for (let index = 1; index < words.length; index++) {
+		appendHard(output, [spaces[index - 1]], maxWidth);
+		const word = words[index];
+		const current = output.at(-1);
+		const wordWidth = lineWidth(word);
+		const currentWidth = lineWidth(current);
+		if (wordWidth <= maxWidth && currentWidth + wordWidth > maxWidth) output.push([]);
+		else if (wordWidth > maxWidth && currentWidth > 0) {
+			const remaining = maxWidth - currentWidth;
+			const breaksHere = 1 + Math.floor((wordWidth - remaining - 1) / maxWidth);
+			if (Math.floor((wordWidth - 1) / maxWidth) < breaksHere) output.push([]);
+		}
+		appendHard(output, word, maxWidth);
+	}
+	return output;
+}
+function hardWrap(line, maxWidth) {
+	const output = [[]];
+	appendHard(output, line, maxWidth);
+	return output;
+}
+function appendHard(output, cells, maxWidth) {
+	for (const cell of cells) {
+		const current = output.at(-1);
+		if (current.length > 0 && lineWidth(current) + cell.width > maxWidth) output.push([]);
+		output.at(-1).push(cell);
+	}
+}
+function truncate(line, maxWidth, wrap, baseStyle) {
+	if (maxWidth === 1) return [ellipsis(baseStyle ?? cellStyleIntersection(line.at(0), line.at(-1)))];
+	if (wrap === "truncate-start") {
+		const right = sliceCells(line, lineWidth(line) - maxWidth + 1, lineWidth(line));
+		return [ellipsis(right[0]?.style), ...right];
+	}
+	if (wrap === "truncate-middle") {
+		const half = Math.min(Math.floor(maxWidth / 2), maxWidth - 1);
+		const left = sliceCells(line, 0, half);
+		const rightWidth = maxWidth - half - 1;
+		const right = sliceCells(line, lineWidth(line) - rightWidth, lineWidth(line));
+		return [
+			...left,
+			ellipsis(baseStyle ?? cellStyleIntersection(left.at(-1), right.at(0))),
+			...right
+		];
+	}
+	const left = sliceCells(line, 0, maxWidth - 1);
+	return [...left, ellipsis(left.at(-1)?.style)];
+}
+function sliceCells(line, start, end) {
+	const output = [];
+	let column = 0;
+	for (const cell of line) {
+		const nextColumn = column + cell.width;
+		if (column >= start && nextColumn <= end) output.push(cell);
+		column = nextColumn;
+	}
+	return output;
+}
+function ellipsis(style = semanticTextStyleToCellStyle(emptySemanticTextStyle)) {
+	return createCell("…", 1, style);
+}
+function cellStyleIntersection(left, right) {
+	if (!left) return right?.style ?? semanticTextStyleToCellStyle(emptySemanticTextStyle);
+	if (!right) return left.style;
+	return {
+		...sameColor(left.style.foreground, right.style.foreground) ? { foreground: left.style.foreground } : {},
+		...sameColor(left.style.background, right.style.background) ? { background: left.style.background } : {},
+		...sameColor(left.style.underlineColor, right.style.underlineColor) ? { underlineColor: left.style.underlineColor } : {},
+		underline: left.style.underline === right.style.underline ? left.style.underline : "none",
+		attributes: left.style.attributes & right.style.attributes
+	};
+}
+function sameColor(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+function lineWidth(line) {
+	return line.reduce((width, cell) => width + cell.width, 0);
+}
+function appendNode(node, inherited, lines, ansi) {
+	if (node.nodeName === "#text") {
+		if (ansi) appendAnsiText(node.nodeValue, inherited, lines);
+		else appendText(node.nodeValue, inherited, lines);
+		return;
+	}
+	const style = mergeSemanticTextStyles(inherited, node.internal_textStyle);
+	for (const child of node.childNodes) appendNode(child, style, lines, ansi || node.internal_ansi === true);
+}
+function appendAnsiText(text, semantic, lines) {
+	const base = semanticTextStyleToCellStyle(semantic);
+	for (const cell of cellsFromAnsi(text)) {
+		if (cell.grapheme === "\n" || cell.grapheme === "\r\n") {
+			lines.push([]);
+			continue;
+		}
+		const hasForeground = cell.style.foreground !== void 0;
+		const hasBackground = cell.style.background !== void 0;
+		lines.at(-1).push({
+			...cell,
+			style: {
+				...cell.style.foreground ?? base.foreground ? { foreground: cell.style.foreground ?? base.foreground } : {},
+				...cell.style.background ?? base.background ? { background: cell.style.background ?? base.background } : {},
+				...cell.style.underlineColor ? { underlineColor: cell.style.underlineColor } : {},
+				underline: cell.style.underline === "none" ? base.underline : cell.style.underline,
+				attributes: base.attributes | cell.style.attributes
+			},
+			...!hasForeground && semantic.foreground ? { foregroundPaint: semantic.foreground } : {},
+			...!hasBackground && semantic.background ? { backgroundPaint: semantic.background } : {}
+		});
+	}
+}
+function appendText(text, style, lines) {
+	const cellStyle = semanticTextStyleToCellStyle(style);
+	const plainText = tokenizeAnsi(text).filter((token) => token.type === "text").map((token) => token.value).join("");
+	for (const segment of graphemes(stripAnsi(plainText))) {
+		if (segment === "\n" || segment === "\r\n") {
+			lines.push([]);
+			continue;
+		}
+		lines.at(-1).push({
+			...createCell(segment, Math.max(1, stringWidth(segment)), cellStyle, void 0, style.resetForeground || style.resetBackground ? {
+				foreground: style.resetForeground,
+				background: style.resetBackground
+			} : void 0),
+			...style.foreground ? { foregroundPaint: style.foreground } : {},
+			...style.background ? { backgroundPaint: style.background } : {}
+		});
+	}
+}
+//#endregion
+//#region src/paint-tree.ts
+const renderAccessibleText = (node, options = {}) => {
+	if (options.skipStaticElements && node.internal_static) return "";
+	if (node.yogaNode?.getDisplay() === Yoga.DISPLAY_NONE) return "";
+	let output = "";
+	if (node.nodeName === "ink-text") output = squashTextNodes(node);
+	else if (node.nodeName === "ink-box" || node.nodeName === "ink-root") {
+		const separator = node.style.flexDirection === "row" || node.style.flexDirection === "row-reverse" ? " " : "\n";
+		output = (node.style.flexDirection === "row-reverse" || node.style.flexDirection === "column-reverse" ? [...node.childNodes].reverse() : [...node.childNodes]).map((childNode) => {
+			return renderAccessibleText(childNode, {
+				parentRole: node.internal_accessibility?.role,
+				skipStaticElements: options.skipStaticElements
+			});
+		}).filter(Boolean).join(separator);
+	}
+	if (node.internal_accessibility) {
+		const { role, state } = node.internal_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;
+};
+const paintTree = (node, output, options) => {
+	const { offsetX = 0, offsetY = 0, transformers = [], skipStaticElements } = options;
+	if (skipStaticElements && node.internal_static) return;
+	const { yogaNode } = node;
+	if (yogaNode) {
+		if (yogaNode.getDisplay() === Yoga.DISPLAY_NONE) return;
+		const x = offsetX + yogaNode.getComputedLeft();
+		const y = offsetY + yogaNode.getComputedTop();
+		const newTransformers = node.internal_transform ? [node.internal_transform, ...transformers] : transformers;
+		if (node.nodeName === "ink-text") {
+			if (squashTextNodes(node).length > 0) {
+				const maxWidth = getMaxWidth(yogaNode);
+				const firstChildYoga = node.childNodes[0]?.yogaNode;
+				const paddingX = firstChildYoga?.getComputedLeft() ?? 0;
+				const paddingY = firstChildYoga?.getComputedTop() ?? 0;
+				const textWrap = node.style.textWrap ?? "wrap";
+				const overflow = textWrap === "none";
+				const lines = wrapStructuredText(structuredTextLines(node), maxWidth, textWrap, structuredTextBaseStyle(node));
+				const paintBounds = {
+					x: x + paddingX,
+					y: y + paddingY,
+					width: Math.max(1, ...lines.map((line) => line.reduce((width, cell) => width + cell.width, 0))),
+					height: lines.length
+				};
+				const sampled = sampleStructuredText(lines, paintBounds, output.paintContext);
+				if (hasCompatibilityText(node)) {
+					const textTransformers = collectTransformers(node, transformers);
+					output.writeAnsi(paintBounds.x, paintBounds.y, sampled.map((line) => serializeLine(line, {
+						colorProfile: output.paintContext.profile ?? "truecolor",
+						trimEnd: false
+					})).join("\n"), {
+						transformers: textTransformers,
+						overflow
+					});
+				} else output.writeCells(paintBounds.x, paintBounds.y, sampled, { overflow });
+			}
+			return;
+		}
+		let clipped = false;
+		if (node.nodeName === "ink-box") {
+			renderBackground(x, y, node, output);
+			renderBorder(x, y, node, output);
+			const clipHorizontally = node.style.overflowX === "hidden" || node.style.overflow === "hidden";
+			const clipVertically = node.style.overflowY === "hidden" || node.style.overflow === "hidden";
+			if (clipHorizontally || clipVertically) {
+				const x1 = clipHorizontally ? x + yogaNode.getComputedBorder(Yoga.EDGE_LEFT) : void 0;
+				const x2 = clipHorizontally ? x + yogaNode.getComputedWidth() - yogaNode.getComputedBorder(Yoga.EDGE_RIGHT) : void 0;
+				const y1 = clipVertically ? y + yogaNode.getComputedBorder(Yoga.EDGE_TOP) : void 0;
+				const y2 = clipVertically ? y + yogaNode.getComputedHeight() - yogaNode.getComputedBorder(Yoga.EDGE_BOTTOM) : void 0;
+				output.clip({
+					x1,
+					x2,
+					y1,
+					y2
+				});
+				clipped = true;
+			}
+		}
+		if (node.nodeName === "ink-root" || node.nodeName === "ink-box") {
+			for (const childNode of node.childNodes) paintTree(childNode, output, {
+				offsetX: x,
+				offsetY: y,
+				transformers: newTransformers,
+				skipStaticElements
+			});
+			if (clipped) output.unclip();
+		}
+	}
+};
+function collectTransformers(node, inherited) {
+	return [
+		...node.childNodes.flatMap((child) => child.nodeName === "#text" ? [] : collectTransformers(child, [])),
+		...node.internal_transform ? [node.internal_transform] : [],
+		...inherited
+	];
+}
+//#endregion
+//#region src/screen/canvas.ts
+/** Immediate structured drawing canvas with one explicit ANSI compatibility adapter. */
+var Canvas = class {
+	width;
+	height;
+	paintContext;
+	#screen;
+	#clips = [];
+	constructor(options) {
+		this.width = options.width;
+		this.height = options.height;
+		this.paintContext = {
+			profile: options.colorProfile ?? "truecolor",
+			...options.paintContext
+		};
+		this.#screen = new Screen(this.width, this.height);
+	}
+	writeCells(x, y, lines, options) {
+		const clip = this.#clips.at(-1);
+		const overflow = options?.overflow === true;
+		for (const [rowOffset, line] of lines.entries()) {
+			const currentY = y + rowOffset;
+			if (!this.#insideY(currentY, clip)) continue;
+			let currentX = x;
+			for (const cell of line) {
+				const endX = currentX + cell.width;
+				if (!(clip?.x1 !== void 0 && currentX < clip.x1 || clip?.x2 !== void 0 && endX > clip.x2)) this.#composeNativeCell(currentX, currentY, cell, overflow);
+				currentX = endX;
+			}
+		}
+	}
+	writeAnsi(x, y, text, options) {
+		if (!text) return;
+		let lines = text.split("\n");
+		const clip = this.#clips.at(-1);
+		const overflow = options.overflow === true;
+		if (clip?.y1 !== void 0 && y < clip.y1) {
+			lines = lines.slice(clip.y1 - y);
+			y = clip.y1;
+		}
+		if (clip?.y2 !== void 0) lines = lines.slice(0, Math.max(0, clip.y2 - y));
+		for (const [lineIndex, original] of lines.entries()) {
+			const currentY = y + lineIndex;
+			if (!this.#insideY(currentY, clip)) continue;
+			let line = original;
+			let currentX = x;
+			if (clip?.x1 !== void 0 && currentX < clip.x1) {
+				line = sliceAnsi(line, clip.x1 - currentX);
+				currentX = clip.x1;
+			}
+			if (clip?.x2 !== void 0) line = sliceAnsi(line, 0, Math.max(0, clip.x2 - currentX));
+			for (const character of transformAnsiLine(line, lineIndex, options.transformers)) {
+				const width = Math.max(1, stringWidth(character.value));
+				if (clip?.x2 !== void 0 && currentX + width > clip.x2) break;
+				this.#writeCompatibilityCell(currentX, currentY, character, width, overflow);
+				currentX += width;
+			}
+		}
+	}
+	clip(clip) {
+		this.#clips.push(clip);
+	}
+	unclip() {
+		this.#clips.pop();
+	}
+	finish() {
+		return this.#screen;
+	}
+	#insideY(y, clip) {
+		return y >= 0 && y < this.#screen.height && (clip?.y1 === void 0 || y >= clip.y1) && (clip?.y2 === void 0 || y < clip.y2);
+	}
+	#composeNativeCell(x, y, cell, overflow = false) {
+		if (!overflow && x >= this.#screen.width) return;
+		this.#screen.composeCell(x, y, {
+			content: {
+				grapheme: cell.grapheme,
+				width: cell.width
+			},
+			foreground: cell.reset?.foreground ? null : cell.style.foreground ?? null,
+			background: cell.reset?.background ? null : cell.style.background,
+			underlineColor: cell.style.underlineColor ?? null,
+			underline: cell.style.underline,
+			attributes: cell.style.attributes,
+			hyperlink: cell.hyperlink ?? null
+		}, { overflow });
+	}
+	#writeCompatibilityCell(x, y, character, width, overflow = false) {
+		if (!overflow && x >= this.#screen.width) return;
+		const cell = cellFromStyledChar(character, width);
+		this.#screen.composeCell(x, y, {
+			content: {
+				grapheme: cell.grapheme,
+				width: cell.width
+			},
+			foreground: cell.style.foreground ?? null,
+			background: cell.style.background,
+			underlineColor: cell.style.underlineColor ?? null,
+			underline: cell.style.underline,
+			attributes: cell.style.attributes,
+			hyperlink: cell.hyperlink ?? null
+		}, { overflow });
+	}
+};
+//#endregion
+//#region src/render-frame.ts
+const renderDimension = (value) => Number.isFinite(value) ? Math.max(0, Math.ceil(value)) : 0;
+const renderFrame = (node, isScreenReaderEnabled, options = {}) => {
+	if (node.yogaNode) {
+		if (isScreenReaderEnabled) {
+			const output = renderAccessibleText(node, { skipStaticElements: true });
+			let staticOutput = "";
+			if (node.staticNode) staticOutput = renderAccessibleText(node.staticNode, { skipStaticElements: false });
+			return {
+				accessibleText: output,
+				staticAccessibleText: staticOutput
+			};
+		}
+		const output = new Canvas({
+			width: renderDimension(node.yogaNode.getComputedWidth()),
+			height: renderDimension(node.yogaNode.getComputedHeight()),
+			colorProfile: options.colorProfile,
+			paintContext: options.paintContext
+		});
+		paintTree(node, output, { skipStaticElements: true });
+		let staticOutput;
+		if (node.staticNode?.yogaNode) {
+			staticOutput = new Canvas({
+				width: renderDimension(node.staticNode.yogaNode.getComputedWidth()),
+				height: renderDimension(node.staticNode.yogaNode.getComputedHeight()),
+				colorProfile: options.colorProfile,
+				paintContext: options.paintContext
+			});
+			paintTree(node.staticNode, staticOutput, { skipStaticElements: false });
+		}
+		return {
+			screen: output.finish(),
+			...staticOutput ? { staticScreen: staticOutput.finish() } : {}
+		};
+	}
+	return { accessibleText: "" };
+};
+//#endregion
+//#region src/terminal/inline-presenter.ts
+/** Full-rewrite fallback and cursor state for the structured inline renderer. */
+function createInlinePresenter(stream, options = {}) {
+	let previousLineCount = 0;
+	let previousOutput = "";
+	let hasHiddenCursor = false;
+	let cursorPosition;
+	let cursorDirty = false;
+	let previousCursorPosition;
+	let cursorWasShown = false;
+	const showCursor = options.showCursor ?? false;
+	const activeCursor = () => cursorDirty ? cursorPosition : void 0;
+	const hasChanges = (output, cursor) => output !== previousOutput || cursorPositionChanged(cursor, previousCursorPosition);
+	const present = (output) => {
+		if (!showCursor && !hasHiddenCursor) {
+			cliCursor.hide(stream);
+			hasHiddenCursor = true;
+		}
+		const cursor = activeCursor();
+		cursorDirty = false;
+		const cursorChanged = cursorPositionChanged(cursor, previousCursorPosition);
+		if (!hasChanges(output, cursor)) return false;
+		const lines = output.split("\n");
+		const suffix = buildCursorSuffix(lines.length - 1, cursor);
+		if (output === previousOutput && cursorChanged) stream.write(buildCursorOnlySequence({
+			cursorWasShown,
+			previousLineCount,
+			previousCursorPosition,
+			cursorPosition: cursor
+		}));
+		else {
+			previousOutput = output;
+			stream.write(buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition) + ansiEscapes.eraseLines(previousLineCount) + output + suffix);
+			previousLineCount = lines.length;
+		}
+		previousCursorPosition = cursor ? { ...cursor } : void 0;
+		cursorWasShown = cursor !== void 0;
+		return true;
+	};
+	present.clear = () => {
+		stream.write(buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition) + ansiEscapes.eraseLines(previousLineCount));
+		previousOutput = "";
+		previousLineCount = 0;
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+	};
+	present.done = () => {
+		previousOutput = "";
+		previousLineCount = 0;
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+		if (!showCursor) {
+			cliCursor.show(stream);
+			hasHiddenCursor = false;
+		}
+	};
+	present.reset = () => {
+		previousOutput = "";
+		previousLineCount = 0;
+		previousCursorPosition = void 0;
+		cursorWasShown = false;
+	};
+	present.sync = (output) => {
+		const cursor = activeCursor();
+		cursorDirty = false;
+		const lines = output.split("\n");
+		previousOutput = output;
+		previousLineCount = lines.length;
+		if (!cursor && cursorWasShown) stream.write(hideCursorEscape);
+		if (cursor) stream.write(buildCursorSuffix(lines.length - 1, cursor));
+		previousCursorPosition = cursor ? { ...cursor } : void 0;
+		cursorWasShown = cursor !== void 0;
+	};
+	present.setCursorPosition = (position) => {
+		cursorPosition = position;
+		cursorDirty = true;
+	};
+	present.isCursorDirty = () => cursorDirty;
+	present.willRender = (output) => hasChanges(output, activeCursor());
+	return present;
+}
+//#endregion
+//#region src/throttle.ts
+/**
+Invokes `fn` at most once per `wait` milliseconds.
+
+The first call in a window fires immediately (leading edge). Calls made while
+the window is open are coalesced into a single trailing invocation with the
+latest arguments. Matches the lodash semantics Ink relied on: a single call
+produces only a leading invocation, no trailing one.
+*/
+const throttle = (fn, wait = 0) => {
+	let timer;
+	let pendingArgs;
+	const invokePending = () => {
+		const args = pendingArgs;
+		pendingArgs = void 0;
+		fn(...args);
+	};
+	const onTimer = () => {
+		if (pendingArgs) {
+			invokePending();
+			timer = setTimeout(onTimer, wait);
+		} else timer = void 0;
+	};
+	const throttled = (...args) => {
+		if (timer) {
+			pendingArgs = args;
+			return;
+		}
+		fn(...args);
+		timer = setTimeout(onTimer, wait);
+	};
+	throttled.cancel = () => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+		pendingArgs = void 0;
+	};
+	throttled.flush = () => {
+		if (!pendingArgs) return;
+		if (timer) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+		invokePending();
+	};
+	return throttled;
+};
+//#endregion
+//#region src/terminal/render-scheduler.ts
+/** Owns frame cadence independently of React reconciliation and terminal presentation. */
+function createRenderScheduler(render, options) {
+	const frameInterval = options.maxFps > 0 ? Math.max(1, Math.ceil(1e3 / options.maxFps)) : 0;
+	let pending = false;
+	const throttled = options.unthrottled ? void 0 : throttle(render, frameInterval);
+	return {
+		intervalMs: options.unthrottled ? 0 : frameInterval,
+		throttled,
+		get pending() {
+			return pending;
+		},
+		schedule: options.unthrottled ? render : () => {
+			pending = true;
+			throttled();
+		},
+		immediate: render,
+		markRendered() {
+			pending = false;
+		}
+	};
+}
+//#endregion
+//#region src/ink.tsx
+/** @jsxImportSource react */
+const noop = () => {};
+const beforeExitCallbacks = /* @__PURE__ */ new Set();
+const runBeforeExitCallbacks = () => {
+	for (const callback of beforeExitCallbacks) callback();
+};
+function registerBeforeExit(callback) {
+	if (beforeExitCallbacks.size === 0) process.on("beforeExit", runBeforeExitCallbacks);
+	beforeExitCallbacks.add(callback);
+	return () => {
+		beforeExitCallbacks.delete(callback);
+		if (beforeExitCallbacks.size === 0) process.off("beforeExit", runBeforeExitCallbacks);
+	};
+}
+function bottomRows(screen, height) {
+	if (screen.height <= height) return screen;
+	const cropped = new Screen(screen.width, height);
+	const offset = screen.height - height;
+	for (let y = 0; y < height; y++) for (let x = 0; x < screen.width; x++) {
+		const cell = screen.cellAt(x, y + offset);
+		if (cell && cell.width > 0) cropped.setCell(x, y, cell);
+	}
+	return cropped;
+}
+const RESIZE_SETTLE_MS = 50;
+const shouldClearTerminalForFrame = ({ isTTY, viewportRows, previousOutputHeight, nextOutputHeight, isUnmounting }) => {
+	if (!isTTY) return false;
+	const hadPreviousFrame = previousOutputHeight > 0;
+	const wasFullscreen = previousOutputHeight >= viewportRows;
+	const wasOverflowing = previousOutputHeight > viewportRows;
+	const isOverflowing = nextOutputHeight > viewportRows;
+	const isFullscreen = nextOutputHeight >= viewportRows;
+	const isLeavingFullscreen = wasOverflowing && nextOutputHeight < viewportRows;
+	const shouldClearOnUnmount = isUnmounting && wasFullscreen;
+	if (isWindows && (wasFullscreen || isFullscreen)) return true;
+	return wasOverflowing || isOverflowing && hadPreviousFrame || isLeavingFullscreen || shouldClearOnUnmount;
+};
+const isErrorInput = (value) => {
+	return value instanceof Error || isNativeError(value);
+};
+const getWritableStreamState = (stdout) => {
+	return { canWriteToStdout: !stdout.destroyed && !stdout.writableEnded && (stdout.writable ?? true) };
+};
+const settleThrottle = (throttled, canWriteToStdout) => {
+	if (!throttled) return;
+	if (canWriteToStdout) throttled.flush();
+	else throttled.cancel();
+};
+const writeBestEffort = (stream, data) => {
+	try {
+		stream.write(data);
+	} catch {}
+};
+const createRenderPassthrough = (stream) => {
+	const passthrough = Object.create(stream);
+	passthrough.write = stream.write.bind(stream);
+	passthrough.on = stream.on.bind(stream);
+	passthrough.off = stream.off.bind(stream);
+	passthrough.once = stream.once.bind(stream);
+	passthrough.addListener = stream.addListener.bind(stream);
+	passthrough.removeListener = stream.removeListener.bind(stream);
+	passthrough.emit = stream.emit.bind(stream);
+	return passthrough;
+};
+const createInk = (options) => {
+	let captureTargets;
+	if (options.patchConsole === "stdio") {
+		captureTargets = {
+			stdout: options.stdout,
+			stderr: options.stderr
+		};
+		options = {
+			...options,
+			stdout: createRenderPassthrough(options.stdout),
+			stderr: createRenderPassthrough(options.stderr)
+		};
+	}
+	const rootNode = createNode("ink-root");
+	rootNode.onComputeLayout = calculateLayout;
+	const isScreenReaderEnabled = options.isScreenReaderEnabled ?? isScreenReader;
+	const interactive = options.interactive ?? (!isInCi && Boolean(options.stdout.isTTY));
+	const terminal = new TerminalSession({
+		stdin: options.stdin,
+		stdout: options.stdout,
+		stderr: options.stderr,
+		colorPolicy: options.colorProfile ?? "auto",
+		onCapabilitiesChange: () => rootNode.onRender?.()
+	});
+	const terminalOsc = {
+		publishProgress: (owner, state, value) => {
+			terminal.publishProgress(owner, state, value);
+		},
+		copyToClipboard: (text, selection) => {
+			terminal.copyToClipboard(text, selection);
+		},
+		publishTitle: (owner, title) => terminal.publishTitle(owner, title),
+		setWorkingDirectory: (directory) => terminal.setWorkingDirectory(directory),
+		notify: (title) => terminal.notify(title),
+		setPointerShape: (shape) => terminal.setPointerShape(shape)
+	};
+	const capabilitiesStore = terminal.capabilities;
+	const renderScheduler = createRenderScheduler(onRender, {
+		unthrottled: options.debug || isScreenReaderEnabled,
+		maxFps: options.maxFps ?? 30
+	});
+	rootNode.onRender = renderScheduler.schedule;
+	rootNode.onImmediateRender = renderScheduler.immediate;
+	rootNode.onStaticChange = handleStaticChange;
+	const accessiblePresenter = isScreenReaderEnabled ? createInlinePresenter(options.stdout, { showCursor: true }) : void 0;
+	let isUnmounted = false;
+	let isUnmounting = false;
+	const isConcurrent = options.concurrent ?? false;
+	let lastOutput = "";
+	let lastOutputToRender = "";
+	let lastOutputHeight = 0;
+	let lastScreen;
+	const windowSize = () => capabilitiesStore.current.size;
+	let lastTerminalWidth = windowSize().columns;
+	let lastTerminalHeight = windowSize().rows;
+	let resizeSettle;
+	let fullStaticOutput = "";
+	let exitResult;
+	let unsubscribeBeforeExit;
+	let restoreConsole;
+	const capturedStdioTails = {
+		stdout: "",
+		stderr: ""
+	};
+	let unsubscribeResize;
+	let kittyProtocolEnabled = false;
+	let kittyFlags;
+	let cancelKittyDetection;
+	let nextRenderCommit;
+	let pauseInput;
+	let resumeInput;
+	const rootTag = isConcurrent ? ConcurrentRoot : LegacyRoot;
+	const container = reconciler.createContainer(rootNode, rootTag, null, false, null, "id", () => {}, () => {}, () => {}, () => {});
+	const unsubscribeExit = signalExit(unmount, { alwaysLast: false });
+	setAlternateScreen(Boolean(options.alternateScreen));
+	if (isSigilDev) reconciler.injectIntoDevTools();
+	if (options.patchConsole) installConsolePatch();
+	if (interactive) {
+		let seenColumns = lastTerminalWidth;
+		let seenRows = lastTerminalHeight;
+		unsubscribeResize = capabilitiesStore.subscribe(({ size }) => {
+			if (size.columns === seenColumns && size.rows === seenRows) return;
+			seenColumns = size.columns;
+			seenRows = size.rows;
+			resized(size.source);
+		});
+	}
+	initKittyKeyboard();
+	const { promise: exitPromise, resolve: resolveExitPromise, reject: rejectExitPromise } = Promise.withResolvers();
+	exitPromise.catch(noop);
+	function resized(source) {
+		if (resizeSettle !== void 0) {
+			clearTimeout(resizeSettle);
+			resizeSettle = void 0;
+		}
+		if (source === "terminal") {
+			settleResize();
+			return;
+		}
+		resizeSettle = setTimeout(settleResize, RESIZE_SETTLE_MS);
+	}
+	function settleResize() {
+		resizeSettle = void 0;
+		if (isUnmounted || isUnmounting) return;
+		const { columns: currentWidth, rows: currentHeight } = windowSize();
+		if (currentWidth < lastTerminalWidth || currentHeight !== lastTerminalHeight) {
+			clearLiveOutput(rewrapsOnResize() ? currentWidth : void 0);
+			resetLiveOutput();
+			lastOutput = "";
+			lastOutputToRender = "";
+			lastOutputHeight = 0;
+		}
+		lastTerminalWidth = currentWidth;
+		lastTerminalHeight = currentHeight;
+		calculateLayout();
+		emitLayoutListeners(rootNode);
+		onRender();
+	}
+	function rewrapsOnResize() {
+		return !isWindows && capabilitiesStore.current.terminal.name !== "apple-terminal";
+	}
+	function handleAppExit(errorOrResult) {
+		if (isUnmounted || isUnmounting) return;
+		if (isErrorInput(errorOrResult)) {
+			unmount(errorOrResult);
+			return;
+		}
+		exitResult = errorOrResult;
+		unmount();
+	}
+	function setCursorPosition(position) {
+		terminal.setCursor(position);
+		accessiblePresenter?.setCursorPosition(position);
+	}
+	function restoreLastOutput() {
+		if (!interactive) return;
+		if (isScreenReaderEnabled) {
+			accessiblePresenter.setCursorPosition(terminal.cursor.position);
+			accessiblePresenter(lastOutputToRender || lastOutput + "\n");
+		} else if (lastScreen) terminal.present(lastScreen, {
+			fullscreen: lastOutputToRender === lastOutput,
+			forceRewrite: true
+		});
+	}
+	function clearLiveOutput(columns) {
+		if (isScreenReaderEnabled) accessiblePresenter.clear();
+		else terminal.clearFrame({ columns });
+	}
+	function finishLiveOutput() {
+		if (isScreenReaderEnabled) accessiblePresenter.done();
+		else terminal.finishFrame();
+	}
+	function resetLiveOutput() {
+		if (isScreenReaderEnabled) accessiblePresenter.reset();
+		else terminal.resetFrame();
+	}
+	function calculateLayout() {
+		const terminalWidth = windowSize().columns;
+		rootNode.yogaNode.setWidth(terminalWidth);
+		rootNode.yogaNode.calculateLayout(void 0, void 0, Yoga.DIRECTION_LTR);
+	}
+	function handleStaticChange() {
+		fullStaticOutput = "";
+	}
+	function onRender() {
+		renderScheduler.markRendered();
+		if (isUnmounted) return;
+		if (terminal.suspended) {
+			if (nextRenderCommit) {
+				nextRenderCommit.resolve();
+				nextRenderCommit = void 0;
+			}
+			return;
+		}
+		if (resizeSettle !== void 0 && !isUnmounting) {
+			if (nextRenderCommit) {
+				nextRenderCommit.resolve();
+				nextRenderCommit = void 0;
+			}
+			return;
+		}
+		if (nextRenderCommit) {
+			nextRenderCommit.resolve();
+			nextRenderCommit = void 0;
+		}
+		const startTime = performance.now();
+		const rendered = renderFrame(rootNode, isScreenReaderEnabled, {
+			colorProfile: terminal.colorProfile,
+			paintContext: {
+				appearance: capabilitiesStore.current.theme.appearance,
+				palette: capabilitiesStore.current.theme.palette
+			}
+		});
+		const screen = rendered.screen;
+		const output = rendered.accessibleText ?? (screen ? terminal.encode(screen) : "");
+		const outputHeight = rendered.accessibleText === void 0 ? screen?.height ?? 0 : rendered.accessibleText === "" ? 0 : rendered.accessibleText.split("\n").length;
+		const staticBody = rendered.staticAccessibleText ?? (rendered.staticScreen ? terminal.encode(rendered.staticScreen) : "");
+		const staticOutput = staticBody ? `${staticBody}\n` : "";
+		options.onRender?.({ renderTime: performance.now() - startTime });
+		const hasStaticOutput = staticOutput && staticOutput !== "\n";
+		if (options.debug) {
+			if (hasStaticOutput) fullStaticOutput += staticOutput;
+			lastOutput = output;
+			lastOutputToRender = output;
+			lastOutputHeight = outputHeight;
+			options.stdout.write(fullStaticOutput + output);
+			return;
+		}
+		if (!interactive) {
+			if (hasStaticOutput) options.stdout.write(staticOutput);
+			lastOutput = output;
+			lastOutputToRender = output + "\n";
+			lastOutputHeight = outputHeight;
+			return;
+		}
+		if (isScreenReaderEnabled) {
+			const sync = shouldSync();
+			if (sync) options.stdout.write(bsu);
+			if (hasStaticOutput) {
+				const erase = lastOutputHeight > 0 ? ansiEscapes.eraseLines(lastOutputHeight) : "";
+				options.stdout.write(erase + staticOutput);
+				lastOutputHeight = 0;
+			}
+			if (output === lastOutput && !hasStaticOutput) {
+				if (sync) options.stdout.write(esu);
+				return;
+			}
+			const terminalWidth = windowSize().columns;
+			const wrappedOutput = wrapAnsi(output, terminalWidth, {
+				trim: false,
+				hard: true
+			});
+			if (hasStaticOutput) options.stdout.write(wrappedOutput);
+			else {
+				const erase = lastOutputHeight > 0 ? ansiEscapes.eraseLines(lastOutputHeight) : "";
+				options.stdout.write(erase + wrappedOutput);
+			}
+			lastOutput = output;
+			lastOutputToRender = wrappedOutput;
+			lastOutputHeight = wrappedOutput === "" ? 0 : wrappedOutput.split("\n").length;
+			if (sync) options.stdout.write(esu);
+			return;
+		}
+		if (hasStaticOutput) fullStaticOutput += staticOutput;
+		renderInteractiveFrame(output, outputHeight, hasStaticOutput ? staticOutput : "", screen, false);
+	}
+	function render(node) {
+		const tree = /* @__PURE__ */ jsx(accessibilityContext.Provider, {
+			value: { isScreenReaderEnabled },
+			children: /* @__PURE__ */ jsx(TerminalOscContext.Provider, {
+				value: terminalOsc,
+				children: /* @__PURE__ */ jsx(App, {
+					stdin: options.stdin,
+					stdout: options.stdout,
+					stderr: options.stderr,
+					exitOnCtrlC: options.exitOnCtrlC,
+					interactive,
+					renderThrottleMs: renderScheduler.intervalMs,
+					terminalInput: terminal.input,
+					writeToStdout,
+					writeToStderr,
+					setCursorPosition,
+					onExit: handleAppExit,
+					onWaitUntilRenderFlush: waitUntilRenderFlush,
+					onSuspendTerminal: suspendTerminal,
+					onRegisterInputControl: registerInputControl,
+					children: node
+				})
+			})
+		});
+		if (isConcurrent) reconciler.updateContainer(tree, container, null, noop);
+		else {
+			reconciler.updateContainerSync(tree, container, null, noop);
+			reconciler.flushSyncWork();
+		}
+	}
+	function writeToStdout(data) {
+		if (isUnmounted) return;
+		if (terminal.suspended) return;
+		if (options.debug) {
+			options.stdout.write(data + fullStaticOutput + lastOutput);
+			return;
+		}
+		if (!interactive) {
+			options.stdout.write(data);
+			return;
+		}
+		const sync = shouldSync();
+		if (sync) options.stdout.write(bsu);
+		clearLiveOutput();
+		options.stdout.write(data);
+		restoreLastOutput();
+		if (sync) options.stdout.write(esu);
+	}
+	function writeToStderr(data) {
+		if (isUnmounted) return;
+		if (terminal.suspended) return;
+		if (options.debug) {
+			options.stderr.write(data);
+			options.stdout.write(fullStaticOutput + lastOutput);
+			return;
+		}
+		if (!interactive) {
+			options.stderr.write(data);
+			return;
+		}
+		const sync = shouldSync();
+		if (sync) options.stdout.write(bsu);
+		clearLiveOutput();
+		options.stderr.write(data);
+		restoreLastOutput();
+		if (sync) options.stdout.write(esu);
+	}
+	function unmount(error) {
+		if (isUnmounted || isUnmounting) return;
+		isUnmounting = true;
+		if (resizeSettle !== void 0) {
+			clearTimeout(resizeSettle);
+			resizeSettle = void 0;
+		}
+		unsubscribeBeforeExit?.();
+		unsubscribeBeforeExit = void 0;
+		const { canWriteToStdout } = getWritableStreamState(options.stdout);
+		if (canWriteToStdout) flushCapturedStdio();
+		settleThrottle(renderScheduler.throttled, canWriteToStdout);
+		if (canWriteToStdout) {
+			if (!renderScheduler.throttled || !renderScheduler.pending && fullStaticOutput === "") {
+				calculateLayout();
+				onRender();
+			}
+		}
+		isUnmounted = true;
+		unsubscribeExit();
+		terminal.cleanup();
+		if (typeof restoreConsole === "function") restoreConsole();
+		const finishUnmount = () => {
+			if (typeof unsubscribeResize === "function") unsubscribeResize();
+			if (cancelKittyDetection) cancelKittyDetection();
+			if (canWriteToStdout) {
+				if (kittyProtocolEnabled) writeBestEffort(options.stdout, ansiEscapes.popKittyKeyboard);
+				if (terminal.alternateScreen) {
+					terminal.setAlternateScreen(false);
+					terminal.setCursorAppearance({ visible: true });
+				}
+				if (!interactive) options.stdout.write(options.debug ? "\n" : lastOutput + "\n");
+				else if (!options.debug) finishLiveOutput();
+			}
+			kittyProtocolEnabled = false;
+			instances.delete(captureTargets?.stdout ?? options.stdout);
+			const finalExitResult = exitResult;
+			const resolveOrReject = () => {
+				if (isErrorInput(error)) rejectExitPromise(error);
+				else resolveExitPromise(finalExitResult);
+			};
+			if (error !== void 0 && !isErrorInput(error)) resolveOrReject();
+			else if (canWriteToStdout) options.stdout.write("", resolveOrReject);
+			else setImmediate(resolveOrReject);
+		};
+		const concurrentReconciler = reconciler;
+		if (isConcurrent) {
+			reconciler.updateContainerSync(null, container, null, noop);
+			reconciler.flushSyncWork();
+			concurrentReconciler.flushPassiveEffects?.();
+			finishUnmount();
+		} else {
+			reconciler.updateContainerSync(null, container, null, noop);
+			reconciler.flushSyncWork();
+			finishUnmount();
+		}
+	}
+	async function waitUntilExit() {
+		if (!unsubscribeBeforeExit) unsubscribeBeforeExit = registerBeforeExit(() => {
+			unmount();
+		});
+		return exitPromise;
+	}
+	async function waitUntilRenderFlush() {
+		if (isUnmounted || isUnmounting) {
+			await awaitExit();
+			return;
+		}
+		await setImmediate$1();
+		if (isUnmounted || isUnmounting) {
+			await awaitExit();
+			return;
+		}
+		if (isConcurrent && hasPendingConcurrentWork()) {
+			await Promise.race([awaitNextRender(), awaitExit()]);
+			if (isUnmounted || isUnmounting) {
+				nextRenderCommit = void 0;
+				await awaitExit();
+				return;
+			}
+		}
+		reconciler.flushSyncWork();
+		const { canWriteToStdout } = getWritableStreamState(options.stdout);
+		settleThrottle(renderScheduler.throttled, canWriteToStdout);
+		if (canWriteToStdout) {
+			await new Promise((resolve) => {
+				options.stdout.write("", () => {
+					resolve();
+				});
+			});
+			return;
+		}
+		await setImmediate$1();
+	}
+	function clear() {
+		if (interactive && !options.debug) {
+			clearLiveOutput();
+			if (isScreenReaderEnabled) accessiblePresenter.sync(lastOutputToRender || lastOutput + "\n");
+		}
+	}
+	function installConsolePatch() {
+		if (options.debug) return;
+		const restoreConsoleMethods = patchConsole((stream, data) => {
+			if (options.onCapturedOutput?.(stream, data, "console") === true) return;
+			if (stream === "stdout") writeToStdout(data);
+			if (stream === "stderr") {
+				if (!data.startsWith("The above error occurred")) writeToStderr(data);
+			}
+		});
+		const restoreDirectStdio = patchDirectStdio();
+		restoreConsole = () => {
+			restoreConsoleMethods();
+			restoreDirectStdio?.();
+		};
+	}
+	function patchDirectStdio() {
+		if (!captureTargets) return;
+		const restoreStdout = patchStreamWrite(captureTargets.stdout, (data) => {
+			handleCapturedStdio("stdout", data);
+		});
+		const restoreStderr = patchStreamWrite(captureTargets.stderr, (data) => {
+			handleCapturedStdio("stderr", data);
+		});
+		return () => {
+			restoreStdout();
+			restoreStderr();
+		};
+	}
+	function handleCapturedStdio(stream, data) {
+		if (options.onCapturedOutput?.(stream, data, "stdio") === true) return;
+		const parts = (capturedStdioTails[stream] + data).split(/\r?\n/);
+		capturedStdioTails[stream] = parts.pop() ?? "";
+		if (parts.length === 0) return;
+		const payload = parts.join("\n") + "\n";
+		if (stream === "stdout") writeToStdout(payload);
+		else writeToStderr(payload);
+	}
+	function flushCapturedStdio() {
+		for (const stream of ["stdout", "stderr"]) {
+			const tail = capturedStdioTails[stream];
+			if (tail === "") continue;
+			capturedStdioTails[stream] = "";
+			if (stream === "stdout") writeToStdout(tail + "\n");
+			else writeToStderr(tail + "\n");
+		}
+	}
+	function registerInputControl(pause, resume) {
+		pauseInput = pause;
+		resumeInput = resume;
+	}
+	async function suspendTerminal(callback) {
+		beginSuspend();
+		if (callback) {
+			try {
+				await callback();
+			} finally {
+				await endSuspend();
+			}
+			return;
+		}
+		const resume = async () => {
+			await endSuspend();
+		};
+		return {
+			resume,
+			[Symbol.asyncDispose]: resume
+		};
+	}
+	function setAlternateScreen(enabled) {
+		terminal.setAlternateScreen(enabled && interactive && Boolean(options.stdout.isTTY), { hideCursor: true });
+	}
+	function shouldSync() {
+		return Boolean(options.stdout.isTTY) && interactive;
+	}
+	async function awaitExit() {
+		try {
+			await exitPromise;
+		} catch {}
+	}
+	function hasPendingConcurrentWork() {
+		const concurrentContainer = container;
+		return (concurrentContainer.pendingLanes ?? 0) !== 0 && concurrentContainer.callbackNode !== void 0 && concurrentContainer.callbackNode !== null;
+	}
+	async function awaitNextRender() {
+		nextRenderCommit ??= Promise.withResolvers();
+		return nextRenderCommit.promise;
+	}
+	function renderInteractiveFrame(output, outputHeight, staticOutput, screen, hasOverflow) {
+		if (!screen) return;
+		const hasStaticOutput = staticOutput !== "";
+		const isTTY = Boolean(options.stdout.isTTY);
+		const viewportRows = isTTY ? windowSize().rows : 24;
+		if (isTTY && outputHeight > viewportRows) {
+			const lines = output.split("\n");
+			output = lines.slice(lines.length - viewportRows).join("\n");
+			outputHeight = viewportRows;
+			screen = bottomRows(screen, viewportRows);
+		}
+		const isFullscreen = isTTY && outputHeight >= viewportRows;
+		const outputToRender = isFullscreen ? output : output + "\n";
+		if (shouldClearTerminalForFrame({
+			isTTY,
+			viewportRows,
+			previousOutputHeight: lastOutputHeight,
+			nextOutputHeight: outputHeight,
+			isUnmounting
+		})) {
+			const sync = shouldSync();
+			if (sync) options.stdout.write(bsu);
+			options.stdout.write(ansiEscapes.clearTerminal + fullStaticOutput + outputToRender);
+			lastOutput = output;
+			lastOutputToRender = outputToRender;
+			lastOutputHeight = outputHeight;
+			lastScreen = screen;
+			terminal.resetFrame();
+			if (sync) options.stdout.write(esu);
+			return;
+		}
+		const willPresent = terminal.willPresent(screen, {
+			fullscreen: isFullscreen,
+			forceRewrite: hasStaticOutput || hasOverflow
+		});
+		const sync = shouldSync() && willPresent;
+		if (sync) terminal.write(bsu);
+		if (hasStaticOutput) {
+			terminal.clearFrame();
+			terminal.write(staticOutput);
+		}
+		terminal.present(screen, {
+			fullscreen: isFullscreen,
+			forceRewrite: hasStaticOutput || hasOverflow
+		});
+		if (sync) terminal.write(esu);
+		lastOutput = output;
+		lastOutputToRender = outputToRender;
+		lastOutputHeight = outputHeight;
+		lastScreen = screen;
+	}
+	function initKittyKeyboard() {
+		if (!options.kittyKeyboard) return;
+		const opts = options.kittyKeyboard;
+		const mode = opts.mode ?? "auto";
+		if (mode === "disabled") return;
+		const flags = opts.flags ?? ["disambiguateEscapeCodes"];
+		if (mode === "enabled") {
+			if (isTty(options.stdin) && options.stdout.isTTY) enableKittyProtocol(flags);
+			return;
+		}
+		if (!interactive || !isTty(options.stdin) || !options.stdout.isTTY) return;
+		cancelKittyDetection = detectKittySupport(options.stdin, options.stdout, () => {
+			cancelKittyDetection = void 0;
+			if (!isUnmounted) enableKittyProtocol(flags);
+		});
+	}
+	function enableKittyProtocol(flags) {
+		options.stdout.write(ansiEscapes.pushKittyKeyboard(resolveFlags(flags)));
+		kittyProtocolEnabled = true;
+		kittyFlags = flags;
+	}
+	function beginSuspend() {
+		terminal.beginSuspension();
+		if (!interactive || isUnmounted || isUnmounting) return;
+		try {
+			const { canWriteToStdout } = getWritableStreamState(options.stdout);
+			settleThrottle(renderScheduler.throttled, canWriteToStdout);
+			if (canWriteToStdout) flushCapturedStdio();
+			if (canWriteToStdout) {
+				clearLiveOutput();
+				finishLiveOutput();
+				if (kittyProtocolEnabled) writeBestEffort(options.stdout, ansiEscapes.popKittyKeyboard);
+				if (terminal.alternateScreen) writeBestEffort(options.stdout, ansiEscapes.exitAlternativeScreen);
+			}
+			pauseInput?.();
+		} catch (error) {
+			terminal.resume();
+			try {
+				resumeInput?.();
+			} catch {}
+			throw error;
+		}
+	}
+	async function endSuspend() {
+		if (!terminal.suspended) return;
+		terminal.resume();
+		resumeInput?.();
+		if (!interactive || isUnmounted || isUnmounting) return;
+		const { canWriteToStdout } = getWritableStreamState(options.stdout);
+		if (canWriteToStdout) {
+			if (terminal.alternateScreen) writeBestEffort(options.stdout, ansiEscapes.enterAlternativeScreen);
+			if (kittyProtocolEnabled && kittyFlags) writeBestEffort(options.stdout, ansiEscapes.pushKittyKeyboard(resolveFlags(kittyFlags)));
+		}
+		lastOutput = "";
+		lastOutputToRender = "";
+		lastOutputHeight = 0;
+		resetLiveOutput();
+		try {
+			calculateLayout();
+			onRender();
+			await waitUntilRenderFlush();
+		} catch {}
+	}
+	return {
+		render,
+		unmount,
+		waitUntilExit,
+		waitUntilRenderFlush,
+		clear,
+		copyToClipboard: (text, selection) => terminal.copyToClipboard(text, selection),
+		setProgress: (state, value) => terminal.setProgress(state, value)
+	};
+};
+//#endregion
+//#region src/render.ts
+/**
+Mount a component and render the output.
+*/
+const render = (node, options) => {
+	const inkOptions = {
+		stdout: process.stdout,
+		stdin: process.stdin,
+		stderr: process.stderr,
+		debug: false,
+		exitOnCtrlC: true,
+		patchConsole: true,
+		maxFps: 30,
+		concurrent: false,
+		alternateScreen: false,
+		...getOptions(options)
+	};
+	const instance = getInstance(inkOptions.stdout, () => createInk(inkOptions));
+	instance.render(node);
+	return {
+		rerender: instance.render,
+		unmount() {
+			instance.unmount();
+		},
+		waitUntilExit: instance.waitUntilExit,
+		waitUntilRenderFlush: instance.waitUntilRenderFlush,
+		cleanup() {
+			instance.unmount();
+		},
+		clear: instance.clear,
+		copyToClipboard: instance.copyToClipboard,
+		setProgress: instance.setProgress
+	};
+};
+const getOptions = (stdout = {}) => {
+	if (stdout instanceof Stream) return {
+		stdout,
+		stdin: process.stdin
+	};
+	return stdout;
+};
+const getInstance = (stdout, createInstance) => {
+	const instance = instances.get(stdout);
+	if (instance === void 0) {
+		const newInstance = createInstance();
+		instances.set(stdout, newInstance);
+		return newInstance;
+	}
+	process.stderr.write("Warning: render() was called again for the same stdout before the previous Ink instance was unmounted. Reusing stdout across multiple render() calls is unsupported. Call unmount() first.\n");
+	return instance;
+};
+//#endregion
+//#region src/render-to-string.ts
+/**
+Render a React element to a string synchronously. Unlike `render()`, this function does not write to stdout, does not set up any terminal event listeners, and returns the rendered output as a string.
+
+Useful for generating documentation, writing output to files, testing, or any scenario where you need the rendered output as a string without starting a persistent terminal application.
+
+**Notes:**
+
+- Terminal-specific hooks (`useInput`, `useStdin`, `useStdout`, `useStderr`, `useApp`, `useFocus`, `useFocusManager`) return default no-op values since there is no terminal session. They will not throw, but they will not function as in a live terminal.
+- `useEffect` callbacks will execute during rendering (due to synchronous rendering mode), but state updates they trigger will not affect the returned output, which reflects the initial render.
+- `useLayoutEffect` callbacks fire synchronously during commit, so state updates they trigger **will** be reflected in the output.
+- The `<Static>` component is supported — its output is prepended to the dynamic output.
+- If a component throws during rendering, the error is propagated to the caller after cleanup.
+
+@example
+```
+import {renderToString, Text, Box} from 'ink';
+
+const output = renderToString(
+<Box padding={1}>
+<Text color="green">Hello World</Text>
+</Box>,
+{columns: 40}
+);
+
+console.log(output);
+```
+*/
+const renderToString = (node, options) => {
+	const columns = options?.columns ?? 80;
+	const colorProfile = options?.colorProfile ?? colorProfileFromLevel(detectColorLevel());
+	const rootNode = createNode("ink-root");
+	let capturedStaticOutput = "";
+	rootNode.onComputeLayout = () => {
+		rootNode.yogaNode.setWidth(columns);
+		rootNode.yogaNode.calculateLayout(void 0, void 0, Yoga.DIRECTION_LTR);
+	};
+	rootNode.onImmediateRender = () => {
+		const { staticScreen } = renderFrame(rootNode, false, { colorProfile });
+		const staticOutput = staticScreen ? `${serializeScreen(staticScreen, {
+			colorProfile,
+			styles: colorProfile !== "none"
+		})}\n` : "";
+		if (staticOutput && staticOutput !== "\n") capturedStaticOutput += staticOutput;
+	};
+	let uncaughtError;
+	const container = reconciler.createContainer(rootNode, LegacyRoot, null, false, null, "render-to-string", (error) => {
+		uncaughtError ??= error;
+	}, () => {}, () => {}, () => {});
+	reconciler.updateContainerSync(node, container, null, () => {});
+	reconciler.flushSyncWork();
+	const { screen } = renderFrame(rootNode, false, { colorProfile });
+	const output = screen ? serializeScreen(screen, {
+		colorProfile,
+		styles: colorProfile !== "none"
+	}) : "";
+	reconciler.updateContainerSync(null, container, null, () => {});
+	reconciler.flushSyncWork();
+	if (uncaughtError !== void 0) throw uncaughtError instanceof Error ? uncaughtError : new Error(String(uncaughtError));
+	const normalizedStaticOutput = capturedStaticOutput.endsWith("\n") ? capturedStaticOutput.slice(0, -1) : capturedStaticOutput;
+	if (normalizedStaticOutput && output) return normalizedStaticOutput + "\n" + output;
+	return normalizedStaticOutput || output;
+};
+//#endregion
+//#region src/components/AnsiText.tsx
+/** @jsxImportSource react */
+/**
+* Renders explicitly trusted ANSI-styled output as structured terminal cells.
+* Ordinary `Text` continues to strip terminal control sequences.
+*/
+function AnsiText({ children, wrap = "wrap", "aria-label": ariaLabel, "aria-hidden": ariaHidden = false }) {
+	const { isScreenReaderEnabled } = useContext(accessibilityContext);
+	if (isScreenReaderEnabled) {
+		if (ariaHidden) return null;
+		return /* @__PURE__ */ jsx(Text, { children: ariaLabel ?? stripAnsi(children) });
+	}
+	return /* @__PURE__ */ jsx("ink-text", {
+		style: {
+			flexGrow: 0,
+			flexShrink: 1,
+			flexDirection: "row",
+			textWrap: wrap
+		},
+		internal_ansi: true,
+		children
+	});
+}
+//#endregion
+//#region src/components/Static.tsx
+/** @jsxImportSource react */
+/**
+`<Static>` component permanently renders its output above everything else. It's useful for displaying activity like completed tasks or logs—things that don't change after they're rendered (hence the name "Static").
+
+It's preferred to use `<Static>` for use cases like these when you can't know or control the number of items that need to be rendered.
+
+For example, [Tap](https://github.com/tapjs/node-tap) uses `<Static>` to display a list of completed tests. [Gatsby](https://github.com/gatsbyjs/gatsby) uses it to display a list of generated pages while still displaying a live progress bar.
+*/
+function Static(props) {
+	const { items, children: render, style: customStyle } = props;
+	const [index, setIndex] = useState(0);
+	const itemsToRender = useMemo(() => {
+		return items.slice(index);
+	}, [items, index]);
+	useLayoutEffect(() => {
+		setIndex(items.length);
+	}, [items.length]);
+	const children = itemsToRender.map((item, itemIndex) => {
+		return render(item, index + itemIndex);
+	});
+	const style = useMemo(() => ({
+		position: "absolute",
+		flexDirection: "column",
+		...customStyle
+	}), [customStyle]);
+	return /* @__PURE__ */ jsx("ink-box", {
+		internal_static: true,
+		style,
+		children
+	});
+}
+//#endregion
+//#region src/components/Transform.tsx
+/** @jsxImportSource react */
+/**
+Transform a string representation of React components before they're written to output. For example, you might want to apply a gradient to text, add a clickable link, or create some text effects. These use cases can't accept React nodes as input; they expect a string. That's what the <Transform> component does: it gives you an output string of its child components and lets you transform it in any way.
+*/
+function Transform({ children, transform, accessibilityLabel }) {
+	const { isScreenReaderEnabled } = useContext(accessibilityContext);
+	if (children === void 0 || children === null) return null;
+	return /* @__PURE__ */ jsx("ink-text", {
+		style: {
+			flexGrow: 0,
+			flexShrink: 1,
+			flexDirection: "row"
+		},
+		internal_transform: transform,
+		children: isScreenReaderEnabled && accessibilityLabel ? accessibilityLabel : children
+	});
+}
+//#endregion
+//#region src/hooks/use-stdout.ts
+/**
+A React hook that returns the stdout stream where Ink renders your app.
+*/
+const useStdout = () => useContext(StdoutContext);
+//#endregion
+//#region src/components/Hyperlink.tsx
+/**
+A clickable OSC 8 hyperlink — the counterpart to the router's `<Link>`, which
+navigates between screens. On terminals without hyperlink support it falls
+back to `text (url)`.
+
+```tsx
+<Hyperlink url="https://example.com">Documentation</Hyperlink>
+```
+*/
+function Hyperlink({ url, fallback = true, children, ...textProps }) {
+	const { stdout } = useStdout();
+	if (!detectHyperlinkSupport(stdout)) return /* @__PURE__ */ jsxs(Text, {
+		...textProps,
+		children: [children, fallback ? /* @__PURE__ */ jsxs(Text, {
+			dimColor: true,
+			children: [
+				" (",
+				url,
+				")"
+			]
+		}) : null]
+	});
+	return /* @__PURE__ */ jsx(Transform, {
+		transform: (text) => link(text, url),
+		children: /* @__PURE__ */ jsx(Text, {
+			...textProps,
+			children
+		})
+	});
+}
+//#endregion
+//#region src/components/Newline.tsx
+/**
+Adds one or more newline (`\n`) characters. Must be used within `<Text>` components.
+*/
+function Newline({ count = 1 }) {
+	return /* @__PURE__ */ jsx("ink-text", { children: "\n".repeat(count) });
+}
+//#endregion
+//#region src/components/Spacer.tsx
+/** @jsxImportSource react */
+/**
+A flexible space that expands along the major axis of its containing layout.
+
+It's useful as a shortcut for filling all the available space between elements.
+*/
+function Spacer() {
+	return /* @__PURE__ */ jsx(Box, { flexGrow: 1 });
+}
+//#endregion
+//#region src/virtual-scroll.ts
+const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
+const wholeRows = (value) => Math.max(0, Math.floor(value)) || 0;
+/**
+Compute which items intersect a viewport over a vertical stack of items.
+*/
+const virtualScrollWindow = (options) => {
+	const count = wholeRows(options.count);
+	const viewportHeight = wholeRows(options.viewportHeight);
+	const tops = [];
+	let totalHeight = 0;
+	for (let index = 0; index < count; index++) {
+		tops.push(totalHeight);
+		totalHeight += wholeRows(options.itemHeight(index));
+	}
+	const bottomOf = (index) => index + 1 < count ? tops[index + 1] : totalHeight;
+	const maxScrollTop = Math.max(0, totalHeight - viewportHeight);
+	let scrollTop = clamp(Math.floor(options.scrollTop) || 0, 0, maxScrollTop);
+	const focused = options.focusedIndex;
+	if (focused !== void 0 && Number.isInteger(focused) && focused >= 0 && focused < count) {
+		const top = tops[focused];
+		const bottom = bottomOf(focused);
+		if (top < scrollTop) scrollTop = top;
+		else if (bottom > scrollTop + viewportHeight) scrollTop = Math.min(top, bottom - viewportHeight);
+		scrollTop = clamp(scrollTop, 0, maxScrollTop);
+	}
+	const viewportBottom = scrollTop + viewportHeight;
+	let start = 0;
+	while (start < count && bottomOf(start) <= scrollTop) start++;
+	let end = start;
+	while (end < count && tops[end] < viewportBottom) end++;
+	return {
+		start,
+		end,
+		scrollTop,
+		maxScrollTop,
+		totalHeight,
+		offset: start < end ? tops[start] - scrollTop : 0,
+		hiddenAbove: scrollTop,
+		hiddenBelow: Math.max(0, totalHeight - viewportBottom)
+	};
+};
+//#endregion
+//#region src/hooks/use-virtual-scroll.ts
+/**
+A React hook that owns the scroll position of a windowed list and returns which
+items to render for it. The position is clamped to the scrollable range and,
+while `focusedIndex` is set, moved as little as necessary to keep that item
+fully visible. Render the items in `[start, end)` inside an `overflowY="hidden"`
+box of `viewportHeight` rows, shifted up by `offset` rows.
+
+`<VirtualList>` wraps this hook; use it directly to draw your own chrome such
+as overflow markers or a scrollbar around the window.
+
+@example
+```tsx
+import { Box, Text, useVirtualScroll } from "@alchemy.run/sigil";
+
+const Example = ({ lines, cursor }: { lines: string[]; cursor: number }) => {
+const { start, end, offset, hiddenAbove, hiddenBelow } = useVirtualScroll({
+count: lines.length,
+itemHeight: () => 1,
+viewportHeight: 10,
+focusedIndex: cursor,
+});
+
+return (
+<Box flexDirection="column">
+<Text dimColor>{hiddenAbove > 0 ? `↑ ${hiddenAbove} more` : ""}</Text>
+<Box flexDirection="column" height={10} overflowY="hidden">
+<Box flexDirection="column" flexShrink={0} marginTop={offset}>
+{lines.slice(start, end).map((line, index) => (
+<Text key={start + index} inverse={start + index === cursor}>
+{line}
+</Text>
+))}
+</Box>
+</Box>
+<Text dimColor>{hiddenBelow > 0 ? `↓ ${hiddenBelow} more` : ""}</Text>
+</Box>
+);
+};
+```
+*/
+const useVirtualScroll = (options) => {
+	const [position, setPosition] = useState(0);
+	const window = virtualScrollWindow({
+		...options,
+		scrollTop: position
+	});
+	useEffect(() => {
+		if (window.scrollTop !== position) setPosition(window.scrollTop);
+	}, [window.scrollTop, position]);
+	const scrollTo = useCallback((top) => {
+		setPosition(top);
+	}, []);
+	const scrollBy = useCallback((delta) => {
+		setPosition((current) => current + delta);
+	}, []);
+	return {
+		...window,
+		scrollTo,
+		scrollBy
+	};
+};
+//#endregion
+//#region src/components/VirtualList.tsx
+/** @jsxImportSource react */
+const rootOf = (node) => {
+	let current = node;
+	while (current?.parentNode) current = current.parentNode;
+	return current?.nodeName === "ink-root" ? current : void 0;
+};
+/**
+A vertically windowed list: only the items intersecting the viewport are
+rendered, inside a clipped box that scrolls by whole rows. Items may have
+different heights, and the item at the top edge may be partially visible.
+
+Until the first layout pass has measured the viewport, every item is rendered
+inside the clipped box so the first frame already looks right.
+*/
+function VirtualList({ items, itemHeight, renderItem, getKey, focusedIndex, height }) {
+	const ref = useRef(null);
+	const [measured, setMeasured] = useState();
+	const measure = () => {
+		const next = ref.current?.yogaNode?.getComputedHeight();
+		if (next !== void 0) setMeasured((previous) => previous === next ? previous : next);
+	};
+	useLayoutEffect(() => {
+		if (height === void 0) measure();
+	});
+	useEffect(() => {
+		if (height !== void 0) return;
+		const root = rootOf(ref.current);
+		return root ? addLayoutListener(root, measure) : void 0;
+	});
+	const viewportHeight = height ?? measured;
+	const windowed = viewportHeight !== void 0;
+	const window = useVirtualScroll({
+		count: items.length,
+		itemHeight: (index) => itemHeight(items[index], index),
+		viewportHeight: viewportHeight ?? 0,
+		focusedIndex: windowed ? focusedIndex : void 0
+	});
+	const start = windowed ? window.start : 0;
+	const end = windowed ? window.end : items.length;
+	const offset = windowed ? window.offset : 0;
+	return /* @__PURE__ */ jsx(Box, {
+		ref,
+		flexDirection: "column",
+		overflowY: "hidden",
+		...height === void 0 ? {
+			height: window.totalHeight,
+			minHeight: 0,
+			flexShrink: 1
+		} : {
+			height,
+			flexShrink: 0
+		},
+		children: /* @__PURE__ */ jsx(Box, {
+			flexDirection: "column",
+			flexShrink: 0,
+			marginTop: offset,
+			children: items.slice(start, end).map((item, sliceIndex) => {
+				const index = start + sliceIndex;
+				return /* @__PURE__ */ jsx(Box, {
+					flexDirection: "column",
+					flexShrink: 0,
+					children: renderItem(item, index)
+				}, getKey ? getKey(item, index) : index);
+			})
+		})
+	});
+}
+//#endregion
+//#region src/hooks/use-capabilities.ts
+/**
+Returns everything knowable about the terminal: size, identity, platform,
+color depth, theme, and feature support.
+
+A thin wrapper over the framework-free capabilities store (`getCapabilities`):
+environment-derived facts are available immediately; facts only the terminal
+itself can answer fill in after a lazy one-time query, and re-mounting
+consumers refreshes the dynamic facts (theme colors, pixel geometry).
+Re-renders on terminal resize and whenever query answers arrive.
+*/
+const useCapabilities = () => {
+	const { stdout } = useStdout();
+	const { stdin } = useStdinContext();
+	const store = getCapabilities(stdin, stdout);
+	const capabilities = useSyncExternalStore(store.subscribe, () => store.current);
+	useEffect(() => {
+		store.query();
+	}, [store]);
+	return capabilities;
+};
+/**
+Calls `onChange` whenever the terminal changes: resizes (including in-band
+pixel geometry), color scheme switches, window focus, and query answers
+arriving. The React wrapper over `capabilities.subscribe()` for side effects —
+for rendering, use `useCapabilities` instead.
+
+The callback always sees the latest render's closure and changing it does not
+resubscribe. Both the new and previous snapshot are passed, so handlers can
+react to the specific change:
+
+```tsx
+useCapabilitiesChange((next, previous) => {
+if (next.theme.appearance !== previous.theme.appearance) {
+// re-theme
+}
+});
+```
+*/
+const useCapabilitiesChange = (onChange) => {
+	const { stdout } = useStdout();
+	const { stdin } = useStdinContext();
+	const store = getCapabilities(stdin, stdout);
+	const handleChange = useEffectEvent(onChange);
+	useEffect(() => {
+		let previous = store.current;
+		const unsubscribe = store.subscribe((next) => {
+			const before = previous;
+			previous = next;
+			handleChange(next, before);
+		});
+		store.query();
+		return unsubscribe;
+	}, [store]);
+};
+//#endregion
+//#region src/hooks/use-paste.ts
+/**
+A React hook that calls `handler` whenever the user pastes text in the terminal. Bracketed paste mode (`\x1b[?2004h`) is automatically enabled while the hook is active, so pasted text arrives as a single string rather than being misinterpreted as individual key presses.
+
+`usePaste` and `useInput` can be used together in the same component. They operate on separate event channels, so paste content is never forwarded to `useInput` handlers when `usePaste` is active.
+
+```
+import {useInput, usePaste} from 'ink';
+
+const MyInput = () => {
+useInput((input, key) => {
+// Only receives typed characters and key events, not pasted text.
+if (key.return) {
+// Submit
+}
+});
+
+usePaste((text) => {
+// Receives the full pasted string, including newlines.
+console.log('Pasted:', text);
+});
+
+return …
+};
+```
+*/
+const usePaste = (handler, options = {}) => {
+	const { setRawMode, setBracketedPasteMode, internal_eventEmitter } = useStdinContext();
+	useEffect(() => {
+		if (options.isActive === false) return;
+		setRawMode(true);
+		setBracketedPasteMode(true);
+		return () => {
+			setRawMode(false);
+			setBracketedPasteMode(false);
+		};
+	}, [
+		options.isActive,
+		setRawMode,
+		setBracketedPasteMode
+	]);
+	const handlePaste = useEffectEvent((text) => {
+		reconciler.discreteUpdates(() => {
+			handler(text);
+		});
+	});
+	useEffect(() => {
+		if (options.isActive === false) return;
+		internal_eventEmitter.on("paste", handlePaste);
+		return () => {
+			internal_eventEmitter.removeListener("paste", handlePaste);
+		};
+	}, [options.isActive, internal_eventEmitter]);
+};
+//#endregion
+//#region src/hooks/use-app.ts
+/**
+A React hook that returns app lifecycle methods like `exit()` and `waitUntilRenderFlush()`.
+*/
+const useApp = () => useContext(AppContext);
+//#endregion
+//#region src/hooks/use-stderr.ts
+/**
+A React hook that returns the stderr stream.
+*/
+const useStderr = () => useContext(StderrContext);
+//#endregion
+//#region src/hooks/use-focus-manager.ts
+/**
+A React hook that returns methods to enable or disable focus management for all components or manually switch focus to the next or previous components.
+*/
+const useFocusManager = () => {
+	const focusContext = useContext(FocusContext);
+	return {
+		enableFocus: focusContext.enableFocus,
+		disableFocus: focusContext.disableFocus,
+		focusNext: focusContext.focusNext,
+		focusPrevious: focusContext.focusPrevious,
+		focus: focusContext.focus,
+		activeId: focusContext.activeId
+	};
+};
+//#endregion
+//#region src/hooks/use-is-screen-reader-enabled.ts
+/**
+A React hook that returns whether a screen reader is enabled.
+This is useful when you want to render different output for screen readers.
+*/
+const useIsScreenReaderEnabled = () => {
+	const { isScreenReaderEnabled } = useContext(accessibilityContext);
+	return isScreenReaderEnabled;
+};
+//#endregion
+//#region src/hooks/use-cursor.ts
+/**
+A React hook that returns methods to control the terminal cursor position.
+
+Setting a cursor position makes the cursor visible at the specified coordinates (relative to the Ink output origin). This is useful for IME (Input Method Editor) support, where the composing character is displayed at the cursor location.
+
+Pass `undefined` to hide the cursor.
+*/
+const useCursor = () => {
+	const context = useContext(CursorContext);
+	const positionRef = useRef(void 0);
+	const setCursorPosition = useCallback((position) => {
+		positionRef.current = position;
+	}, []);
+	useInsertionEffect(() => {
+		context.setCursorPosition(positionRef.current);
+		return () => {
+			context.setCursorPosition(void 0);
+		};
+	});
+	return { setCursorPosition };
+};
+//#endregion
+//#region src/hooks/use-animation.ts
+const defaultAnimationInterval = 100;
+const maximumTimerInterval = 2147483647;
+const zeroAnimState = {
+	frame: 0,
+	time: 0,
+	delta: 0
+};
+/**
+A React hook that drives animations. Returns a frame counter, elapsed time, frame delta, and a reset function. All animations share a single timer internally, so multiple animated components consolidate into one render cycle.
+
+@example
+```
+import {Text, useAnimation} from 'ink';
+
+const Spinner = () => {
+const {frame} = useAnimation({interval: 80});
+const characters = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+return <Text>{characters[frame % characters.length]}</Text>;
+};
+```
+*/
+function useAnimation(options) {
+	const { interval = defaultAnimationInterval, isActive = true } = options ?? {};
+	const safeInterval = normalizeAnimationInterval(interval);
+	const { subscribe, renderThrottleMs } = useContext(animationContext);
+	const [resetKey, setResetKey] = useState(0);
+	const [animState, setAnimState] = useState(zeroAnimState);
+	const nextRenderTimeRef = useRef(0);
+	const lastRenderTimeRef = useRef(0);
+	const previousOptionsRef = useRef({
+		isActive,
+		safeInterval,
+		resetKey
+	});
+	const previousOptions = previousOptionsRef.current;
+	const shouldReset = isActive && (safeInterval !== previousOptions.safeInterval || !previousOptions.isActive || resetKey !== previousOptions.resetKey);
+	const reset = useCallback(() => {
+		setResetKey((k) => k + 1);
+	}, []);
+	useLayoutEffect(() => {
+		if (!isActive) return;
+		setAnimState(zeroAnimState);
+		let startTime = 0;
+		const { startTime: subscriberStartTime, unsubscribe } = subscribe((currentTime) => {
+			if (renderThrottleMs > 0 && currentTime < nextRenderTimeRef.current) return;
+			const elapsed = currentTime - startTime;
+			const nextDelta = currentTime - lastRenderTimeRef.current;
+			lastRenderTimeRef.current = currentTime;
+			nextRenderTimeRef.current = currentTime + renderThrottleMs;
+			setAnimState({
+				frame: Math.floor(elapsed / safeInterval),
+				time: elapsed,
+				delta: nextDelta
+			});
+		}, safeInterval);
+		startTime = subscriberStartTime;
+		lastRenderTimeRef.current = subscriberStartTime;
+		nextRenderTimeRef.current = startTime + renderThrottleMs;
+		return unsubscribe;
+	}, [
+		safeInterval,
+		isActive,
+		subscribe,
+		renderThrottleMs,
+		resetKey
+	]);
+	useLayoutEffect(() => {
+		previousOptionsRef.current = {
+			isActive,
+			safeInterval,
+			resetKey
+		};
+	}, [
+		isActive,
+		safeInterval,
+		resetKey
+	]);
+	if (shouldReset) return {
+		...zeroAnimState,
+		reset
+	};
+	return {
+		...animState,
+		reset
+	};
+}
+function normalizeAnimationInterval(interval) {
+	if (!Number.isFinite(interval)) return defaultAnimationInterval;
+	return Math.min(maximumTimerInterval, Math.max(1, interval));
+}
+//#endregion
+//#region src/hooks/use-terminal-osc.ts
+const useProgress = ({ state, value }) => {
+	const terminal = useContext(TerminalOscContext);
+	const owner = useRef(void 0);
+	owner.current ??= Symbol("terminal-progress");
+	useEffect(() => {
+		terminal.publishProgress(owner.current, state, value);
+	}, [
+		state,
+		terminal,
+		value
+	]);
+	useEffect(() => {
+		return () => {
+			terminal.publishProgress(owner.current, "inactive");
+		};
+	}, [terminal]);
+};
+const useClipboard = () => {
+	const terminal = useContext(TerminalOscContext);
+	return useCallback((text, selection) => terminal.copyToClipboard(text, selection), [terminal]);
+};
+const useTitle = (title) => {
+	const terminal = useContext(TerminalOscContext);
+	const owner = useRef(void 0);
+	owner.current ??= Symbol("terminal-title");
+	useEffect(() => {
+		terminal.publishTitle(owner.current, title);
+	}, [terminal, title]);
+	useEffect(() => () => terminal.publishTitle(owner.current, void 0), [terminal]);
+};
+const useWorkingDirectory = (directory) => {
+	const terminal = useContext(TerminalOscContext);
+	useEffect(() => {
+		terminal.setWorkingDirectory(directory);
+	}, [directory, terminal]);
+};
+const useNotification = () => {
+	const terminal = useContext(TerminalOscContext);
+	return useCallback((title) => terminal.notify(title), [terminal]);
+};
+const usePointerShape = (shape) => {
+	const terminal = useContext(TerminalOscContext);
+	useEffect(() => {
+		terminal.setPointerShape(shape);
+	}, [shape, terminal]);
+};
+//#endregion
+//#region src/hooks/use-window-size.ts
+/**
+A React hook that returns the current terminal window dimensions and re-renders the component whenever the terminal is resized.
+
+Reads the capabilities store, so on terminals that send in-band size reports
+(mode 2048) the dimensions are the emulator's own, arriving after it has
+rewrapped its screen; elsewhere they are the stream's `columns`/`rows`.
+Subscribing to dimensions does not initiate capability queries. In-band reports
+are used when another consumer has explicitly enabled capability discovery.
+*/
+const useWindowSize = () => {
+	const { stdin } = useStdinContext();
+	const { stdout } = useStdout();
+	const store = getCapabilities(stdin, stdout);
+	const { size } = useSyncExternalStore(store.subscribe, () => store.current);
+	return useMemo(() => ({
+		columns: size.columns,
+		rows: size.rows
+	}), [size.columns, size.rows]);
+};
+//#endregion
+//#region src/hooks/use-box-metrics.ts
+const emptyMetrics = {
+	width: 0,
+	height: 0,
+	left: 0,
+	top: 0
+};
+const findRootNode = (node) => {
+	if (!node) return;
+	if (!node.parentNode) return node.nodeName === "ink-root" ? node : void 0;
+	return findRootNode(node.parentNode);
+};
+/**
+A React hook that returns the current layout metrics for a tracked box element.
+It updates when layout changes (for example terminal resize, sibling/content changes, or position changes).
+
+The hook returns `{width: 0, height: 0, left: 0, top: 0}` until the first layout pass completes. It also returns zeros when the tracked ref is detached.
+
+Use `hasMeasured` to detect when the currently tracked element has been measured.
+
+@example
+```tsx
+import {useRef} from 'react';
+import {Box, Text, useBoxMetrics} from 'ink';
+
+const Example = () => {
+const ref = useRef(null);
+const {width, height, left, top, hasMeasured} = useBoxMetrics(ref);
+return (
+<Box ref={ref}>
+<Text>
+{hasMeasured ? `${width}x${height} at ${left},${top}` : 'Measuring...'}
+</Text>
+</Box>
+);
+};
+```
+*/
+const useBoxMetrics = (ref) => {
+	const [metrics, setMetrics] = useState(emptyMetrics);
+	const [hasMeasured, setHasMeasured] = useState(false);
+	const updateMetrics = useCallback(() => {
+		const layout = ref.current?.yogaNode?.getComputedLayout() ?? emptyMetrics;
+		setMetrics((previousMetrics) => {
+			return previousMetrics.width !== layout.width || previousMetrics.height !== layout.height || previousMetrics.left !== layout.left || previousMetrics.top !== layout.top ? layout : previousMetrics;
+		});
+		setHasMeasured(Boolean(ref.current));
+	}, [ref]);
+	useEffect(updateMetrics);
+	useEffect(() => {
+		const rootNode = findRootNode(ref.current);
+		if (!rootNode) return;
+		return addLayoutListener(rootNode, updateMetrics);
+	});
+	return useMemo(() => ({
+		...metrics,
+		hasMeasured
+	}), [metrics, hasMeasured]);
+};
+//#endregion
+//#region src/measure-element.ts
+/**
+Measure the layout metrics of a particular `<Box>` element.
+Returns an object with `x`, `y`, `width`, and `height` properties.
+
+`x` and `y` are the element's position within the live layout region, computed by walking up the layout tree and accumulating each ancestor's offset. These are layout-tree coordinates, not terminal viewport coordinates. To compare them with mouse events, convert the event coordinates using the live region's viewport position. This is necessary even in alternate-screen mode when output, such as `<Static>` content, appears above the live region.
+
+Note: `measureElement()` returns `{x: 0, y: 0, width: 0, height: 0}` when called during render (before layout is calculated). Call it from post-render code, such as `useEffect`, `useLayoutEffect`, input handlers, or timer callbacks. When content changes, pass the relevant dependency to your effect so it re-measures after each update.
+*/
+const measureElement = (node) => {
+	const { yogaNode } = node;
+	if (!yogaNode) return {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	};
+	let x = yogaNode.getComputedLeft();
+	let y = yogaNode.getComputedTop();
+	let current = node.parentNode;
+	while (current) {
+		if (current.yogaNode) {
+			x += current.yogaNode.getComputedLeft();
+			y += current.yogaNode.getComputedTop();
+		}
+		current = current.parentNode;
+	}
+	return {
+		x,
+		y,
+		width: yogaNode.getComputedWidth(),
+		height: yogaNode.getComputedHeight()
+	};
+};
+//#endregion
+export { AnsiText, Box, Hyperlink, Newline, Spacer, Static, Text, Transform, VirtualList, applyTerminalQuery, capabilities, createSupportsColor, detectCapabilities, detectColorLevel, detectHyperlinkSupport, detectTerminal, detectUnicodeSupport, getCapabilities, getTerminalQuery, kittyFlags, kittyModifiers, measureElement, queryTerminal, refreshTerminalQuery, render, renderToString, useAnimation, useApp, useBoxMetrics, useCapabilities, useCapabilitiesChange, useClipboard, useCursor, useFocus, useFocusManager, useInput, useIsScreenReaderEnabled, useNotification, usePaste, usePointerShape, useProgress, useStderr, useStdin, useStdout, useTitle, useVirtualScroll, useWindowSize, useWorkingDirectory };