@alchemy.run/sigil 0.0.0-alpha.3 → 0.0.0-alpha.5

package/dist/index.js

@@ -1,198 +1,33 @@
-import { At as esu, Ft as pasteStart, Pt as pasteEnd, b as wrapAnsi, ct as CSI, d as styledCharsFromTokens, f as styledCharsToString, g as chalk, h as widestLine, mt as bsu, n as sliceAnsi, p as tokenize, pt as ansiEscapes, t as cliTruncate, v as cliCursor, x as stringWidth, y as signalExit } from "./truncate-CBiyyZzw.js";
+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-C2sciZOo.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, c as signalExit, i as detectHyperlinkSupport, n as detectCapabilities, o as detectUnicodeSupport, r as detectColorLevel, s as terminalSize, t as createSupportsColor } from "./detect-BuTXtY6e.js";
+import { u as cliCursor } from "./osc-CCH7xDoS.js";
+import { a as registerTerminalIntegration, c as ensureTerminalQuery, d as queryTerminal, f as refreshTerminalQuery, i as getCapabilities, l as getTerminalQuery, o as getRawModeStream, r as capabilities, s as applyTerminalQuery, u as getTerminalQueryPromise } from "./color-policy-SVj1pYTA.js";
+import { a as buildCursorSuffix, c as hideCursorEscape, i as buildCursorOnlySequence, o as buildReturnToBottomPrefix, s as cursorPositionChanged, t as TerminalSession } from "./session-BJmzX2NJ.js";
 import { t as Yoga } from "./yoga-5jKhYCJC.js";
-import process, { cwd } from "node:process";
+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-BOh__-65.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 { ConcurrentRoot, DefaultEventPriority, LegacyRoot, NoEventPriority } from "react-reconciler/constants.js";
-import { PureComponent, createContext, forwardRef, useCallback, useContext, useEffect, useEffectEvent, useInsertionEffect, useLayoutEffect, useMemo, useRef, useState, version } from "react";
+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 * as fs$1 from "node:fs";
-import fs from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import { cwd } from "node:process";
 import { jsx, jsxs } from "react/jsx-runtime";
-import tty from "node:tty";
 import { Console } from "node:console";
-import createReconciler from "react-reconciler";
-import * as Scheduler from "scheduler";
-//#region src/auto-bind.ts
-const getAllProperties = (object) => {
-	const properties = [];
-	let current = object;
-	do {
-		for (const key of Reflect.ownKeys(current)) properties.push([current, key]);
-		current = Reflect.getPrototypeOf(current);
-	} while (current && current !== Object.prototype);
-	return properties;
-};
-const autoBind = (self) => {
-	for (const [object, key] of getAllProperties(self.constructor.prototype)) {
-		if (key === "constructor") continue;
-		const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
-		if (descriptor && typeof descriptor.value === "function") {
-			const value = self[key];
-			if (typeof value === "function") self[key] = value.bind(self);
-		}
-	}
-	return self;
-};
-//#endregion
-//#region src/components/AccessibilityContext.ts
-const accessibilityContext = createContext({ isScreenReaderEnabled: false });
-//#endregion
-//#region src/input-parser.ts
-const escape$1 = "\x1B";
-const isCsiParameterByte = (byte) => {
-	return byte >= 48 && byte <= 63;
-};
-const isCsiIntermediateByte = (byte) => {
-	return byte >= 32 && byte <= 47;
-};
-const isCsiFinalByte = (byte) => {
-	return byte >= 64 && byte <= 126;
-};
-const parseCsiSequence = (input, startIndex, prefixLength) => {
-	const csiPayloadStart = startIndex + prefixLength + 1;
-	let index = csiPayloadStart;
-	for (; index < input.length; index++) {
-		const byte = input.codePointAt(index);
-		if (byte === void 0) return "pending";
-		if (isCsiParameterByte(byte) || isCsiIntermediateByte(byte)) continue;
-		if (byte === 91 && index === csiPayloadStart) continue;
-		if (isCsiFinalByte(byte)) return {
-			sequence: input.slice(startIndex, index + 1),
-			nextIndex: index + 1
-		};
-		return;
-	}
-	return "pending";
-};
-const parseSs3Sequence = (input, startIndex, prefixLength) => {
-	const nextIndex = startIndex + prefixLength + 2;
-	if (nextIndex > input.length) return "pending";
-	const finalByte = input.codePointAt(nextIndex - 1);
-	if (finalByte === void 0 || !isCsiFinalByte(finalByte)) return;
-	return {
-		sequence: input.slice(startIndex, nextIndex),
-		nextIndex
-	};
-};
-const parseControlSequence = (input, startIndex, prefixLength) => {
-	const sequenceType = input[startIndex + prefixLength];
-	if (sequenceType === void 0) return "pending";
-	if (sequenceType === "[") return parseCsiSequence(input, startIndex, prefixLength);
-	if (sequenceType === "O") return parseSs3Sequence(input, startIndex, prefixLength);
-};
-const parseEscapedCodePoint = (input, escapeIndex) => {
-	const nextCodePoint = input.codePointAt(escapeIndex + 1);
-	const nextCodePointLength = nextCodePoint !== void 0 && nextCodePoint > 65535 ? 2 : 1;
-	const nextIndex = escapeIndex + 1 + nextCodePointLength;
-	return {
-		sequence: input.slice(escapeIndex, nextIndex),
-		nextIndex
-	};
-};
-const parseEscapeSequence = (input, escapeIndex) => {
-	if (escapeIndex === input.length - 1) return "pending";
-	if (input[escapeIndex + 1] === escape$1) {
-		if (escapeIndex + 2 >= input.length) return "pending";
-		const doubleEscapeSequence = parseControlSequence(input, escapeIndex, 2);
-		if (doubleEscapeSequence === "pending") return "pending";
-		if (doubleEscapeSequence) return doubleEscapeSequence;
-		return {
-			sequence: input.slice(escapeIndex, escapeIndex + 2),
-			nextIndex: escapeIndex + 2
-		};
-	}
-	const controlSequence = parseControlSequence(input, escapeIndex, 1);
-	if (controlSequence === "pending") return "pending";
-	if (controlSequence) return controlSequence;
-	return parseEscapedCodePoint(input, escapeIndex);
-};
-/**
-Split a chunk of non-escape text so that backspace bytes (`0x7F` and `0x08`) become individual events. When a user holds the backspace key, the terminal sends repeated bytes in a single stdin chunk. Without splitting, `parseKeypress` receives the multi-byte string and fails to recognize it as a key event, corrupting the input state.
-
-Other control characters like `\r` and `\t` are NOT split because they can legitimately appear inside pasted text.
-*/
-const splitBackspaceBytes = (text, events) => {
-	let textSegmentStart = 0;
-	for (let index = 0; index < text.length; index++) {
-		const character = text[index];
-		if (character === "" || character === "\b") {
-			if (index > textSegmentStart) events.push(text.slice(textSegmentStart, index));
-			events.push(character);
-			textSegmentStart = index + 1;
-		}
-	}
-	if (textSegmentStart < text.length) events.push(text.slice(textSegmentStart));
-};
-const parseKeypresses = (input) => {
-	const events = [];
-	let index = 0;
-	const pendingFrom = (pendingStartIndex) => ({
-		events,
-		pending: input.slice(pendingStartIndex)
-	});
-	while (index < input.length) {
-		const escapeIndex = input.indexOf(escape$1, index);
-		if (escapeIndex === -1) {
-			splitBackspaceBytes(input.slice(index), events);
-			return {
-				events,
-				pending: ""
-			};
-		}
-		if (escapeIndex > index) splitBackspaceBytes(input.slice(index, escapeIndex), events);
-		const parsedEscapeSequence = parseEscapeSequence(input, escapeIndex);
-		if (parsedEscapeSequence === "pending") return pendingFrom(escapeIndex);
-		if (parsedEscapeSequence.sequence === pasteStart) {
-			const afterStart = parsedEscapeSequence.nextIndex;
-			const endIndex = input.indexOf(pasteEnd, afterStart);
-			if (endIndex === -1) return pendingFrom(escapeIndex);
-			events.push({ paste: input.slice(afterStart, endIndex) });
-			index = endIndex + pasteEnd.length;
-			continue;
-		}
-		events.push(parsedEscapeSequence.sequence);
-		index = parsedEscapeSequence.nextIndex;
-	}
-	return {
-		events,
-		pending: ""
-	};
-};
-const createInputParser = () => {
-	let pending = "";
-	return {
-		push(chunk) {
-			const parsedInput = parseKeypresses(pending + chunk);
-			pending = parsedInput.pending;
-			return parsedInput.events;
-		},
-		hasPendingEscape() {
-			return pending.startsWith(escape$1) && !pending.startsWith(pasteStart) && pending !== pasteStart.slice(0, -1);
-		},
-		flushPendingEscape() {
-			if (!pending.startsWith(escape$1)) return;
-			const pendingEscape = pending;
-			pending = "";
-			return pendingEscape;
-		},
-		reset() {
-			pending = "";
-		}
-	};
-};
-//#endregion
-//#region src/stream.ts
-const isTty = (stream) => {
-	return "isTTY" in stream && stream.isTTY === true;
-};
-const isRawModeStream = (stdin) => {
-	return isTty(stdin) && "setRawMode" in stdin && typeof stdin.setRawMode === "function";
-};
-const getRawModeStream = (stdin) => {
-	if (!isRawModeStream(stdin)) return;
-	return stdin;
-};
-//#endregion
 //#region src/components/AnimationContext.ts
 const animationContext = createContext({
 	renderThrottleMs: 0,
@@ -247,6 +82,119 @@ const codeExcerpt = (source, line, options = {}) => {
 	}));
 };
 //#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 (.*?)]$/;
@@ -308,110 +256,6 @@ const parseStackLine = (line) => {
 	return result;
 };
 //#endregion
-//#region src/components/BackgroundContext.ts
-const backgroundContext = createContext(void 0);
-//#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.
-*/
-const Box = forwardRef(({ children, backgroundColor, "aria-label": ariaLabel, "aria-hidden": ariaHidden, "aria-role": role, "aria-state": ariaState, ...style }, ref) => {
-	const { isScreenReaderEnabled } = useContext(accessibilityContext);
-	const label = ariaLabel ? /* @__PURE__ */ jsx("ink-text", { children: ariaLabel }) : void 0;
-	if (isScreenReaderEnabled && ariaHidden) return null;
-	const boxElement = /* @__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
-	});
-	if (backgroundColor) return /* @__PURE__ */ jsx(backgroundContext.Provider, {
-		value: backgroundColor,
-		children: boxElement
-	});
-	return boxElement;
-});
-Box.displayName = "Box";
-//#endregion
-//#region src/colorize.ts
-const rgbRegex = /^rgb\(\s?(\d+),\s?(\d+),\s?(\d+)\s?\)$/;
-const ansiRegex = /^ansi256\(\s?(\d+)\s?\)$/;
-const isNamedColor = (color) => {
-	return color in chalk;
-};
-const colorize = (str, color, type) => {
-	if (!color) return str;
-	if (isNamedColor(color)) {
-		if (type === "foreground") return chalk[color](str);
-		const methodName = `bg${color[0].toUpperCase() + color.slice(1)}`;
-		return chalk[methodName](str);
-	}
-	if (color.startsWith("#")) return type === "foreground" ? chalk.hex(color)(str) : chalk.bgHex(color)(str);
-	if (color.startsWith("ansi256")) {
-		const matches = ansiRegex.exec(color);
-		if (!matches) return str;
-		const value = Number(matches[1]);
-		return type === "foreground" ? chalk.ansi256(value)(str) : chalk.bgAnsi256(value)(str);
-	}
-	if (color.startsWith("rgb")) {
-		const matches = rgbRegex.exec(color);
-		if (!matches) return str;
-		const firstValue = Number(matches[1]);
-		const secondValue = Number(matches[2]);
-		const thirdValue = Number(matches[3]);
-		return type === "foreground" ? chalk.rgb(firstValue, secondValue, thirdValue)(str) : chalk.bgRgb(firstValue, secondValue, thirdValue)(str);
-	}
-	return str;
-};
-//#endregion
-//#region src/components/Text.tsx
-/** @jsxImportSource react */
-/**
-This component can display text and change its style to make it bold, underlined, italic, or strikethrough.
-*/
-function Text({ color, backgroundColor, dimColor = false, bold = false, italic = false, underline = false, strikethrough = false, inverse = false, wrap = "wrap", children, "aria-label": ariaLabel, "aria-hidden": ariaHidden = false }) {
-	const { isScreenReaderEnabled } = useContext(accessibilityContext);
-	const inheritedBackgroundColor = useContext(backgroundContext);
-	const childrenOrAriaLabel = isScreenReaderEnabled && ariaLabel ? ariaLabel : children;
-	if (childrenOrAriaLabel === void 0 || childrenOrAriaLabel === null) return null;
-	const transform = (text) => {
-		if (dimColor) text = chalk.dim(text);
-		if (color) text = colorize(text, color, "foreground");
-		const effectiveBackgroundColor = backgroundColor ?? inheritedBackgroundColor;
-		if (effectiveBackgroundColor) text = colorize(text, effectiveBackgroundColor, "background");
-		if (bold) text = chalk.bold(text);
-		if (italic) text = chalk.italic(text);
-		if (underline) text = chalk.underline(text);
-		if (strikethrough) text = chalk.strikethrough(text);
-		if (inverse) text = chalk.inverse(text);
-		return text;
-	};
-	if (isScreenReaderEnabled && ariaHidden) return null;
-	return /* @__PURE__ */ jsx("ink-text", {
-		style: {
-			flexGrow: 0,
-			flexShrink: 1,
-			flexDirection: "row",
-			textWrap: wrap
-		},
-		internal_transform: transform,
-		children: childrenOrAriaLabel
-	});
-}
-//#endregion
 //#region src/components/ErrorOverview.tsx
 /** @jsxImportSource react */
 const cleanupPath = (path) => {
@@ -424,8 +268,8 @@ function ErrorOverview({ error }) {
 	let excerpt;
 	let lineWidth = 0;
 	const stackLineCounts = /* @__PURE__ */ new Map();
-	if (filePath && origin?.line && fs$1.existsSync(filePath)) {
-		const sourceCode = fs$1.readFileSync(filePath, "utf8");
+	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);
 	}
@@ -542,21 +386,6 @@ var ErrorBoundary = class extends PureComponent {
 	}
 };
 //#endregion
-//#region src/components/FocusContext.ts
-const FocusContext = createContext({
-	activeId: void 0,
-	add() {},
-	remove() {},
-	activate() {},
-	deactivate() {},
-	enableFocus() {},
-	disableFocus() {},
-	focusNext() {},
-	focusPrevious() {},
-	focus() {}
-});
-FocusContext.displayName = "InternalFocusContext";
-//#endregion
 //#region src/components/StderrContext.ts
 /**
 `StderrContext` is a React context that exposes the stderr stream.
@@ -567,20 +396,6 @@ const StderrContext = createContext({
 });
 StderrContext.displayName = "InternalStderrContext";
 //#endregion
-//#region src/components/StdinContext.ts
-/**
-`StdinContext` is a React context that exposes the input stream.
-*/
-const StdinContext = createContext({
-	stdin: process.stdin,
-	internal_eventEmitter: new EventEmitter(),
-	setRawMode() {},
-	setBracketedPasteMode() {},
-	isRawModeSupported: false,
-	internal_exitOnCtrlC: true
-});
-StdinContext.displayName = "InternalStdinContext";
-//#endregion
 //#region src/components/StdoutContext.ts
 /**
 `StdoutContext` is a React context that exposes the stdout stream where Ink renders your app.
@@ -596,7 +411,7 @@ StdoutContext.displayName = "InternalStdoutContext";
 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 }) {
+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([]);
@@ -609,7 +424,6 @@ function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, ex
 	const internal_eventEmitter = useRef(new EventEmitter());
 	internal_eventEmitter.current.setMaxListeners(Infinity);
 	const readableListenerRef = useRef(void 0);
-	const inputParserRef = useRef(createInputParser());
 	const pendingInputFlushRef = useRef(void 0);
 	const pendingInputFlushDelayMilliseconds = 20;
 	const clearPendingInputFlush = useCallback(() => {
@@ -675,10 +489,14 @@ function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, ex
 		readableListenerRef.current = void 0;
 	}, [stdin]);
 	const clearInputState = useCallback(() => {
-		inputParserRef.current.reset();
+		terminalInput.reset();
 		clearPendingInputFlush();
 		detachReadableListener();
-	}, [clearPendingInputFlush, detachReadableListener]);
+	}, [
+		clearPendingInputFlush,
+		detachReadableListener,
+		terminalInput
+	]);
 	const disableRawMode = useCallback(() => {
 		if (!rawModeStdin) return;
 		pendingDisableRawModeRef.current = false;
@@ -714,16 +532,20 @@ function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, ex
 		clearPendingInputFlush();
 		pendingInputFlushRef.current = setTimeout(() => {
 			pendingInputFlushRef.current = void 0;
-			const pendingEscape = inputParserRef.current.flushPendingEscape();
+			const pendingEscape = terminalInput.flushPendingEscape();
 			if (!pendingEscape) return;
 			emitInput(pendingEscape);
 		}, pendingInputFlushDelayMilliseconds);
-	}, [clearPendingInputFlush, emitInput]);
+	}, [
+		clearPendingInputFlush,
+		emitInput,
+		terminalInput
+	]);
 	const handleReadable = useCallback(() => {
 		clearPendingInputFlush();
 		let chunk;
 		while ((chunk = stdin.read()) !== null) {
-			const inputEvents = inputParserRef.current.push(chunk);
+			const inputEvents = terminalInput.push(chunk);
 			for (const event of inputEvents) if (typeof event === "string") emitInput(event);
 			else {
 				if (internal_eventEmitter.current.listenerCount("paste") === 0) {
@@ -733,12 +555,13 @@ function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, ex
 				internal_eventEmitter.current.emit("paste", event.paste);
 			}
 		}
-		if (inputParserRef.current.hasPendingEscape()) schedulePendingInputFlush();
+		if (terminalInput.hasPendingEscape()) schedulePendingInputFlush();
 	}, [
 		stdin,
 		emitInput,
 		clearPendingInputFlush,
-		schedulePendingInputFlush
+		schedulePendingInputFlush,
+		terminalInput
 	]);
 	const attachReadableListener = useCallback(() => {
 		if (readableListenerRef.current) return;
@@ -780,6 +603,49 @@ function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, ex
 		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 {
+			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) {
@@ -1053,844 +919,21 @@ function App({ children, stdin, stdout, stderr, writeToStdout, writeToStderr, ex
 }
 App.displayName = "InternalApp";
 //#endregion
-//#region src/cursor-position.ts
-const showCursorEscape = ansiEscapes.cursorShow;
-const hideCursorEscape = ansiEscapes.cursorHide;
-/**
-Compare two cursor positions. Returns true if they differ.
-*/
-const cursorPositionChanged = (a, b) => a?.x !== b?.x || a?.y !== b?.y;
-/**
-Build escape sequence to move cursor from the bottom of the output to the target position and show it.
-
-`bottomLine` is the row the renderer left the cursor on, counted from the top of the output.
-That is always `lines.length - 1` for `lines = str.split('\n')`, whether or not the output ends
-with a newline:
-
-- With a trailing newline, `split` yields one extra empty element and the renderer stops just
-past the last visible line — which is `lines.length - 1`.
-- Without one, there is no extra element and the renderer deliberately stops on the last visible
-line instead of moving past it — which is also `lines.length - 1`.
-
-This is the same row basis `buildReturnToBottom` measures from, so the two stay in step.
-*/
-const buildCursorSuffix = (bottomLine, cursorPosition) => {
-	if (!cursorPosition) return "";
-	const moveUp = bottomLine - cursorPosition.y;
-	return (moveUp > 0 ? ansiEscapes.cursorUp(moveUp) : "") + ansiEscapes.cursorTo(cursorPosition.x) + showCursorEscape;
-};
-/**
-Build escape sequence to move cursor from previousCursorPosition back to the bottom of output.
-This must be done before eraseLines or any operation that assumes cursor is at the bottom.
-*/
-const buildReturnToBottom = (previousLineCount, previousCursorPosition) => {
-	if (!previousCursorPosition) return "";
-	const down = previousLineCount - 1 - previousCursorPosition.y;
-	return (down > 0 ? ansiEscapes.cursorDown(down) : "") + ansiEscapes.cursorTo(0);
-};
-/**
-Build the escape sequence for cursor-only updates (output unchanged, cursor moved).
-Hides cursor if it was previously shown, returns to bottom, then repositions.
-
-`buildReturnToBottom` has just placed the cursor on row `previousLineCount - 1`, so the
-suffix measures from there rather than recomputing the row from the output.
-*/
-const buildCursorOnlySequence = (input) => {
-	const hidePrefix = input.cursorWasShown ? hideCursorEscape : "";
-	const returnToBottom = buildReturnToBottom(input.previousLineCount, input.previousCursorPosition);
-	const cursorSuffix = buildCursorSuffix(input.previousLineCount - 1, input.cursorPosition);
-	return hidePrefix + returnToBottom + cursorSuffix;
-};
-/**
-Build the prefix that hides cursor and returns to bottom before erasing or rewriting.
-Returns empty string if cursor was not shown.
-*/
-const buildReturnToBottomPrefix = (cursorWasShown, previousLineCount, previousCursorPosition) => {
-	if (!cursorWasShown) return "";
-	return hideCursorEscape + buildReturnToBottom(previousLineCount, previousCursorPosition);
-};
-//#endregion
-//#region src/quick-lru.ts
-var QuickLru = class {
-	#size = 0;
-	#cache = /* @__PURE__ */ new Map();
-	#oldCache = /* @__PURE__ */ new Map();
-	#maxSize;
-	constructor({ maxSize }) {
-		if (!(maxSize && maxSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
-		this.#maxSize = maxSize;
-	}
-	get size() {
-		let oldCacheSize = 0;
-		for (const key of this.#oldCache.keys()) if (!this.#cache.has(key)) oldCacheSize++;
-		return Math.min(this.#size + oldCacheSize, this.#maxSize);
-	}
-	get(key) {
-		if (this.#cache.has(key)) return this.#cache.get(key);
-		if (this.#oldCache.has(key)) {
-			const value = this.#oldCache.get(key);
-			this.#oldCache.delete(key);
-			this.#set(key, value);
-			return value;
-		}
-	}
-	set(key, value) {
-		if (this.#cache.has(key)) this.#cache.set(key, value);
-		else this.#set(key, value);
-		return this;
-	}
-	has(key) {
-		return this.#cache.has(key) || this.#oldCache.has(key);
-	}
-	delete(key) {
-		const deleted = this.#cache.delete(key);
-		if (deleted) this.#size--;
-		return this.#oldCache.delete(key) || deleted;
-	}
-	clear() {
-		this.#cache.clear();
-		this.#oldCache.clear();
-		this.#size = 0;
-	}
-	#set(key, value) {
-		this.#cache.set(key, value);
-		this.#size++;
-		if (this.#size >= this.#maxSize) {
-			this.#size = 0;
-			this.#oldCache = this.#cache;
-			this.#cache = /* @__PURE__ */ new Map();
-		}
-	}
-};
-//#endregion
-//#region src/measure-text.ts
-const cache = new QuickLru({ maxSize: 4096 });
-const measureText = (text) => {
-	if (text.length === 0) return {
-		width: 0,
-		height: 0
-	};
-	const cachedDimensions = cache.get(text);
-	if (cachedDimensions) return cachedDimensions;
-	const dimensions = {
-		width: widestLine(text),
-		height: text.split("\n").length
-	};
-	cache.set(text, dimensions);
-	return dimensions;
-};
-//#endregion
-//#region src/ansi-tokenizer.ts
-const bellCharacter = "\x07";
-const escapeCharacter = "\x1B";
-const stringTerminatorCharacter = "œ";
-const csiCharacter = "›";
-const oscCharacter = "";
-const dcsCharacter = "";
-const pmCharacter = "ž";
-const apcCharacter = "Ÿ";
-const sosCharacter = "˜";
-const isCsiParameterCharacter = (character) => {
-	const codePoint = character.codePointAt(0);
-	return codePoint !== void 0 && codePoint >= 48 && codePoint <= 63;
-};
-const isCsiIntermediateCharacter = (character) => {
-	const codePoint = character.codePointAt(0);
-	return codePoint !== void 0 && codePoint >= 32 && codePoint <= 47;
-};
-const isCsiFinalCharacter = (character) => {
-	const codePoint = character.codePointAt(0);
-	return codePoint !== void 0 && codePoint >= 64 && codePoint <= 126;
-};
-const isEscapeIntermediateCharacter = (character) => {
-	const codePoint = character.codePointAt(0);
-	return codePoint !== void 0 && codePoint >= 32 && codePoint <= 47;
-};
-const isEscapeFinalCharacter = (character) => {
-	const codePoint = character.codePointAt(0);
-	return codePoint !== void 0 && codePoint >= 48 && codePoint <= 126;
-};
-const isC1ControlCharacter = (character) => {
-	const codePoint = character.codePointAt(0);
-	return codePoint !== void 0 && codePoint >= 128 && codePoint <= 159;
-};
-const readCsiSequence = (text, fromIndex) => {
-	let index = fromIndex;
-	while (index < text.length) {
-		const character = text[index];
-		if (!isCsiParameterCharacter(character)) break;
-		index++;
-	}
-	const parameterString = text.slice(fromIndex, index);
-	const intermediateStartIndex = index;
-	while (index < text.length) {
-		const character = text[index];
-		if (!isCsiIntermediateCharacter(character)) break;
-		index++;
-	}
-	const intermediateString = text.slice(intermediateStartIndex, index);
-	const finalCharacter = text[index];
-	if (finalCharacter === void 0 || !isCsiFinalCharacter(finalCharacter)) return;
-	return {
-		endIndex: index + 1,
-		parameterString,
-		intermediateString,
-		finalCharacter
-	};
-};
-const findControlStringTerminatorIndex = (text, fromIndex, allowBellTerminator) => {
-	for (let index = fromIndex; index < text.length; index++) {
-		const character = text[index];
-		if (allowBellTerminator && character === bellCharacter) return index + 1;
-		if (character === stringTerminatorCharacter) return index + 1;
-		if (character === escapeCharacter) {
-			const followingCharacter = text[index + 1];
-			if (followingCharacter === escapeCharacter) {
-				index++;
-				continue;
-			}
-			if (followingCharacter === "\\") return index + 2;
-		}
-	}
-};
-const readEscapeSequence = (text, fromIndex) => {
-	let index = fromIndex;
-	while (index < text.length) {
-		const character = text[index];
-		if (!isEscapeIntermediateCharacter(character)) break;
-		index++;
-	}
-	const intermediateString = text.slice(fromIndex, index);
-	const finalCharacter = text[index];
-	if (finalCharacter === void 0 || !isEscapeFinalCharacter(finalCharacter)) return;
-	return {
-		endIndex: index + 1,
-		intermediateString,
-		finalCharacter
-	};
-};
-const getControlStringFromEscapeIntroducer = (character) => {
-	switch (character) {
-		case "]": return {
-			type: "osc",
-			allowBellTerminator: true
-		};
-		case "P": return {
-			type: "dcs",
-			allowBellTerminator: false
-		};
-		case "^": return {
-			type: "pm",
-			allowBellTerminator: false
-		};
-		case "_": return {
-			type: "apc",
-			allowBellTerminator: false
-		};
-		case "X": return {
-			type: "sos",
-			allowBellTerminator: false
-		};
-		default: return;
-	}
-};
-const getControlStringFromC1Introducer = (character) => {
-	switch (character) {
-		case oscCharacter: return {
-			type: "osc",
-			allowBellTerminator: true
-		};
-		case dcsCharacter: return {
-			type: "dcs",
-			allowBellTerminator: false
-		};
-		case pmCharacter: return {
-			type: "pm",
-			allowBellTerminator: false
-		};
-		case apcCharacter: return {
-			type: "apc",
-			allowBellTerminator: false
-		};
-		case sosCharacter: return {
-			type: "sos",
-			allowBellTerminator: false
-		};
-		default: return;
-	}
-};
-const hasAnsiControlCharacters = (text) => {
-	if (text.includes(escapeCharacter)) return true;
-	for (const character of text) if (isC1ControlCharacter(character)) return true;
-	return false;
-};
-const malformedFromIndex = (tokens, text, textStartIndex, fromIndex) => {
-	if (fromIndex > textStartIndex) tokens.push({
-		type: "text",
-		value: text.slice(textStartIndex, fromIndex)
-	});
-	tokens.push({
-		type: "invalid",
-		value: text.slice(fromIndex)
-	});
-	return tokens;
-};
-const tokenizeAnsi = (text) => {
-	if (!hasAnsiControlCharacters(text)) return [{
-		type: "text",
-		value: text
-	}];
-	const tokens = [];
-	let textStartIndex = 0;
-	for (let index = 0; index < text.length;) {
-		const character = text[index];
-		if (character === void 0) break;
-		if (character === escapeCharacter) {
-			const followingCharacter = text[index + 1];
-			if (followingCharacter === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
-			if (followingCharacter === "[") {
-				const csiSequence = readCsiSequence(text, index + 2);
-				if (csiSequence === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
-				if (index > textStartIndex) tokens.push({
-					type: "text",
-					value: text.slice(textStartIndex, index)
-				});
-				tokens.push({
-					type: "csi",
-					value: text.slice(index, csiSequence.endIndex),
-					parameterString: csiSequence.parameterString,
-					intermediateString: csiSequence.intermediateString,
-					finalCharacter: csiSequence.finalCharacter
-				});
-				index = csiSequence.endIndex;
-				textStartIndex = index;
-				continue;
-			}
-			const escapeControlString = getControlStringFromEscapeIntroducer(followingCharacter);
-			if (escapeControlString !== void 0) {
-				const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 2, escapeControlString.allowBellTerminator);
-				if (controlStringTerminatorIndex === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
-				if (index > textStartIndex) tokens.push({
-					type: "text",
-					value: text.slice(textStartIndex, index)
-				});
-				tokens.push({
-					type: escapeControlString.type,
-					value: text.slice(index, controlStringTerminatorIndex)
-				});
-				index = controlStringTerminatorIndex;
-				textStartIndex = index;
-				continue;
-			}
-			const escapeSequence = readEscapeSequence(text, index + 1);
-			if (escapeSequence === void 0) {
-				if (isEscapeIntermediateCharacter(followingCharacter)) return malformedFromIndex(tokens, text, textStartIndex, index);
-				if (index > textStartIndex) tokens.push({
-					type: "text",
-					value: text.slice(textStartIndex, index)
-				});
-				index++;
-				textStartIndex = index;
-				continue;
-			}
-			if (index > textStartIndex) tokens.push({
-				type: "text",
-				value: text.slice(textStartIndex, index)
-			});
-			tokens.push({
-				type: "esc",
-				value: text.slice(index, escapeSequence.endIndex),
-				intermediateString: escapeSequence.intermediateString,
-				finalCharacter: escapeSequence.finalCharacter
-			});
-			index = escapeSequence.endIndex;
-			textStartIndex = index;
-			continue;
-		}
-		if (character === csiCharacter) {
-			const csiSequence = readCsiSequence(text, index + 1);
-			if (csiSequence === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
-			if (index > textStartIndex) tokens.push({
-				type: "text",
-				value: text.slice(textStartIndex, index)
-			});
-			tokens.push({
-				type: "csi",
-				value: text.slice(index, csiSequence.endIndex),
-				parameterString: csiSequence.parameterString,
-				intermediateString: csiSequence.intermediateString,
-				finalCharacter: csiSequence.finalCharacter
-			});
-			index = csiSequence.endIndex;
-			textStartIndex = index;
-			continue;
-		}
-		const c1ControlString = getControlStringFromC1Introducer(character);
-		if (c1ControlString !== void 0) {
-			const controlStringTerminatorIndex = findControlStringTerminatorIndex(text, index + 1, c1ControlString.allowBellTerminator);
-			if (controlStringTerminatorIndex === void 0) return malformedFromIndex(tokens, text, textStartIndex, index);
-			if (index > textStartIndex) tokens.push({
-				type: "text",
-				value: text.slice(textStartIndex, index)
-			});
-			tokens.push({
-				type: c1ControlString.type,
-				value: text.slice(index, controlStringTerminatorIndex)
-			});
-			index = controlStringTerminatorIndex;
-			textStartIndex = index;
-			continue;
-		}
-		if (character === stringTerminatorCharacter) {
-			if (index > textStartIndex) tokens.push({
-				type: "text",
-				value: text.slice(textStartIndex, index)
-			});
-			tokens.push({
-				type: "st",
-				value: character
-			});
-			index++;
-			textStartIndex = index;
-			continue;
-		}
-		if (isC1ControlCharacter(character)) {
-			if (index > textStartIndex) tokens.push({
-				type: "text",
-				value: text.slice(textStartIndex, index)
-			});
-			tokens.push({
-				type: "c1",
-				value: character
-			});
-			index++;
-			textStartIndex = index;
-			continue;
-		}
-		index++;
-	}
-	if (textStartIndex < text.length) tokens.push({
-		type: "text",
-		value: text.slice(textStartIndex)
-	});
-	return tokens;
-};
-//#endregion
-//#region src/sanitize-ansi.ts
-const sgrParametersRegex = /^[\d:;]*$/;
-const sanitizeAnsi = (text) => {
-	if (!hasAnsiControlCharacters(text)) return text;
-	let output = "";
-	for (const token of tokenizeAnsi(text)) {
-		if (token.type === "text" || token.type === "osc") {
-			output += token.value;
-			continue;
-		}
-		if (token.type === "csi" && token.finalCharacter === "m" && token.intermediateString === "" && sgrParametersRegex.test(token.parameterString)) output += token.value;
-	}
-	return output;
-};
-//#endregion
-//#region src/squash-text-nodes.ts
-const squashTextNodes = (node) => {
-	let text = "";
-	for (let index = 0; index < node.childNodes.length; index++) {
-		const childNode = node.childNodes[index];
-		if (childNode === void 0) continue;
-		let nodeText = "";
-		if (childNode.nodeName === "#text") nodeText = childNode.nodeValue;
-		else {
-			if (childNode.nodeName === "ink-text" || childNode.nodeName === "ink-virtual-text") nodeText = squashTextNodes(childNode);
-			if (nodeText.length > 0 && typeof childNode.internal_transform === "function") nodeText = childNode.internal_transform(nodeText, index);
-		}
-		text += nodeText;
-	}
-	return sanitizeAnsi(text);
-};
-//#endregion
-//#region src/wrap-text.ts
-const wrapTextCache = new QuickLru({ maxSize: 4096 });
-const wrapText = (text, maxWidth, wrapType) => {
-	const cacheKey = text + String(maxWidth) + String(wrapType);
-	const cachedText = wrapTextCache.get(cacheKey);
-	if (cachedText !== void 0) return cachedText;
-	let wrappedText = text;
-	if (wrapType === "wrap") wrappedText = wrapAnsi(text, maxWidth, {
-		trim: false,
-		hard: true
-	});
-	if (wrapType === "hard") wrappedText = wrapAnsi(text, maxWidth, {
-		trim: false,
-		hard: true,
-		wordWrap: false
-	});
-	if (wrapType.startsWith("truncate")) {
-		let position = "end";
-		if (wrapType === "truncate-middle") position = "middle";
-		if (wrapType === "truncate-start") position = "start";
-		wrappedText = cliTruncate(text, maxWidth, { position });
-	}
-	wrapTextCache.set(cacheKey, wrappedText);
-	return wrappedText;
-};
-//#endregion
-//#region src/dom.ts
-const createNode = (nodeName) => {
-	const node = {
-		nodeName,
-		style: {},
-		attributes: {},
-		childNodes: [],
-		parentNode: void 0,
-		yogaNode: nodeName === "ink-virtual-text" ? void 0 : Yoga.Node.create(),
-		internal_accessibility: {}
-	};
-	if (nodeName === "ink-text") node.yogaNode?.setMeasureFunc(measureTextNode.bind(null, node));
-	return node;
-};
-const appendChildNode = (node, childNode) => {
-	if (childNode.parentNode) removeChildNode(childNode.parentNode, childNode);
-	childNode.parentNode = node;
-	node.childNodes.push(childNode);
-	if (childNode.yogaNode) node.yogaNode?.insertChild(childNode.yogaNode, node.yogaNode.getChildCount());
-	if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") markNodeAsDirty(node);
-};
-const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
-	if (newChildNode.parentNode) removeChildNode(newChildNode.parentNode, newChildNode);
-	newChildNode.parentNode = node;
-	const index = node.childNodes.indexOf(beforeChildNode);
-	if (index >= 0) {
-		node.childNodes.splice(index, 0, newChildNode);
-		if (newChildNode.yogaNode) node.yogaNode?.insertChild(newChildNode.yogaNode, index);
-	} else {
-		node.childNodes.push(newChildNode);
-		if (newChildNode.yogaNode) node.yogaNode?.insertChild(newChildNode.yogaNode, node.yogaNode.getChildCount());
-	}
-	if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") markNodeAsDirty(node);
-};
-const removeChildNode = (node, removeNode) => {
-	if (removeNode.yogaNode) removeNode.parentNode?.yogaNode?.removeChild(removeNode.yogaNode);
-	removeNode.parentNode = void 0;
-	const index = node.childNodes.indexOf(removeNode);
-	if (index >= 0) node.childNodes.splice(index, 1);
-	if (node.nodeName === "ink-text" || node.nodeName === "ink-virtual-text") markNodeAsDirty(node);
-};
-const nullifyYogaNodes = (node) => {
-	node.yogaNode = void 0;
-	if (node.nodeName !== "#text") for (const childNode of node.childNodes) nullifyYogaNodes(childNode);
-};
-/**
-Detach a removed subtree from the layout engine: drop the measure callback
-and null the `yogaNode` reference on every DOM node within it.
-
-Nulling the references makes every `?.yogaNode` guard in the codebase
-effective for removed nodes, turns lingering access into a safe no-op (see
-QwenLM/qwen-code#6820), and lets the garbage collector reclaim the Yoga
-tree along with its closures.
-*/
-const detachYogaSubtree = (removeNode) => {
-	removeNode.yogaNode?.unsetMeasureFunc();
-	nullifyYogaNodes(removeNode);
-};
-const setAttribute = (node, key, value) => {
-	if (key === "internal_accessibility") {
-		node.internal_accessibility = value;
-		return;
-	}
-	node.attributes[key] = value;
-};
-const setStyle = (node, style) => {
-	node.style = style ?? {};
-};
-const createTextNode = (text) => {
-	const node = {
-		nodeName: "#text",
-		nodeValue: text,
-		yogaNode: void 0,
-		parentNode: void 0,
-		style: {}
-	};
-	setTextNodeValue(node, text);
-	return node;
-};
-const measureTextNode = function(node, width) {
-	const text = node.nodeName === "#text" ? node.nodeValue : squashTextNodes(node);
-	const dimensions = measureText(text);
-	if (dimensions.width <= width) return dimensions;
-	if (dimensions.width >= 1 && width > 0 && width < 1) return dimensions;
-	const textWrap = node.style?.textWrap ?? "wrap";
-	const wrappedText = wrapText(text, width, textWrap);
-	return measureText(wrappedText);
-};
-const findClosestYogaNode = (node) => {
-	if (!node?.parentNode) return;
-	return node.yogaNode ?? findClosestYogaNode(node.parentNode);
-};
-const markNodeAsDirty = (node) => {
-	findClosestYogaNode(node)?.markDirty();
-};
-const setTextNodeValue = (node, text) => {
-	if (typeof text !== "string") text = String(text);
-	node.nodeValue = text;
-	markNodeAsDirty(node);
-};
-const addLayoutListener = (rootNode, listener) => {
-	if (rootNode.nodeName !== "ink-root") return () => {};
-	rootNode.internal_layoutListeners ??= /* @__PURE__ */ new Set();
-	rootNode.internal_layoutListeners.add(listener);
-	return () => {
-		rootNode.internal_layoutListeners?.delete(listener);
-	};
-};
-const emitLayoutListeners = (rootNode) => {
-	if (rootNode.nodeName !== "ink-root" || !rootNode.internal_layoutListeners) return;
-	for (const listener of rootNode.internal_layoutListeners) listener();
-};
+//#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/is-in-ci.ts
-const check = (key) => key in process.env && process.env[key] !== "0" && process.env[key] !== "false";
-const isInCi = check("CI") || check("CONTINUOUS_INTEGRATION");
-//#endregion
-//#region src/kitty-keyboard.ts
-const kittyFlags = {
-	disambiguateEscapeCodes: 1,
-	reportEventTypes: 2,
-	reportAlternateKeys: 4,
-	reportAllKeysAsEscapeCodes: 8,
-	reportAssociatedText: 16
-};
-function resolveFlags(flags) {
-	let result = 0;
-	for (const flag of flags) result |= kittyFlags[flag];
-	return result;
-}
-const kittyModifiers = {
-	shift: 1,
-	alt: 2,
-	ctrl: 4,
-	super: 8,
-	hyper: 16,
-	meta: 32,
-	capsLock: 64,
-	numLock: 128
-};
-//#endregion
-//#region src/log-update.ts
-const visibleLineCount = (lines, str) => str.endsWith("\n") ? lines.length - 1 : lines.length;
-const createStandard = (stream, { showCursor = false } = {}) => {
-	let previousLineCount = 0;
-	let previousOutput = "";
-	let hasHiddenCursor = false;
-	let cursorPosition;
-	let cursorDirty = false;
-	let previousCursorPosition;
-	let cursorWasShown = false;
-	const getActiveCursor = () => cursorDirty ? cursorPosition : void 0;
-	const hasChanges = (str, activeCursor) => {
-		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
-		return str !== previousOutput || cursorChanged;
-	};
-	const render = (str) => {
-		if (!showCursor && !hasHiddenCursor) {
-			cliCursor.hide(stream);
-			hasHiddenCursor = true;
-		}
-		const activeCursor = getActiveCursor();
-		cursorDirty = false;
-		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
-		if (!hasChanges(str, activeCursor)) return false;
-		const lines = str.split("\n");
-		const cursorSuffix = buildCursorSuffix(lines.length - 1, activeCursor);
-		if (str === previousOutput && cursorChanged) stream.write(buildCursorOnlySequence({
-			cursorWasShown,
-			previousLineCount,
-			previousCursorPosition,
-			cursorPosition: activeCursor
-		}));
-		else {
-			previousOutput = str;
-			const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
-			stream.write(returnPrefix + ansiEscapes.eraseLines(previousLineCount) + str + cursorSuffix);
-			previousLineCount = lines.length;
-		}
-		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
-		cursorWasShown = activeCursor !== void 0;
-		return true;
-	};
-	render.clear = () => {
-		const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLineCount, previousCursorPosition);
-		stream.write(prefix + ansiEscapes.eraseLines(previousLineCount));
-		previousOutput = "";
-		previousLineCount = 0;
-		previousCursorPosition = void 0;
-		cursorWasShown = false;
-	};
-	render.done = () => {
-		previousOutput = "";
-		previousLineCount = 0;
-		previousCursorPosition = void 0;
-		cursorWasShown = false;
-		if (!showCursor) {
-			cliCursor.show(stream);
-			hasHiddenCursor = false;
-		}
-	};
-	render.reset = () => {
-		previousOutput = "";
-		previousLineCount = 0;
-		previousCursorPosition = void 0;
-		cursorWasShown = false;
-	};
-	render.sync = (str) => {
-		const activeCursor = cursorDirty ? cursorPosition : void 0;
-		cursorDirty = false;
-		const lines = str.split("\n");
-		previousOutput = str;
-		previousLineCount = lines.length;
-		if (!activeCursor && cursorWasShown) stream.write(hideCursorEscape);
-		if (activeCursor) stream.write(buildCursorSuffix(lines.length - 1, activeCursor));
-		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
-		cursorWasShown = activeCursor !== void 0;
-	};
-	render.setCursorPosition = (position) => {
-		cursorPosition = position;
-		cursorDirty = true;
-	};
-	render.isCursorDirty = () => cursorDirty;
-	render.willRender = (str) => hasChanges(str, getActiveCursor());
-	return render;
-};
-const createIncremental = (stream, { showCursor = false } = {}) => {
-	let previousLines = [];
-	let previousOutput = "";
-	let hasHiddenCursor = false;
-	let cursorPosition;
-	let cursorDirty = false;
-	let previousCursorPosition;
-	let cursorWasShown = false;
-	const getActiveCursor = () => cursorDirty ? cursorPosition : void 0;
-	const hasChanges = (str, activeCursor) => {
-		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
-		return str !== previousOutput || cursorChanged;
-	};
-	const render = (str) => {
-		if (!showCursor && !hasHiddenCursor) {
-			cliCursor.hide(stream);
-			hasHiddenCursor = true;
-		}
-		const activeCursor = getActiveCursor();
-		cursorDirty = false;
-		const cursorChanged = cursorPositionChanged(activeCursor, previousCursorPosition);
-		if (!hasChanges(str, activeCursor)) return false;
-		const nextLines = str.split("\n");
-		const visibleCount = visibleLineCount(nextLines, str);
-		const previousVisible = visibleLineCount(previousLines, previousOutput);
-		if (str === previousOutput && cursorChanged) {
-			stream.write(buildCursorOnlySequence({
-				cursorWasShown,
-				previousLineCount: previousLines.length,
-				previousCursorPosition,
-				cursorPosition: activeCursor
-			}));
-			previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
-			cursorWasShown = activeCursor !== void 0;
-			return true;
-		}
-		const returnPrefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
-		if (str === "\n" || previousOutput.length === 0) {
-			const cursorSuffix = buildCursorSuffix(nextLines.length - 1, activeCursor);
-			stream.write(returnPrefix + ansiEscapes.eraseLines(previousLines.length) + str + cursorSuffix);
-			cursorWasShown = activeCursor !== void 0;
-			previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
-			previousOutput = str;
-			previousLines = nextLines;
-			return true;
-		}
-		if (visibleCount > previousVisible) {
-			const cursorSuffix = buildCursorSuffix(visibleCount, activeCursor);
-			stream.write(returnPrefix + ansiEscapes.eraseLines(previousLines.length) + str + cursorSuffix);
-			cursorWasShown = activeCursor !== void 0;
-			previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
-			previousOutput = str;
-			previousLines = nextLines;
-			return true;
-		}
-		const hasTrailingNewline = str.endsWith("\n");
-		const buffer = [];
-		buffer.push(returnPrefix);
-		if (visibleCount < previousVisible) {
-			const extraSlot = previousOutput.endsWith("\n") ? 1 : 0;
-			buffer.push(ansiEscapes.eraseLines(previousVisible - visibleCount + extraSlot), ansiEscapes.cursorUp(visibleCount));
-		} else buffer.push(ansiEscapes.cursorUp(previousLines.length - 1));
-		for (let i = 0; i < visibleCount; i++) {
-			const isLastLine = i === visibleCount - 1;
-			if (nextLines[i] === previousLines[i]) {
-				if (!isLastLine || hasTrailingNewline) buffer.push(ansiEscapes.cursorNextLine);
-				continue;
-			}
-			buffer.push(ansiEscapes.cursorTo(0) + nextLines[i] + ansiEscapes.eraseEndLine + (isLastLine && !hasTrailingNewline ? "" : "\n"));
-		}
-		const cursorSuffix = buildCursorSuffix(nextLines.length - 1, activeCursor);
-		buffer.push(cursorSuffix);
-		stream.write(buffer.join(""));
-		cursorWasShown = activeCursor !== void 0;
-		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
-		previousOutput = str;
-		previousLines = nextLines;
-		return true;
-	};
-	render.clear = () => {
-		const prefix = buildReturnToBottomPrefix(cursorWasShown, previousLines.length, previousCursorPosition);
-		stream.write(prefix + ansiEscapes.eraseLines(previousLines.length));
-		previousOutput = "";
-		previousLines = [];
-		previousCursorPosition = void 0;
-		cursorWasShown = false;
-	};
-	render.done = () => {
-		previousOutput = "";
-		previousLines = [];
-		previousCursorPosition = void 0;
-		cursorWasShown = false;
-		if (!showCursor) {
-			cliCursor.show(stream);
-			hasHiddenCursor = false;
-		}
-	};
-	render.reset = () => {
-		previousOutput = "";
-		previousLines = [];
-		previousCursorPosition = void 0;
-		cursorWasShown = false;
-	};
-	render.sync = (str) => {
-		const activeCursor = cursorDirty ? cursorPosition : void 0;
-		cursorDirty = false;
-		const lines = str.split("\n");
-		previousOutput = str;
-		previousLines = lines;
-		if (!activeCursor && cursorWasShown) stream.write(hideCursorEscape);
-		if (activeCursor) stream.write(buildCursorSuffix(lines.length - 1, activeCursor));
-		previousCursorPosition = activeCursor ? { ...activeCursor } : void 0;
-		cursorWasShown = activeCursor !== void 0;
-	};
-	render.setCursorPosition = (position) => {
-		cursorPosition = position;
-		cursorDirty = true;
-	};
-	render.isCursorDirty = () => cursorDirty;
-	render.willRender = (str) => hasChanges(str, getActiveCursor());
-	return render;
-};
-const create$1 = (stream, { showCursor = false, incremental = false } = {}) => {
-	if (incremental) return createIncremental(stream, { showCursor });
-	return createStandard(stream, { showCursor });
-};
-const logUpdate = { create: create$1 };
-//#endregion
 //#region src/patch-console.ts
 const consoleMethods = [
 	"assert",
@@ -1905,590 +948,46 @@ const consoleMethods = [
 	"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();
-	};
-};
-//#endregion
-//#region src/styles.ts
-const positionEdges = [
-	["top", Yoga.EDGE_TOP],
-	["right", Yoga.EDGE_RIGHT],
-	["bottom", Yoga.EDGE_BOTTOM],
-	["left", Yoga.EDGE_LEFT]
-];
-const applyPositionStyles = (node, style) => {
-	if ("position" in style) {
-		let positionType = Yoga.POSITION_TYPE_RELATIVE;
-		if (style.position === "absolute") positionType = Yoga.POSITION_TYPE_ABSOLUTE;
-		else if (style.position === "static") positionType = Yoga.POSITION_TYPE_STATIC;
-		node.setPositionType(positionType);
-	}
-	for (const [property, edge] of positionEdges) {
-		if (!(property in style)) continue;
-		const value = style[property];
-		if (typeof value === "string") {
-			node.setPositionPercent(edge, Number.parseFloat(value));
-			continue;
-		}
-		node.setPosition(edge, value);
-	}
-};
-const applyMarginStyles = (node, style) => {
-	if ("margin" in style) node.setMargin(Yoga.EDGE_ALL, style.margin ?? 0);
-	if ("marginX" in style) node.setMargin(Yoga.EDGE_HORIZONTAL, style.marginX ?? 0);
-	if ("marginY" in style) node.setMargin(Yoga.EDGE_VERTICAL, style.marginY ?? 0);
-	if ("marginLeft" in style) node.setMargin(Yoga.EDGE_START, style.marginLeft ?? 0);
-	if ("marginRight" in style) node.setMargin(Yoga.EDGE_END, style.marginRight ?? 0);
-	if ("marginTop" in style) node.setMargin(Yoga.EDGE_TOP, style.marginTop ?? 0);
-	if ("marginBottom" in style) node.setMargin(Yoga.EDGE_BOTTOM, style.marginBottom ?? 0);
-};
-const applyPaddingStyles = (node, style) => {
-	if ("padding" in style) node.setPadding(Yoga.EDGE_ALL, style.padding ?? 0);
-	if ("paddingX" in style) node.setPadding(Yoga.EDGE_HORIZONTAL, style.paddingX ?? 0);
-	if ("paddingY" in style) node.setPadding(Yoga.EDGE_VERTICAL, style.paddingY ?? 0);
-	if ("paddingLeft" in style) node.setPadding(Yoga.EDGE_LEFT, style.paddingLeft ?? 0);
-	if ("paddingRight" in style) node.setPadding(Yoga.EDGE_RIGHT, style.paddingRight ?? 0);
-	if ("paddingTop" in style) node.setPadding(Yoga.EDGE_TOP, style.paddingTop ?? 0);
-	if ("paddingBottom" in style) node.setPadding(Yoga.EDGE_BOTTOM, style.paddingBottom ?? 0);
-};
-const applyFlexStyles = (node, style) => {
-	if ("flexGrow" in style) node.setFlexGrow(style.flexGrow ?? 0);
-	if ("flexShrink" in style) node.setFlexShrink(typeof style.flexShrink === "number" ? style.flexShrink : 1);
-	if ("flexWrap" in style) {
-		if (style.flexWrap === "nowrap") node.setFlexWrap(Yoga.WRAP_NO_WRAP);
-		if (style.flexWrap === "wrap") node.setFlexWrap(Yoga.WRAP_WRAP);
-		if (style.flexWrap === "wrap-reverse") node.setFlexWrap(Yoga.WRAP_WRAP_REVERSE);
-	}
-	if ("flexDirection" in style) {
-		if (style.flexDirection === "row") node.setFlexDirection(Yoga.FLEX_DIRECTION_ROW);
-		if (style.flexDirection === "row-reverse") node.setFlexDirection(Yoga.FLEX_DIRECTION_ROW_REVERSE);
-		if (style.flexDirection === "column") node.setFlexDirection(Yoga.FLEX_DIRECTION_COLUMN);
-		if (style.flexDirection === "column-reverse") node.setFlexDirection(Yoga.FLEX_DIRECTION_COLUMN_REVERSE);
-	}
-	if ("flexBasis" in style) {
-		if (typeof style.flexBasis === "number") node.setFlexBasis(style.flexBasis);
-		else if (typeof style.flexBasis === "string") node.setFlexBasisPercent(Number.parseInt(style.flexBasis, 10));
-		else node.setFlexBasisAuto();
-	}
-	if ("alignItems" in style) {
-		if (style.alignItems === "stretch" || !style.alignItems) node.setAlignItems(Yoga.ALIGN_STRETCH);
-		if (style.alignItems === "flex-start") node.setAlignItems(Yoga.ALIGN_FLEX_START);
-		if (style.alignItems === "center") node.setAlignItems(Yoga.ALIGN_CENTER);
-		if (style.alignItems === "flex-end") node.setAlignItems(Yoga.ALIGN_FLEX_END);
-		if (style.alignItems === "baseline") node.setAlignItems(Yoga.ALIGN_BASELINE);
-	}
-	if ("alignSelf" in style) {
-		if (style.alignSelf === "auto" || !style.alignSelf) node.setAlignSelf(Yoga.ALIGN_AUTO);
-		if (style.alignSelf === "flex-start") node.setAlignSelf(Yoga.ALIGN_FLEX_START);
-		if (style.alignSelf === "center") node.setAlignSelf(Yoga.ALIGN_CENTER);
-		if (style.alignSelf === "flex-end") node.setAlignSelf(Yoga.ALIGN_FLEX_END);
-		if (style.alignSelf === "stretch") node.setAlignSelf(Yoga.ALIGN_STRETCH);
-		if (style.alignSelf === "baseline") node.setAlignSelf(Yoga.ALIGN_BASELINE);
-	}
-	if ("alignContent" in style) {
-		if (style.alignContent === "flex-start" || !style.alignContent) node.setAlignContent(Yoga.ALIGN_FLEX_START);
-		if (style.alignContent === "center") node.setAlignContent(Yoga.ALIGN_CENTER);
-		if (style.alignContent === "flex-end") node.setAlignContent(Yoga.ALIGN_FLEX_END);
-		if (style.alignContent === "space-between") node.setAlignContent(Yoga.ALIGN_SPACE_BETWEEN);
-		if (style.alignContent === "space-around") node.setAlignContent(Yoga.ALIGN_SPACE_AROUND);
-		if (style.alignContent === "space-evenly") node.setAlignContent(Yoga.ALIGN_SPACE_EVENLY);
-		if (style.alignContent === "stretch") node.setAlignContent(Yoga.ALIGN_STRETCH);
-	}
-	if ("justifyContent" in style) {
-		if (style.justifyContent === "flex-start" || !style.justifyContent) node.setJustifyContent(Yoga.JUSTIFY_FLEX_START);
-		if (style.justifyContent === "center") node.setJustifyContent(Yoga.JUSTIFY_CENTER);
-		if (style.justifyContent === "flex-end") node.setJustifyContent(Yoga.JUSTIFY_FLEX_END);
-		if (style.justifyContent === "space-between") node.setJustifyContent(Yoga.JUSTIFY_SPACE_BETWEEN);
-		if (style.justifyContent === "space-around") node.setJustifyContent(Yoga.JUSTIFY_SPACE_AROUND);
-		if (style.justifyContent === "space-evenly") node.setJustifyContent(Yoga.JUSTIFY_SPACE_EVENLY);
-	}
-};
-const applyDimensionStyles = (node, style) => {
-	if ("width" in style) {
-		if (typeof style.width === "number") node.setWidth(style.width);
-		else if (typeof style.width === "string") node.setWidthPercent(Number.parseInt(style.width, 10));
-		else node.setWidthAuto();
-	}
-	if ("height" in style) {
-		if (typeof style.height === "number") node.setHeight(style.height);
-		else if (typeof style.height === "string") node.setHeightPercent(Number.parseInt(style.height, 10));
-		else node.setHeightAuto();
-	}
-	if ("minWidth" in style) {
-		if (typeof style.minWidth === "string") node.setMinWidthPercent(Number.parseInt(style.minWidth, 10));
-		else node.setMinWidth(style.minWidth ?? 0);
-	}
-	if ("minHeight" in style) {
-		if (typeof style.minHeight === "string") node.setMinHeightPercent(Number.parseInt(style.minHeight, 10));
-		else node.setMinHeight(style.minHeight ?? 0);
-	}
-	if ("maxWidth" in style) {
-		if (typeof style.maxWidth === "string") node.setMaxWidthPercent(Number.parseInt(style.maxWidth, 10));
-		else node.setMaxWidth(style.maxWidth);
-	}
-	if ("maxHeight" in style) {
-		if (typeof style.maxHeight === "string") node.setMaxHeightPercent(Number.parseInt(style.maxHeight, 10));
-		else node.setMaxHeight(style.maxHeight);
-	}
-	if ("aspectRatio" in style) node.setAspectRatio(style.aspectRatio);
-};
-const applyDisplayStyles = (node, style) => {
-	if ("display" in style) node.setDisplay(style.display === "flex" ? Yoga.DISPLAY_FLEX : Yoga.DISPLAY_NONE);
-};
-const applyBorderStyles = (node, style, currentStyle) => {
-	if (!("borderStyle" in style || "borderTop" in style || "borderBottom" in style || "borderLeft" in style || "borderRight" in style)) return;
-	const borderWidth = currentStyle.borderStyle ? 1 : 0;
-	node.setBorder(Yoga.EDGE_TOP, currentStyle.borderTop === false ? 0 : borderWidth);
-	node.setBorder(Yoga.EDGE_BOTTOM, currentStyle.borderBottom === false ? 0 : borderWidth);
-	node.setBorder(Yoga.EDGE_LEFT, currentStyle.borderLeft === false ? 0 : borderWidth);
-	node.setBorder(Yoga.EDGE_RIGHT, currentStyle.borderRight === false ? 0 : borderWidth);
-};
-const applyGapStyles = (node, style) => {
-	if ("gap" in style) node.setGap(Yoga.GUTTER_ALL, style.gap ?? 0);
-	if ("columnGap" in style) node.setGap(Yoga.GUTTER_COLUMN, style.columnGap ?? 0);
-	if ("rowGap" in style) node.setGap(Yoga.GUTTER_ROW, style.rowGap ?? 0);
-};
-const styles = (node, style = {}, currentStyle = style) => {
-	applyPositionStyles(node, style);
-	applyMarginStyles(node, style);
-	applyPaddingStyles(node, style);
-	applyFlexStyles(node, style);
-	applyDimensionStyles(node, style);
-	applyDisplayStyles(node, style);
-	applyBorderStyles(node, style, currentStyle);
-	applyGapStyles(node, style);
-};
-//#endregion
-//#region src/reconciler.ts
-if (process.env["SIGIL_DEV"] === "true") {
-	let isDevtoolsInstalled = false;
-	try {
-		import.meta.resolve("react-devtools-core");
-		isDevtoolsInstalled = true;
-	} catch {}
-	if (isDevtoolsInstalled) await import("./devtools-BhYGjb7h.js");
-}
-const diff = (before, after) => {
-	if (before === after) return;
-	if (!before) return after;
-	const changed = {};
-	let isChanged = false;
-	for (const key of Object.keys(before)) if (after ? !Object.hasOwn(after, key) : true) {
-		changed[key] = void 0;
-		isChanged = true;
-	}
-	if (after) {
-		for (const key of Object.keys(after)) if (after[key] !== before[key]) {
-			changed[key] = after[key];
-			isChanged = true;
-		}
-	}
-	return isChanged ? changed : void 0;
-};
-const findRootNode$1 = (node) => {
-	let current = node;
-	while (current) {
-		if (current.nodeName === "ink-root") return current;
-		current = current.parentNode;
-	}
-};
-/**
-* Clear the root's cached `staticNode` when the node it points at is being
-* removed as part of a larger subtree.
-*
-* The previous identity check (`staticNode === removeNode`) only caught direct
-* removal of the `<Static>` element. When an *ancestor* of `<Static>` is
-* removed, the stale `staticNode` reference survives and the next render would
-* replay stale static output (and, before `detachYogaSubtree`, trap on detached
-* WASM memory — see QwenLM/qwen-code#6820).
-*
-* The owning root is derived from the host parent passed to the removal hook,
-* not a module-level global, so instances with separate stdout streams don't
-* clobber each other's pointers.
-*/
-const clearStaticNodeIfContained = (rootNode, removeNode) => {
-	if (!rootNode?.staticNode) return;
-	let current = rootNode.staticNode;
-	while (current) {
-		if (current === removeNode) {
-			rootNode.staticNode = void 0;
-			return;
-		}
-		current = current.parentNode;
-	}
-};
-let currentUpdatePriority = NoEventPriority;
-async function loadPackageJson() {
-	const content = (await import("node:fs")).readFileSync(new URL("../package.json", import.meta.url), "utf8");
-	const parsedContent = JSON.parse(content);
-	return {
-		name: parsedContent?.name,
-		version: parsedContent?.version
-	};
-}
-let packageInfo = {
-	name: "ink",
-	version
-};
-if (process.env["DEV"] === "true") try {
-	const loaded = await loadPackageJson();
-	packageInfo = {
-		name: loaded.name || packageInfo.name,
-		version: loaded.version || packageInfo.version
-	};
-} catch (error) {
-	console.warn("Failed to load package.json in development mode. Falling back to default renderer metadata.", error);
-}
-const reconciler = createReconciler({
-	getRootHostContext: () => ({ isInsideText: false }),
-	prepareForCommit: () => null,
-	preparePortalMount: () => null,
-	clearContainer: () => false,
-	resetAfterCommit(rootNode) {
-		if (typeof rootNode.onComputeLayout === "function") rootNode.onComputeLayout();
-		emitLayoutListeners(rootNode);
-		if (rootNode.staticNode !== rootNode.previousStaticNode) {
-			rootNode.previousStaticNode = rootNode.staticNode;
-			if (typeof rootNode.onStaticChange === "function") rootNode.onStaticChange();
-		}
-		if (rootNode.isStaticDirty) {
-			rootNode.isStaticDirty = false;
-			if (typeof rootNode.onImmediateRender === "function") rootNode.onImmediateRender();
-			return;
-		}
-		if (typeof rootNode.onRender === "function") rootNode.onRender();
-	},
-	getChildHostContext(parentHostContext, type) {
-		const previousIsInsideText = parentHostContext.isInsideText;
-		const isInsideText = type === "ink-text" || type === "ink-virtual-text";
-		if (previousIsInsideText === isInsideText) return parentHostContext;
-		return { isInsideText };
-	},
-	shouldSetTextContent: () => false,
-	createInstance(originalType, newProps, rootNode, hostContext) {
-		if (hostContext.isInsideText && originalType === "ink-box") throw new Error(`<Box> can’t be nested inside <Text> component`);
-		const type = originalType === "ink-text" && hostContext.isInsideText ? "ink-virtual-text" : originalType;
-		const node = createNode(type);
-		for (const [key, value] of Object.entries(newProps)) {
-			if (key === "children") continue;
-			if (key === "style") {
-				setStyle(node, value);
-				if (node.yogaNode) styles(node.yogaNode, value);
-				continue;
-			}
-			if (key === "internal_transform") {
-				node.internal_transform = value;
-				continue;
-			}
-			if (key === "internal_static") {
-				node.internal_static = true;
-				rootNode.isStaticDirty = true;
-				rootNode.staticNode = node;
-				continue;
-			}
-			setAttribute(node, key, value);
-		}
-		return node;
-	},
-	createTextInstance(text, _root, hostContext) {
-		if (!hostContext.isInsideText) throw new Error(`Text string "${text}" must be rendered inside <Text> component`);
-		return createTextNode(text);
-	},
-	resetTextContent() {},
-	hideTextInstance(node) {
-		setTextNodeValue(node, "");
-	},
-	unhideTextInstance(node, text) {
-		setTextNodeValue(node, text);
-	},
-	getPublicInstance: (instance) => instance,
-	hideInstance(node) {
-		node.yogaNode?.setDisplay(Yoga.DISPLAY_NONE);
-	},
-	unhideInstance(node) {
-		node.yogaNode?.setDisplay(Yoga.DISPLAY_FLEX);
-	},
-	appendInitialChild: appendChildNode,
-	appendChild: appendChildNode,
-	insertBefore: insertBeforeNode,
-	finalizeInitialChildren() {
-		return false;
-	},
-	isPrimaryRenderer: true,
-	supportsMutation: true,
-	supportsPersistence: false,
-	supportsHydration: false,
-	supportsMicrotasks: true,
-	scheduleMicrotask: queueMicrotask,
-	scheduleCallback: Scheduler.unstable_scheduleCallback,
-	cancelCallback: Scheduler.unstable_cancelCallback,
-	shouldYield: Scheduler.unstable_shouldYield,
-	now: Scheduler.unstable_now,
-	scheduleTimeout: setTimeout,
-	cancelTimeout: clearTimeout,
-	noTimeout: -1,
-	beforeActiveInstanceBlur() {},
-	afterActiveInstanceBlur() {},
-	detachDeletedInstance() {},
-	getInstanceFromNode: () => null,
-	prepareScopeUpdate() {},
-	getInstanceFromScope: () => null,
-	appendChildToContainer: appendChildNode,
-	insertInContainerBefore: insertBeforeNode,
-	removeChildFromContainer(node, removeNode) {
-		clearStaticNodeIfContained(findRootNode$1(node), removeNode);
-		removeChildNode(node, removeNode);
-		detachYogaSubtree(removeNode);
-	},
-	commitUpdate(node, _type, oldProps, newProps) {
-		if (node.internal_static) {
-			const rootNode = findRootNode$1(node);
-			if (rootNode) rootNode.isStaticDirty = true;
-		}
-		const props = diff(oldProps, newProps);
-		const style = diff(oldProps["style"], newProps["style"]);
-		if (!props && !style) return;
-		if (props) for (const [key, value] of Object.entries(props)) {
-			if (key === "style") {
-				setStyle(node, value);
-				continue;
-			}
-			if (key === "internal_transform") {
-				node.internal_transform = value;
-				continue;
-			}
-			if (key === "internal_static") {
-				node.internal_static = true;
-				continue;
-			}
-			setAttribute(node, key, value);
-		}
-		if (style && node.yogaNode) styles(node.yogaNode, style, newProps["style"] ?? {});
-	},
-	commitTextUpdate(node, _oldText, newText) {
-		setTextNodeValue(node, newText);
-	},
-	removeChild(node, removeNode) {
-		clearStaticNodeIfContained(findRootNode$1(node), removeNode);
-		removeChildNode(node, removeNode);
-		detachYogaSubtree(removeNode);
-	},
-	setCurrentUpdatePriority(newPriority) {
-		currentUpdatePriority = newPriority;
-	},
-	getCurrentUpdatePriority: () => currentUpdatePriority,
-	resolveUpdatePriority() {
-		if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
-		return DefaultEventPriority;
-	},
-	maySuspendCommit() {
+	"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;
-	},
-	NotPendingTransition: void 0,
-	HostTransitionContext: createContext(null),
-	resetFormInstance() {},
-	requestPostPaintCallback() {},
-	shouldAttemptEagerTransition() {
-		return false;
-	},
-	trackSchedulerEvent() {},
-	resolveEventType() {
-		return null;
-	},
-	resolveEventTimeStamp() {
-		return -1.1;
-	},
-	preloadInstance() {
+	};
+	stderr.write = (data) => {
+		callback("stderr", String(data));
 		return true;
-	},
-	startSuspendingCommit() {},
-	suspendInstance() {},
-	waitForCommitToBeReady() {
-		return null;
-	},
-	rendererPackageName: packageInfo.name,
-	rendererVersion: packageInfo.version
-});
-//#endregion
-//#region src/output.ts
-var OutputCaches = class {
-	widths = /* @__PURE__ */ new Map();
-	blockWidths = /* @__PURE__ */ new Map();
-	styledChars = /* @__PURE__ */ new Map();
-	getStyledChars(line) {
-		let cached = this.styledChars.get(line);
-		if (cached === void 0) {
-			cached = styledCharsFromTokens(tokenize(line));
-			this.styledChars.set(line, cached);
-		}
-		return cached;
-	}
-	getStringWidth(text) {
-		let cached = this.widths.get(text);
-		if (cached === void 0) {
-			cached = stringWidth(text);
-			this.widths.set(text, cached);
-		}
-		return cached;
-	}
-	getWidestLine(text) {
-		let cached = this.blockWidths.get(text);
-		if (cached === void 0) {
-			let lineWidth = 0;
-			for (const line of text.split("\n")) lineWidth = Math.max(lineWidth, this.getStringWidth(line));
-			cached = lineWidth;
-			this.blockWidths.set(text, cached);
-		}
-		return cached;
+	};
+	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();
+	};
 };
-var Output = class {
-	width;
-	height;
-	operations = [];
-	caches = new OutputCaches();
-	constructor(options) {
-		const { width, height } = options;
-		this.width = width;
-		this.height = height;
-	}
-	write(x, y, text, options) {
-		const { transformers } = options;
-		if (!text) return;
-		this.operations.push({
-			type: "write",
-			x,
-			y,
-			text,
-			transformers
-		});
-	}
-	clip(clip) {
-		this.operations.push({
-			type: "clip",
-			clip
-		});
-	}
-	unclip() {
-		this.operations.push({ type: "unclip" });
-	}
-	get() {
-		const output = [];
-		for (let y = 0; y < this.height; y++) {
-			const row = [];
-			for (let x = 0; x < this.width; x++) row.push({
-				type: "char",
-				value: " ",
-				fullWidth: false,
-				styles: []
-			});
-			output.push(row);
-		}
-		const clips = [];
-		for (const operation of this.operations) {
-			if (operation.type === "clip") clips.push(operation.clip);
-			if (operation.type === "unclip") clips.pop();
-			if (operation.type === "write") {
-				const { text, transformers } = operation;
-				let { x, y } = operation;
-				let lines = text.split("\n");
-				const clip = clips.at(-1);
-				if (clip) {
-					const clipHorizontally = typeof clip?.x1 === "number" && typeof clip?.x2 === "number";
-					const clipVertically = typeof clip?.y1 === "number" && typeof clip?.y2 === "number";
-					if (clipHorizontally) {
-						const width = this.caches.getWidestLine(text);
-						if (x + width < clip.x1 || x > clip.x2) continue;
-					}
-					if (clipVertically) {
-						const height = lines.length;
-						if (y + height < clip.y1 || y > clip.y2) continue;
-					}
-					if (clipHorizontally) {
-						lines = lines.map((line) => {
-							const from = x < clip.x1 ? clip.x1 - x : 0;
-							const width = this.caches.getStringWidth(line);
-							const to = x + width > clip.x2 ? clip.x2 - x : width;
-							return sliceAnsi(line, from, to);
-						});
-						if (x < clip.x1) x = clip.x1;
-					}
-					if (clipVertically) {
-						const from = y < clip.y1 ? clip.y1 - y : 0;
-						const height = lines.length;
-						const to = y + height > clip.y2 ? clip.y2 - y : height;
-						lines = lines.slice(from, to);
-						if (y < clip.y1) y = clip.y1;
-					}
-				}
-				let offsetY = 0;
-				for (let [index, line] of lines.entries()) {
-					const currentLine = output[y + offsetY];
-					if (!currentLine) continue;
-					for (const transformer of transformers) line = transformer(line, index);
-					const characters = this.caches.getStyledChars(line);
-					let offsetX = x;
-					if (characters.length === 0) {
-						offsetY++;
-						continue;
-					}
-					const spaceCell = {
-						type: "char",
-						value: " ",
-						fullWidth: false,
-						styles: []
-					};
-					if (currentLine[offsetX]?.value === "" && offsetX > 0 && this.caches.getStringWidth(currentLine[offsetX - 1]?.value ?? "") > 1) currentLine[offsetX - 1] = spaceCell;
-					for (const character of characters) {
-						currentLine[offsetX] = character;
-						const characterWidth = Math.max(1, this.caches.getStringWidth(character.value));
-						if (characterWidth > 1) for (let columnOffset = 1; columnOffset < characterWidth; columnOffset++) currentLine[offsetX + columnOffset] = {
-							type: "char",
-							value: "",
-							fullWidth: false,
-							styles: character.styles
-						};
-						offsetX += characterWidth;
-					}
-					if (currentLine[offsetX]?.value === "") currentLine[offsetX] = spaceCell;
-					offsetY++;
-				}
-			}
-		}
-		return {
-			output: output.map((line) => {
-				const lineWithoutEmptyItems = line.filter((item) => item !== void 0);
-				return styledCharsToString(lineWithoutEmptyItems).trimEnd();
-			}).join("\n"),
-			height: output.length
-		};
-	}
+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
@@ -2496,17 +995,9 @@ 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/indent-string.ts
-const indentString = (string, count = 1, options = {}) => {
-	const { indent = " ", includeEmptyLines = false } = options;
-	if (count === 0) return string;
-	const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
-	return string.replace(regex, indent.repeat(count));
-};
-//#endregion
 //#region src/render-background.ts
 const renderBackground = (x, y, node, output) => {
-	if (!node.style.backgroundColor) return;
+	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;
@@ -2516,106 +1007,51 @@ const renderBackground = (x, y, node, output) => {
 	const contentWidth = width - leftBorderWidth - rightBorderWidth;
 	const contentHeight = height - topBorderHeight - bottomBorderHeight;
 	if (!(contentWidth > 0 && contentHeight > 0)) return;
-	const backgroundLine = colorize(" ".repeat(contentWidth), node.style.backgroundColor, "background");
-	for (let row = 0; row < contentHeight; row++) output.write(x + leftBorderWidth, y + topBorderHeight + row, backgroundLine, { transformers: [] });
-};
-//#endregion
-//#region src/boxes.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: "→"
-	}
+	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, fg, bg, dim) => {
-	let styled = colorize(segment, fg, "foreground");
-	styled = colorize(styled, bg, "background");
-	if (dim) styled = chalk.dim(styled);
-	return styled;
+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 box = typeof node.style.borderStyle === "string" ? boxes[node.style.borderStyle] : node.style.borderStyle;
+		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;
@@ -2633,36 +1069,200 @@ const renderBorder = (x, y, node, output) => {
 		const showLeftBorder = node.style.borderLeft !== false;
 		const showRightBorder = node.style.borderRight !== false;
 		const contentWidth = width - (showLeftBorder ? 1 : 0) - (showRightBorder ? 1 : 0);
-		let topBorder = showTopBorder ? (showLeftBorder ? box.topLeft : "") + box.top.repeat(contentWidth) + (showRightBorder ? box.topRight : "") : void 0;
-		topBorder &&= stylePiece(topBorder, topBorderColor, topBorderBackgroundColor, dimTopBorderColor);
+		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;
-		let leftBorder = "";
-		if (showLeftBorder) leftBorder = (stylePiece(box.left, leftBorderColor, leftBorderBackgroundColor, dimLeftBorderColor) + "\n").repeat(verticalBorderHeight);
-		let rightBorder = "";
-		if (showRightBorder) rightBorder = (stylePiece(box.right, rightBorderColor, rightBorderBackgroundColor, dimRightBorderColor) + "\n").repeat(verticalBorderHeight);
-		let bottomBorder = showBottomBorder ? (showLeftBorder ? box.bottomLeft : "") + box.bottom.repeat(contentWidth) + (showRightBorder ? box.bottomRight : "") : void 0;
-		bottomBorder &&= stylePiece(bottomBorder, bottomBorderColor, bottomBorderBackgroundColor, dimBottomBorderColor);
 		const offsetY = showTopBorder ? 1 : 0;
-		if (topBorder) output.write(x, y, topBorder, { transformers: [] });
-		if (leftBorder) output.write(x, y + offsetY, leftBorder, { transformers: [] });
-		if (rightBorder) output.write(x + width - 1, y + offsetY, rightBorder, { transformers: [] });
-		if (bottomBorder) output.write(x, y + height - 1, bottomBorder, { transformers: [] });
+		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/render-node-to-output.ts
-const applyPaddingToText = (node, text) => {
-	const yogaNode = node.childNodes[0]?.yogaNode;
-	if (yogaNode) {
-		const offsetX = yogaNode.getComputedLeft();
-		const offsetY = yogaNode.getComputedTop();
-		text = "\n".repeat(offsetY) + indentString(text, offsetX);
+//#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 (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 text;
-};
-const renderNodeToScreenReaderOutput = (node, options = {}) => {
+	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 = "";
@@ -2670,7 +1270,7 @@ const renderNodeToScreenReaderOutput = (node, options = {}) => {
 	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 renderNodeToScreenReaderOutput(childNode, {
+			return renderAccessibleText(childNode, {
 				parentRole: node.internal_accessibility?.role,
 				skipStaticElements: options.skipStaticElements
 			});
@@ -2686,7 +1286,7 @@ const renderNodeToScreenReaderOutput = (node, options = {}) => {
 	}
 	return output;
 };
-const renderNodeToOutput = (node, output, options) => {
+const paintTree = (node, output, options) => {
 	const { offsetX = 0, offsetY = 0, transformers = [], skipStaticElements } = options;
 	if (skipStaticElements && node.internal_static) return;
 	const { yogaNode } = node;
@@ -2694,19 +1294,28 @@ const renderNodeToOutput = (node, output, options) => {
 		if (yogaNode.getDisplay() === Yoga.DISPLAY_NONE) return;
 		const x = offsetX + yogaNode.getComputedLeft();
 		const y = offsetY + yogaNode.getComputedTop();
-		let newTransformers = transformers;
-		if (typeof node.internal_transform === "function") newTransformers = [node.internal_transform, ...transformers];
+		const newTransformers = node.internal_transform ? [node.internal_transform, ...transformers] : transformers;
 		if (node.nodeName === "ink-text") {
-			let text = squashTextNodes(node);
-			if (text.length > 0) {
-				const currentWidth = widestLine(text);
+			if (squashTextNodes(node).length > 0) {
 				const maxWidth = getMaxWidth(yogaNode);
-				if (currentWidth > maxWidth) {
-					const textWrap = node.style.textWrap ?? "wrap";
-					text = wrapText(text, maxWidth, textWrap);
-				}
-				text = applyPaddingToText(node, text);
-				output.write(x, y, text, { transformers: newTransformers });
+				const firstChildYoga = node.childNodes[0]?.yogaNode;
+				const paddingX = firstChildYoga?.getComputedLeft() ?? 0;
+				const paddingY = firstChildYoga?.getComputedTop() ?? 0;
+				const lines = wrapStructuredText(structuredTextLines(node), maxWidth, node.style.textWrap ?? "wrap", 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 });
+				} else output.writeCells(paintBounds.x, paintBounds.y, sampled);
 			}
 			return;
 		}
@@ -2731,7 +1340,7 @@ const renderNodeToOutput = (node, output, options) => {
 			}
 		}
 		if (node.nodeName === "ink-root" || node.nodeName === "ink-box") {
-			for (const childNode of node.childNodes) renderNodeToOutput(childNode, output, {
+			for (const childNode of node.childNodes) paintTree(childNode, output, {
 				offsetX: x,
 				offsetY: y,
 				transformers: newTransformers,
@@ -2741,47 +1350,235 @@ const renderNodeToOutput = (node, output, options) => {
 		}
 	}
 };
+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) {
+		const clip = this.#clips.at(-1);
+		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);
+				currentX = endX;
+			}
+		}
+	}
+	writeAnsi(x, y, text, options) {
+		if (!text) return;
+		let lines = text.split("\n");
+		const clip = this.#clips.at(-1);
+		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);
+				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) {
+		if (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
+		});
+	}
+	#writeCompatibilityCell(x, y, character, width) {
+		if (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
+		});
+	}
+};
 //#endregion
-//#region src/renderer.ts
-const renderer = (node, isScreenReaderEnabled) => {
+//#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 = renderNodeToScreenReaderOutput(node, { skipStaticElements: true });
-			const outputHeight = output === "" ? 0 : output.split("\n").length;
+			const output = renderAccessibleText(node, { skipStaticElements: true });
 			let staticOutput = "";
-			if (node.staticNode) staticOutput = renderNodeToScreenReaderOutput(node.staticNode, { skipStaticElements: false });
+			if (node.staticNode) staticOutput = renderAccessibleText(node.staticNode, { skipStaticElements: false });
 			return {
-				output,
-				outputHeight,
-				staticOutput: staticOutput ? `${staticOutput}\n` : ""
+				accessibleText: output,
+				staticAccessibleText: staticOutput
 			};
 		}
-		const output = new Output({
-			width: node.yogaNode.getComputedWidth(),
-			height: node.yogaNode.getComputedHeight()
+		const output = new Canvas({
+			width: renderDimension(node.yogaNode.getComputedWidth()),
+			height: renderDimension(node.yogaNode.getComputedHeight()),
+			colorProfile: options.colorProfile,
+			paintContext: options.paintContext
 		});
-		renderNodeToOutput(node, output, { skipStaticElements: true });
+		paintTree(node, output, { skipStaticElements: true });
 		let staticOutput;
 		if (node.staticNode?.yogaNode) {
-			staticOutput = new Output({
-				width: node.staticNode.yogaNode.getComputedWidth(),
-				height: node.staticNode.yogaNode.getComputedHeight()
+			staticOutput = new Canvas({
+				width: renderDimension(node.staticNode.yogaNode.getComputedWidth()),
+				height: renderDimension(node.staticNode.yogaNode.getComputedHeight()),
+				colorProfile: options.colorProfile,
+				paintContext: options.paintContext
 			});
-			renderNodeToOutput(node.staticNode, staticOutput, { skipStaticElements: false });
+			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;
 		}
-		const { output: generatedOutput, height: outputHeight } = output.get();
-		return {
-			output: generatedOutput,
-			outputHeight,
-			staticOutput: staticOutput ? `${staticOutput.get().output}\n` : ""
-		};
-	}
-	return {
-		output: "",
-		outputHeight: 0,
-		staticOutput: ""
 	};
-};
+	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
 /**
@@ -2832,32 +1629,28 @@ const throttle = (fn, wait = 0) => {
 	return throttled;
 };
 //#endregion
-//#region src/terminal-size.ts
-const create = (columns, rows) => ({
-	columns: Number.parseInt(String(columns), 10),
-	rows: Number.parseInt(String(rows), 10)
-});
-const devTty = () => {
-	try {
-		const { O_EVTONLY: evtOnly } = fs.constants;
-		const flags = process.platform === "darwin" && evtOnly !== void 0 ? evtOnly | fs.constants.O_NONBLOCK : fs.constants.O_NONBLOCK;
-		const { columns, rows } = new tty.WriteStream(fs.openSync("/dev/tty", flags));
-		if (columns && rows) return {
-			columns,
-			rows
-		};
-	} catch {}
-};
-const terminalSize = () => {
-	const { env, stdout, stderr } = process;
-	if (stdout?.columns && stdout?.rows) return create(stdout.columns, stdout.rows);
-	if (stderr?.columns && stderr?.rows) return create(stderr.columns, stderr.rows);
-	if (env["COLUMNS"] && env["LINES"]) return create(env["COLUMNS"], env["LINES"]);
-	return devTty() ?? {
-		columns: 80,
-		rows: 24
+//#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/utils.ts
 const resolveDimension = (value, fallback, defaultValue) => {
@@ -2884,57 +1677,31 @@ const getWindowSize = (stdout) => {
 	};
 };
 //#endregion
-//#region src/write-synchronized.ts
-function shouldSynchronize(stream, interactive) {
-	return "isTTY" in stream && stream.isTTY && (interactive ?? !isInCi);
-}
-//#endregion
 //#region src/ink.tsx
 /** @jsxImportSource react */
 const noop = () => {};
-const textEncoder = new TextEncoder();
-const yieldImmediate = async () => new Promise((resolve) => {
-	setImmediate(resolve);
-});
-const kittyQueryEscapeByte = 27;
-const kittyQueryOpenBracketByte = 91;
-const kittyQueryQuestionMarkByte = 63;
-const kittyQueryLetterByte = 117;
-const zeroByte = 48;
-const nineByte = 57;
-const isDigitByte = (byte) => byte >= zeroByte && byte <= nineByte;
-const matchKittyQueryResponse = (buffer, startIndex) => {
-	if (buffer[startIndex] !== kittyQueryEscapeByte || buffer[startIndex + 1] !== kittyQueryOpenBracketByte || buffer[startIndex + 2] !== kittyQueryQuestionMarkByte) return;
-	let index = startIndex + 3;
-	const digitsStartIndex = index;
-	while (index < buffer.length && isDigitByte(buffer[index])) index++;
-	if (index === digitsStartIndex) return;
-	if (index === buffer.length) return { state: "partial" };
-	if (buffer[index] === kittyQueryLetterByte) return {
-		state: "complete",
-		endIndex: index
-	};
-};
-const hasCompleteKittyQueryResponse = (buffer) => {
-	for (let index = 0; index < buffer.length; index++) if (matchKittyQueryResponse(buffer, index)?.state === "complete") return true;
-	return false;
-};
-const stripKittyQueryResponsesAndTrailingPartial = (buffer) => {
-	const keptBytes = [];
-	let index = 0;
-	while (index < buffer.length) {
-		const match = matchKittyQueryResponse(buffer, index);
-		if (match?.state === "complete") {
-			index = match.endIndex + 1;
-			continue;
-		}
-		if (match?.state === "partial") break;
-		keptBytes.push(buffer[index]);
-		index++;
-	}
-	return keptBytes;
+const beforeExitCallbacks = /* @__PURE__ */ new Set();
+const runBeforeExitCallbacks = () => {
+	for (const callback of beforeExitCallbacks) callback();
 };
-const isWindowsConsole = process.platform === "win32";
+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 shouldClearTerminalForFrame = ({ isTTY, viewportRows, previousOutputHeight, nextOutputHeight, isUnmounting }) => {
 	if (!isTTY) return false;
 	const hadPreviousFrame = previousOutputHeight > 0;
@@ -2944,20 +1711,24 @@ const shouldClearTerminalForFrame = ({ isTTY, viewportRows, previousOutputHeight
 	const isFullscreen = nextOutputHeight >= viewportRows;
 	const isLeavingFullscreen = wasOverflowing && nextOutputHeight < viewportRows;
 	const shouldClearOnUnmount = isUnmounting && wasFullscreen;
-	if (isWindowsConsole && (wasFullscreen || isFullscreen)) return true;
+	if (isWindows && (wasFullscreen || isFullscreen)) return true;
 	return wasOverflowing || isOverflowing && hadPreviousFrame || isLeavingFullscreen || shouldClearOnUnmount;
 };
 const isErrorInput = (value) => {
-	return value instanceof Error || Object.prototype.toString.call(value) === "[object Error]";
+	return value instanceof Error || isNativeError(value);
 };
 const getWritableStreamState = (stdout) => {
 	return { canWriteToStdout: !stdout.destroyed && !stdout.writableEnded && (stdout.writable ?? true) };
 };
 const settleThrottle = (throttled, canWriteToStdout) => {
-	if (!throttled || typeof throttled.flush !== "function") return;
-	const throttledValue = throttled;
-	if (canWriteToStdout) throttledValue.flush();
-	else if (typeof throttledValue.cancel === "function") throttledValue.cancel();
+	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);
@@ -2970,645 +1741,597 @@ const createRenderPassthrough = (stream) => {
 	passthrough.emit = stream.emit.bind(stream);
 	return passthrough;
 };
-var Ink = class {
-	/**
-	Whether this instance is using concurrent rendering mode.
-	*/
-	isConcurrent;
-	options;
-	log;
-	cursorPosition;
-	throttledLog;
-	isScreenReaderEnabled;
-	interactive;
-	renderThrottleMs;
-	alternateScreen;
-	isUnmounted;
-	isUnmounting;
-	lastOutput;
-	lastOutputToRender;
-	lastOutputHeight;
-	lastTerminalWidth;
-	lastTerminalHeight;
-	container;
-	rootNode;
-	fullStaticOutput;
-	exitPromise;
-	exitResult;
-	beforeExitHandler;
-	restoreConsole;
-	captureTargets;
-	capturedStdioTails = {
+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;
+	let lastTerminalWidth = getWindowSize(options.stdout).columns;
+	let lastTerminalHeight = getWindowSize(options.stdout).rows;
+	let fullStaticOutput = "";
+	let exitResult;
+	let unsubscribeBeforeExit;
+	let restoreConsole;
+	const capturedStdioTails = {
 		stdout: "",
 		stderr: ""
 	};
-	unsubscribeResize;
-	throttledOnRender;
-	hasPendingThrottledRender = false;
-	kittyProtocolEnabled = false;
-	kittyFlags;
-	cancelKittyDetection;
-	nextRenderCommit;
-	isSuspended = false;
-	pauseInput;
-	resumeInput;
-	constructor(options) {
-		autoBind(this);
-		if (options.patchConsole === "stdio") {
-			this.captureTargets = {
-				stdout: options.stdout,
-				stderr: options.stderr
-			};
-			options = {
-				...options,
-				stdout: createRenderPassthrough(options.stdout),
-				stderr: createRenderPassthrough(options.stderr)
-			};
-		}
-		this.options = options;
-		this.rootNode = createNode("ink-root");
-		this.rootNode.onComputeLayout = this.calculateLayout;
-		this.isScreenReaderEnabled = options.isScreenReaderEnabled ?? process.env["SIGIL_SCREEN_READER"] === "true";
-		this.interactive = this.resolveInteractiveOption(options.interactive);
-		this.alternateScreen = false;
-		const unthrottled = options.debug || this.isScreenReaderEnabled;
-		const maxFps = options.maxFps ?? 30;
-		const renderThrottleMs = maxFps > 0 ? Math.max(1, Math.ceil(1e3 / maxFps)) : 0;
-		this.renderThrottleMs = unthrottled ? 0 : renderThrottleMs;
-		if (unthrottled) {
-			this.rootNode.onRender = this.onRender;
-			this.throttledOnRender = void 0;
-		} else {
-			const throttled = throttle(this.onRender, renderThrottleMs);
-			this.rootNode.onRender = () => {
-				this.hasPendingThrottledRender = true;
-				throttled();
-			};
-			this.throttledOnRender = throttled;
-		}
-		this.rootNode.onImmediateRender = this.onRender;
-		this.rootNode.onStaticChange = this.handleStaticChange;
-		this.log = logUpdate.create(options.stdout, { incremental: options.incrementalRendering });
-		this.cursorPosition = void 0;
-		this.throttledLog = unthrottled ? this.log : throttle((output) => {
-			const shouldWrite = this.log.willRender(output);
-			const sync = this.shouldSync();
-			if (sync && shouldWrite) this.options.stdout.write(bsu);
-			this.log(output);
-			if (sync && shouldWrite) this.options.stdout.write(esu);
-		});
-		this.isUnmounted = false;
-		this.isUnmounting = false;
-		this.isConcurrent = options.concurrent ?? false;
-		this.lastOutput = "";
-		this.lastOutputToRender = "";
-		this.lastOutputHeight = 0;
-		this.lastTerminalWidth = getWindowSize(this.options.stdout).columns;
-		this.lastTerminalHeight = getWindowSize(this.options.stdout).rows;
-		this.fullStaticOutput = "";
-		const rootTag = options.concurrent ? ConcurrentRoot : LegacyRoot;
-		this.container = reconciler.createContainer(this.rootNode, rootTag, null, false, null, "id", () => {}, () => {}, () => {}, () => {});
-		this.unsubscribeExit = signalExit(this.unmount.bind(this), { alwaysLast: false });
-		this.setAlternateScreen(Boolean(options.alternateScreen));
-		if (process.env["SIGIL_DEV"] === "true") reconciler.injectIntoDevTools();
-		if (options.patchConsole) this.patchConsole();
-		if (this.interactive) {
-			options.stdout.on("resize", this.resized);
-			this.unsubscribeResize = () => {
-				options.stdout.off("resize", this.resized);
-			};
-		}
-		this.initKittyKeyboard();
-		this.exitPromise = new Promise((resolve, reject) => {
-			this.resolveExitPromise = resolve;
-			this.rejectExitPromise = reject;
-		});
-		this.exitPromise.catch(noop);
+	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) {
+		options.stdout.on("resize", resized);
+		unsubscribeResize = () => {
+			options.stdout.off("resize", resized);
+		};
 	}
-	resized = () => {
-		const currentWidth = getWindowSize(this.options.stdout).columns;
-		const currentHeight = getWindowSize(this.options.stdout).rows;
-		if (currentWidth < this.lastTerminalWidth || currentHeight !== this.lastTerminalHeight) {
-			this.log.clear();
-			this.lastOutput = "";
-			this.lastOutputToRender = "";
-			this.lastOutputHeight = 0;
-		}
-		this.calculateLayout();
-		emitLayoutListeners(this.rootNode);
-		this.onRender();
-		this.lastTerminalWidth = currentWidth;
-		this.lastTerminalHeight = currentHeight;
-	};
-	resolveExitPromise = () => {};
-	rejectExitPromise = () => {};
-	unsubscribeExit = () => {};
-	handleAppExit = (errorOrResult) => {
-		if (this.isUnmounted || this.isUnmounting) return;
+	initKittyKeyboard();
+	const { promise: exitPromise, resolve: resolveExitPromise, reject: rejectExitPromise } = Promise.withResolvers();
+	exitPromise.catch(noop);
+	function resized() {
+		const currentWidth = getWindowSize(options.stdout).columns;
+		const currentHeight = getWindowSize(options.stdout).rows;
+		if (currentWidth < lastTerminalWidth || currentHeight !== lastTerminalHeight) {
+			clearLiveOutput();
+			resetLiveOutput();
+			lastOutput = "";
+			lastOutputToRender = "";
+			lastOutputHeight = 0;
+		}
+		calculateLayout();
+		emitLayoutListeners(rootNode);
+		onRender();
+		lastTerminalWidth = currentWidth;
+		lastTerminalHeight = currentHeight;
+	}
+	function handleAppExit(errorOrResult) {
+		if (isUnmounted || isUnmounting) return;
 		if (isErrorInput(errorOrResult)) {
-			this.unmount(errorOrResult);
+			unmount(errorOrResult);
 			return;
 		}
-		this.exitResult = errorOrResult;
-		this.unmount();
-	};
-	setCursorPosition = (position) => {
-		this.cursorPosition = position;
-		this.log.setCursorPosition(position);
-	};
-	restoreLastOutput = () => {
-		if (!this.interactive) return;
-		this.log.setCursorPosition(this.cursorPosition);
-		this.log(this.lastOutputToRender || this.lastOutput + "\n");
-	};
-	calculateLayout = () => {
-		const terminalWidth = getWindowSize(this.options.stdout).columns;
-		this.rootNode.yogaNode.setWidth(terminalWidth);
-		this.rootNode.yogaNode.calculateLayout(void 0, void 0, Yoga.DIRECTION_LTR);
-	};
-	handleStaticChange = () => {
-		this.fullStaticOutput = "";
-	};
-	onRender = () => {
-		this.hasPendingThrottledRender = false;
-		if (this.isUnmounted) return;
-		if (this.isSuspended) {
-			if (this.nextRenderCommit) {
-				this.nextRenderCommit.resolve();
-				this.nextRenderCommit = void 0;
+		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() {
+		if (isScreenReaderEnabled) accessiblePresenter.clear();
+		else terminal.clearFrame();
+	}
+	function finishLiveOutput() {
+		if (isScreenReaderEnabled) accessiblePresenter.done();
+		else terminal.finishFrame();
+	}
+	function resetLiveOutput() {
+		if (isScreenReaderEnabled) accessiblePresenter.reset();
+		else terminal.resetFrame();
+	}
+	function calculateLayout() {
+		const terminalWidth = getWindowSize(options.stdout).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 (this.nextRenderCommit) {
-			this.nextRenderCommit.resolve();
-			this.nextRenderCommit = void 0;
+		if (nextRenderCommit) {
+			nextRenderCommit.resolve();
+			nextRenderCommit = void 0;
 		}
 		const startTime = performance.now();
-		const { output, outputHeight, staticOutput } = renderer(this.rootNode, this.isScreenReaderEnabled);
-		this.options.onRender?.({ renderTime: performance.now() - startTime });
+		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 (this.options.debug) {
-			if (hasStaticOutput) this.fullStaticOutput += staticOutput;
-			this.lastOutput = output;
-			this.lastOutputToRender = output;
-			this.lastOutputHeight = outputHeight;
-			this.options.stdout.write(this.fullStaticOutput + output);
+		if (options.debug) {
+			if (hasStaticOutput) fullStaticOutput += staticOutput;
+			lastOutput = output;
+			lastOutputToRender = output;
+			lastOutputHeight = outputHeight;
+			options.stdout.write(fullStaticOutput + output);
 			return;
 		}
-		if (!this.interactive) {
-			if (hasStaticOutput) this.options.stdout.write(staticOutput);
-			this.lastOutput = output;
-			this.lastOutputToRender = output + "\n";
-			this.lastOutputHeight = outputHeight;
+		if (!interactive) {
+			if (hasStaticOutput) options.stdout.write(staticOutput);
+			lastOutput = output;
+			lastOutputToRender = output + "\n";
+			lastOutputHeight = outputHeight;
 			return;
 		}
-		if (this.isScreenReaderEnabled) {
-			const sync = this.shouldSync();
-			if (sync) this.options.stdout.write(bsu);
+		if (isScreenReaderEnabled) {
+			const sync = shouldSync();
+			if (sync) options.stdout.write(bsu);
 			if (hasStaticOutput) {
-				const erase = this.lastOutputHeight > 0 ? ansiEscapes.eraseLines(this.lastOutputHeight) : "";
-				this.options.stdout.write(erase + staticOutput);
-				this.lastOutputHeight = 0;
+				const erase = lastOutputHeight > 0 ? ansiEscapes.eraseLines(lastOutputHeight) : "";
+				options.stdout.write(erase + staticOutput);
+				lastOutputHeight = 0;
 			}
-			if (output === this.lastOutput && !hasStaticOutput) {
-				if (sync) this.options.stdout.write(esu);
+			if (output === lastOutput && !hasStaticOutput) {
+				if (sync) options.stdout.write(esu);
 				return;
 			}
-			const terminalWidth = getWindowSize(this.options.stdout).columns;
+			const terminalWidth = getWindowSize(options.stdout).columns;
 			const wrappedOutput = wrapAnsi(output, terminalWidth, {
 				trim: false,
 				hard: true
 			});
-			if (hasStaticOutput) this.options.stdout.write(wrappedOutput);
+			if (hasStaticOutput) options.stdout.write(wrappedOutput);
 			else {
-				const erase = this.lastOutputHeight > 0 ? ansiEscapes.eraseLines(this.lastOutputHeight) : "";
-				this.options.stdout.write(erase + wrappedOutput);
+				const erase = lastOutputHeight > 0 ? ansiEscapes.eraseLines(lastOutputHeight) : "";
+				options.stdout.write(erase + wrappedOutput);
 			}
-			this.lastOutput = output;
-			this.lastOutputToRender = wrappedOutput;
-			this.lastOutputHeight = wrappedOutput === "" ? 0 : wrappedOutput.split("\n").length;
-			if (sync) this.options.stdout.write(esu);
+			lastOutput = output;
+			lastOutputToRender = wrappedOutput;
+			lastOutputHeight = wrappedOutput === "" ? 0 : wrappedOutput.split("\n").length;
+			if (sync) options.stdout.write(esu);
 			return;
 		}
-		if (hasStaticOutput) this.fullStaticOutput += staticOutput;
-		this.renderInteractiveFrame(output, outputHeight, hasStaticOutput ? staticOutput : "");
-	};
-	render(node) {
+		if (hasStaticOutput) fullStaticOutput += staticOutput;
+		renderInteractiveFrame(output, outputHeight, hasStaticOutput ? staticOutput : "", screen, false);
+	}
+	function render(node) {
 		const tree = /* @__PURE__ */ jsx(accessibilityContext.Provider, {
-			value: { isScreenReaderEnabled: this.isScreenReaderEnabled },
-			children: /* @__PURE__ */ jsx(App, {
-				stdin: this.options.stdin,
-				stdout: this.options.stdout,
-				stderr: this.options.stderr,
-				exitOnCtrlC: this.options.exitOnCtrlC,
-				interactive: this.interactive,
-				renderThrottleMs: this.renderThrottleMs,
-				writeToStdout: this.writeToStdout.bind(this),
-				writeToStderr: this.writeToStderr.bind(this),
-				setCursorPosition: this.setCursorPosition.bind(this),
-				onExit: this.handleAppExit.bind(this),
-				onWaitUntilRenderFlush: this.waitUntilRenderFlush.bind(this),
-				onSuspendTerminal: this.suspendTerminal.bind(this),
-				onRegisterInputControl: this.registerInputControl.bind(this),
-				children: node
+			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 (this.options.concurrent) reconciler.updateContainer(tree, this.container, null, noop);
+		if (isConcurrent) reconciler.updateContainer(tree, container, null, noop);
 		else {
-			reconciler.updateContainerSync(tree, this.container, null, noop);
+			reconciler.updateContainerSync(tree, container, null, noop);
 			reconciler.flushSyncWork();
 		}
 	}
-	writeToStdout(data) {
-		if (this.isUnmounted) return;
-		if (this.isSuspended) return;
-		if (this.options.debug) {
-			this.options.stdout.write(data + this.fullStaticOutput + this.lastOutput);
+	function writeToStdout(data) {
+		if (isUnmounted) return;
+		if (terminal.suspended) return;
+		if (options.debug) {
+			options.stdout.write(data + fullStaticOutput + lastOutput);
 			return;
 		}
-		if (!this.interactive) {
-			this.options.stdout.write(data);
+		if (!interactive) {
+			options.stdout.write(data);
 			return;
 		}
-		const sync = this.shouldSync();
-		if (sync) this.options.stdout.write(bsu);
-		this.log.clear();
-		this.options.stdout.write(data);
-		this.restoreLastOutput();
-		if (sync) this.options.stdout.write(esu);
-	}
-	writeToStderr(data) {
-		if (this.isUnmounted) return;
-		if (this.isSuspended) return;
-		if (this.options.debug) {
-			this.options.stderr.write(data);
-			this.options.stdout.write(this.fullStaticOutput + this.lastOutput);
+		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 (!this.interactive) {
-			this.options.stderr.write(data);
+		if (!interactive) {
+			options.stderr.write(data);
 			return;
 		}
-		const sync = this.shouldSync();
-		if (sync) this.options.stdout.write(bsu);
-		this.log.clear();
-		this.options.stderr.write(data);
-		this.restoreLastOutput();
-		if (sync) this.options.stdout.write(esu);
-	}
-	unmount(error) {
-		if (this.isUnmounted || this.isUnmounting) return;
-		this.isUnmounting = true;
-		if (this.beforeExitHandler) {
-			process.off("beforeExit", this.beforeExitHandler);
-			this.beforeExitHandler = void 0;
-		}
-		const { stdout } = this.options;
-		const { canWriteToStdout } = getWritableStreamState(stdout);
-		if (canWriteToStdout) this.flushCapturedStdio();
-		settleThrottle(this.throttledOnRender, canWriteToStdout);
+		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;
+		unsubscribeBeforeExit?.();
+		unsubscribeBeforeExit = void 0;
+		const { canWriteToStdout } = getWritableStreamState(options.stdout);
+		if (canWriteToStdout) flushCapturedStdio();
+		settleThrottle(renderScheduler.throttled, canWriteToStdout);
 		if (canWriteToStdout) {
-			if (!this.throttledOnRender || !this.hasPendingThrottledRender && this.fullStaticOutput === "") {
-				this.calculateLayout();
-				this.onRender();
+			if (!renderScheduler.throttled || !renderScheduler.pending && fullStaticOutput === "") {
+				calculateLayout();
+				onRender();
 			}
 		}
-		this.isUnmounted = true;
-		this.unsubscribeExit();
-		settleThrottle(this.throttledLog, canWriteToStdout);
-		if (typeof this.restoreConsole === "function") this.restoreConsole();
+		isUnmounted = true;
+		unsubscribeExit();
+		terminal.cleanup();
+		if (typeof restoreConsole === "function") restoreConsole();
 		const finishUnmount = () => {
-			if (typeof this.unsubscribeResize === "function") this.unsubscribeResize();
-			if (this.cancelKittyDetection) this.cancelKittyDetection();
+			if (typeof unsubscribeResize === "function") unsubscribeResize();
+			if (cancelKittyDetection) cancelKittyDetection();
 			if (canWriteToStdout) {
-				if (this.kittyProtocolEnabled) this.writeBestEffort(this.options.stdout, ansiEscapes.popKittyKeyboard);
-				if (this.alternateScreen) {
-					this.writeBestEffort(this.options.stdout, ansiEscapes.exitAlternativeScreen);
-					this.writeBestEffort(this.options.stdout, showCursorEscape);
-					this.alternateScreen = false;
+				if (kittyProtocolEnabled) writeBestEffort(options.stdout, ansiEscapes.popKittyKeyboard);
+				if (terminal.alternateScreen) {
+					terminal.setAlternateScreen(false);
+					terminal.setCursorAppearance({ visible: true });
 				}
-				if (!this.interactive) this.options.stdout.write(this.options.debug ? "\n" : this.lastOutput + "\n");
-				else if (!this.options.debug) this.log.done();
+				if (!interactive) options.stdout.write(options.debug ? "\n" : lastOutput + "\n");
+				else if (!options.debug) finishLiveOutput();
 			}
-			this.kittyProtocolEnabled = false;
-			instances.delete(this.captureTargets?.stdout ?? this.options.stdout);
-			const { exitResult } = this;
+			kittyProtocolEnabled = false;
+			instances.delete(captureTargets?.stdout ?? options.stdout);
+			const finalExitResult = exitResult;
 			const resolveOrReject = () => {
-				if (isErrorInput(error)) this.rejectExitPromise(error);
-				else this.resolveExitPromise(exitResult);
+				if (isErrorInput(error)) rejectExitPromise(error);
+				else resolveExitPromise(finalExitResult);
 			};
 			if (error !== void 0 && !isErrorInput(error)) resolveOrReject();
-			else if (canWriteToStdout) this.options.stdout.write("", resolveOrReject);
+			else if (canWriteToStdout) options.stdout.write("", resolveOrReject);
 			else setImmediate(resolveOrReject);
 		};
 		const concurrentReconciler = reconciler;
-		if (this.options.concurrent) {
-			reconciler.updateContainerSync(null, this.container, null, noop);
+		if (isConcurrent) {
+			reconciler.updateContainerSync(null, container, null, noop);
 			reconciler.flushSyncWork();
 			concurrentReconciler.flushPassiveEffects?.();
 			finishUnmount();
 		} else {
-			reconciler.updateContainerSync(null, this.container, null, noop);
+			reconciler.updateContainerSync(null, container, null, noop);
 			reconciler.flushSyncWork();
 			finishUnmount();
 		}
 	}
-	async waitUntilExit() {
-		if (!this.beforeExitHandler) {
-			this.beforeExitHandler = () => {
-				this.unmount();
-			};
-			process.once("beforeExit", this.beforeExitHandler);
-		}
-		return this.exitPromise;
+	async function waitUntilExit() {
+		if (!unsubscribeBeforeExit) unsubscribeBeforeExit = registerBeforeExit(() => {
+			unmount();
+		});
+		return exitPromise;
 	}
-	async waitUntilRenderFlush() {
-		if (this.isUnmounted || this.isUnmounting) {
-			await this.awaitExit();
+	async function waitUntilRenderFlush() {
+		if (isUnmounted || isUnmounting) {
+			await awaitExit();
 			return;
 		}
-		await yieldImmediate();
-		if (this.isUnmounted || this.isUnmounting) {
-			await this.awaitExit();
+		await setImmediate$1();
+		if (isUnmounted || isUnmounting) {
+			await awaitExit();
 			return;
 		}
-		if (this.isConcurrent && this.hasPendingConcurrentWork()) {
-			await Promise.race([this.awaitNextRender(), this.awaitExit()]);
-			if (this.isUnmounted || this.isUnmounting) {
-				this.nextRenderCommit = void 0;
-				await this.awaitExit();
+		if (isConcurrent && hasPendingConcurrentWork()) {
+			await Promise.race([awaitNextRender(), awaitExit()]);
+			if (isUnmounted || isUnmounting) {
+				nextRenderCommit = void 0;
+				await awaitExit();
 				return;
 			}
 		}
 		reconciler.flushSyncWork();
-		const { stdout } = this.options;
-		const { canWriteToStdout } = getWritableStreamState(stdout);
-		settleThrottle(this.throttledOnRender, canWriteToStdout);
-		settleThrottle(this.throttledLog, canWriteToStdout);
+		const { canWriteToStdout } = getWritableStreamState(options.stdout);
+		settleThrottle(renderScheduler.throttled, canWriteToStdout);
 		if (canWriteToStdout) {
 			await new Promise((resolve) => {
-				this.options.stdout.write("", () => {
+				options.stdout.write("", () => {
 					resolve();
 				});
 			});
 			return;
 		}
-		await yieldImmediate();
+		await setImmediate$1();
 	}
-	clear() {
-		if (this.interactive && !this.options.debug) {
-			this.log.clear();
-			this.log.sync(this.lastOutputToRender || this.lastOutput + "\n");
+	function clear() {
+		if (interactive && !options.debug) {
+			clearLiveOutput();
+			if (isScreenReaderEnabled) accessiblePresenter.sync(lastOutputToRender || lastOutput + "\n");
 		}
 	}
-	patchConsole() {
-		if (this.options.debug) return;
+	function installConsolePatch() {
+		if (options.debug) return;
 		const restoreConsoleMethods = patchConsole((stream, data) => {
-			if (this.options.onCapturedOutput?.(stream, data, "console") === true) return;
-			if (stream === "stdout") this.writeToStdout(data);
+			if (options.onCapturedOutput?.(stream, data, "console") === true) return;
+			if (stream === "stdout") writeToStdout(data);
 			if (stream === "stderr") {
-				if (!data.startsWith("The above error occurred")) this.writeToStderr(data);
+				if (!data.startsWith("The above error occurred")) writeToStderr(data);
 			}
 		});
-		const restoreDirectStdio = this.patchDirectStdio();
-		this.restoreConsole = () => {
+		const restoreDirectStdio = patchDirectStdio();
+		restoreConsole = () => {
 			restoreConsoleMethods();
 			restoreDirectStdio?.();
 		};
 	}
-	patchDirectStdio() {
-		const targets = this.captureTargets;
-		if (!targets) return;
-		const patch = (name, stream) => {
-			const originalWrite = stream.write;
-			const patchedWrite = (chunk, encodingOrCallback, callback) => {
-				const data = typeof chunk === "string" ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk).toString() : String(chunk);
-				this.handleCapturedStdio(name, data);
-				(typeof encodingOrCallback === "function" ? encodingOrCallback : typeof callback === "function" ? callback : void 0)?.();
-				return true;
-			};
-			stream.write = patchedWrite;
-			return () => {
-				stream.write = originalWrite;
-			};
-		};
-		const restoreStdout = patch("stdout", targets.stdout);
-		const restoreStderr = patch("stderr", targets.stderr);
+	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();
 		};
 	}
-	handleCapturedStdio(stream, data) {
-		if (this.options.onCapturedOutput?.(stream, data, "stdio") === true) return;
-		const parts = (this.capturedStdioTails[stream] + data).split(/\r?\n/);
-		this.capturedStdioTails[stream] = parts.pop() ?? "";
+	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") this.writeToStdout(payload);
-		else this.writeToStderr(payload);
+		if (stream === "stdout") writeToStdout(payload);
+		else writeToStderr(payload);
 	}
-	flushCapturedStdio() {
+	function flushCapturedStdio() {
 		for (const stream of ["stdout", "stderr"]) {
-			const tail = this.capturedStdioTails[stream];
+			const tail = capturedStdioTails[stream];
 			if (tail === "") continue;
-			this.capturedStdioTails[stream] = "";
-			if (stream === "stdout") this.writeToStdout(tail + "\n");
-			else this.writeToStderr(tail + "\n");
+			capturedStdioTails[stream] = "";
+			if (stream === "stdout") writeToStdout(tail + "\n");
+			else writeToStderr(tail + "\n");
 		}
 	}
-	registerInputControl(pauseInput, resumeInput) {
-		this.pauseInput = pauseInput;
-		this.resumeInput = resumeInput;
+	function registerInputControl(pause, resume) {
+		pauseInput = pause;
+		resumeInput = resume;
 	}
-	async suspendTerminal(callback) {
-		this.beginSuspend();
+	async function suspendTerminal(callback) {
+		beginSuspend();
 		if (callback) {
 			try {
 				await callback();
 			} finally {
-				await this.endSuspend();
+				await endSuspend();
 			}
 			return;
 		}
 		const resume = async () => {
-			await this.endSuspend();
+			await endSuspend();
 		};
 		return {
 			resume,
 			[Symbol.asyncDispose]: resume
 		};
 	}
-	setAlternateScreen(enabled) {
-		this.alternateScreen = this.resolveAlternateScreenOption(enabled, this.interactive);
-		if (this.alternateScreen) {
-			this.writeBestEffort(this.options.stdout, ansiEscapes.enterAlternativeScreen);
-			this.writeBestEffort(this.options.stdout, hideCursorEscape);
-		}
-	}
-	resolveInteractiveOption(interactive) {
-		return interactive ?? (!isInCi && Boolean(this.options.stdout.isTTY));
-	}
-	resolveAlternateScreenOption(alternateScreen, interactive) {
-		return Boolean(alternateScreen) && interactive && Boolean(this.options.stdout.isTTY);
+	function setAlternateScreen(enabled) {
+		terminal.setAlternateScreen(enabled && interactive && Boolean(options.stdout.isTTY), { hideCursor: true });
 	}
-	shouldSync() {
-		return shouldSynchronize(this.options.stdout, this.interactive);
-	}
-	writeBestEffort(stream, data) {
-		try {
-			stream.write(data);
-		} catch {}
+	function shouldSync() {
+		return Boolean(options.stdout.isTTY) && interactive;
 	}
-	async awaitExit() {
+	async function awaitExit() {
 		try {
-			await this.exitPromise;
+			await exitPromise;
 		} catch {}
 	}
-	hasPendingConcurrentWork() {
-		const concurrentContainer = this.container;
+	function hasPendingConcurrentWork() {
+		const concurrentContainer = container;
 		return (concurrentContainer.pendingLanes ?? 0) !== 0 && concurrentContainer.callbackNode !== void 0 && concurrentContainer.callbackNode !== null;
 	}
-	async awaitNextRender() {
-		if (!this.nextRenderCommit) {
-			let resolveRender;
-			const promise = new Promise((resolve) => {
-				resolveRender = resolve;
-			});
-			this.nextRenderCommit = {
-				promise,
-				resolve: resolveRender
-			};
-		}
-		return this.nextRenderCommit.promise;
+	async function awaitNextRender() {
+		nextRenderCommit ??= Promise.withResolvers();
+		return nextRenderCommit.promise;
 	}
-	renderInteractiveFrame(output, outputHeight, staticOutput) {
+	function renderInteractiveFrame(output, outputHeight, staticOutput, screen, hasOverflow) {
+		if (!screen) return;
 		const hasStaticOutput = staticOutput !== "";
-		const isTTY = Boolean(this.options.stdout.isTTY);
-		const viewportRows = isTTY ? getWindowSize(this.options.stdout).rows : 24;
+		const isTTY = Boolean(options.stdout.isTTY);
+		const viewportRows = isTTY ? getWindowSize(options.stdout).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 outputToRender = isTTY && outputHeight >= viewportRows ? output : output + "\n";
+		const isFullscreen = isTTY && outputHeight >= viewportRows;
+		const outputToRender = isFullscreen ? output : output + "\n";
 		if (shouldClearTerminalForFrame({
 			isTTY,
 			viewportRows,
-			previousOutputHeight: this.lastOutputHeight,
+			previousOutputHeight: lastOutputHeight,
 			nextOutputHeight: outputHeight,
-			isUnmounting: this.isUnmounting
+			isUnmounting
 		})) {
-			const sync = this.shouldSync();
-			if (sync) this.options.stdout.write(bsu);
-			this.options.stdout.write(ansiEscapes.clearTerminal + this.fullStaticOutput + outputToRender);
-			this.lastOutput = output;
-			this.lastOutputToRender = outputToRender;
-			this.lastOutputHeight = outputHeight;
-			this.log.sync(outputToRender);
-			if (sync) this.options.stdout.write(esu);
+			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) {
-			const sync = this.shouldSync();
-			if (sync) this.options.stdout.write(bsu);
-			this.log.clear();
-			this.options.stdout.write(staticOutput);
-			this.log(outputToRender);
-			if (sync) this.options.stdout.write(esu);
-		} else if (output !== this.lastOutput || this.log.isCursorDirty()) this.throttledLog(outputToRender);
-		this.lastOutput = output;
-		this.lastOutputToRender = outputToRender;
-		this.lastOutputHeight = outputHeight;
-	}
-	initKittyKeyboard() {
-		if (!this.options.kittyKeyboard) return;
-		const opts = this.options.kittyKeyboard;
+			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(this.options.stdin) && this.options.stdout.isTTY) this.enableKittyProtocol(flags);
+			if (isTty(options.stdin) && options.stdout.isTTY) enableKittyProtocol(flags);
 			return;
 		}
-		if (!this.interactive || !isTty(this.options.stdin) || !this.options.stdout.isTTY) return;
-		this.confirmKittySupport(flags);
-	}
-	confirmKittySupport(flags) {
-		const { stdin, stdout } = this.options;
-		let responseBuffer = [];
-		const cleanup = () => {
-			this.cancelKittyDetection = void 0;
-			clearTimeout(timer);
-			stdin.removeListener("data", onData);
-			const remaining = stripKittyQueryResponsesAndTrailingPartial(responseBuffer);
-			responseBuffer = [];
-			if (remaining.length > 0) stdin.unshift(Uint8Array.from(remaining));
-		};
-		const onData = (data) => {
-			const chunk = typeof data === "string" ? textEncoder.encode(data) : data;
-			for (const byte of chunk) responseBuffer.push(byte);
-			if (hasCompleteKittyQueryResponse(responseBuffer)) {
-				cleanup();
-				if (!this.isUnmounted) this.enableKittyProtocol(flags);
-			}
-		};
-		stdin.on("data", onData);
-		const timer = setTimeout(cleanup, 200);
-		this.cancelKittyDetection = cleanup;
-		stdout.write(ansiEscapes.kittyQuery);
+		if (!interactive || !isTty(options.stdin) || !options.stdout.isTTY) return;
+		cancelKittyDetection = detectKittySupport(options.stdin, options.stdout, () => {
+			cancelKittyDetection = void 0;
+			if (!isUnmounted) enableKittyProtocol(flags);
+		});
 	}
-	enableKittyProtocol(flags) {
-		this.options.stdout.write(ansiEscapes.pushKittyKeyboard(resolveFlags(flags)));
-		this.kittyProtocolEnabled = true;
-		this.kittyFlags = flags;
+	function enableKittyProtocol(flags) {
+		options.stdout.write(ansiEscapes.pushKittyKeyboard(resolveFlags(flags)));
+		kittyProtocolEnabled = true;
+		kittyFlags = flags;
 	}
-	beginSuspend() {
-		if (this.isSuspended) throw new Error("The terminal is already suspended. Resume the current suspension before suspending again.");
-		this.isSuspended = true;
-		if (!this.interactive || this.isUnmounted || this.isUnmounting) return;
+	function beginSuspend() {
+		terminal.beginSuspension();
+		if (!interactive || isUnmounted || isUnmounting) return;
 		try {
-			const { stdout } = this.options;
-			const { canWriteToStdout } = getWritableStreamState(stdout);
-			settleThrottle(this.throttledOnRender, canWriteToStdout);
-			settleThrottle(this.throttledLog, canWriteToStdout);
-			if (canWriteToStdout) this.flushCapturedStdio();
+			const { canWriteToStdout } = getWritableStreamState(options.stdout);
+			settleThrottle(renderScheduler.throttled, canWriteToStdout);
+			if (canWriteToStdout) flushCapturedStdio();
 			if (canWriteToStdout) {
-				this.log.clear();
-				this.log.done();
-				if (this.kittyProtocolEnabled) this.writeBestEffort(this.options.stdout, ansiEscapes.popKittyKeyboard);
-				if (this.alternateScreen) this.writeBestEffort(this.options.stdout, ansiEscapes.exitAlternativeScreen);
+				clearLiveOutput();
+				finishLiveOutput();
+				if (kittyProtocolEnabled) writeBestEffort(options.stdout, ansiEscapes.popKittyKeyboard);
+				if (terminal.alternateScreen) writeBestEffort(options.stdout, ansiEscapes.exitAlternativeScreen);
 			}
-			this.pauseInput?.();
+			pauseInput?.();
 		} catch (error) {
-			this.isSuspended = false;
+			terminal.resume();
 			try {
-				this.resumeInput?.();
+				resumeInput?.();
 			} catch {}
 			throw error;
 		}
 	}
-	async endSuspend() {
-		if (!this.isSuspended) return;
-		this.isSuspended = false;
-		this.resumeInput?.();
-		if (!this.interactive || this.isUnmounted || this.isUnmounting) return;
-		const { stdout } = this.options;
-		const { canWriteToStdout } = getWritableStreamState(stdout);
+	async function endSuspend() {
+		if (!terminal.suspended) return;
+		terminal.resume();
+		resumeInput?.();
+		if (!interactive || isUnmounted || isUnmounting) return;
+		const { canWriteToStdout } = getWritableStreamState(options.stdout);
 		if (canWriteToStdout) {
-			if (this.alternateScreen) this.writeBestEffort(this.options.stdout, ansiEscapes.enterAlternativeScreen);
-			if (this.kittyProtocolEnabled && this.kittyFlags) this.writeBestEffort(this.options.stdout, ansiEscapes.pushKittyKeyboard(resolveFlags(this.kittyFlags)));
+			if (terminal.alternateScreen) writeBestEffort(options.stdout, ansiEscapes.enterAlternativeScreen);
+			if (kittyProtocolEnabled && kittyFlags) writeBestEffort(options.stdout, ansiEscapes.pushKittyKeyboard(resolveFlags(kittyFlags)));
 		}
-		this.lastOutput = "";
-		this.lastOutputToRender = "";
-		this.lastOutputHeight = 0;
-		this.log.reset();
+		lastOutput = "";
+		lastOutputToRender = "";
+		lastOutputHeight = 0;
+		resetLiveOutput();
 		try {
-			this.calculateLayout();
-			this.onRender();
-			await this.waitUntilRenderFlush();
+			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
@@ -3624,24 +2347,25 @@ const render = (node, options) => {
 		exitOnCtrlC: true,
 		patchConsole: true,
 		maxFps: 30,
-		incrementalRendering: false,
 		concurrent: false,
 		alternateScreen: false,
 		...getOptions(options)
 	};
-	const instance = getInstance(inkOptions.stdout, () => new Ink(inkOptions));
+	const instance = getInstance(inkOptions.stdout, () => createInk(inkOptions));
 	instance.render(node);
 	return {
-		rerender: instance.render.bind(instance),
+		rerender: instance.render,
 		unmount() {
 			instance.unmount();
 		},
-		waitUntilExit: instance.waitUntilExit.bind(instance),
-		waitUntilRenderFlush: instance.waitUntilRenderFlush.bind(instance),
+		waitUntilExit: instance.waitUntilExit,
+		waitUntilRenderFlush: instance.waitUntilRenderFlush,
 		cleanup() {
 			instance.unmount();
 		},
-		clear: instance.clear.bind(instance)
+		clear: instance.clear,
+		copyToClipboard: instance.copyToClipboard,
+		setProgress: instance.setProgress
 	};
 };
 const getOptions = (stdout = {}) => {
@@ -3692,6 +2416,7 @@ 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 = () => {
@@ -3699,7 +2424,11 @@ const renderToString = (node, options) => {
 		rootNode.yogaNode.calculateLayout(void 0, void 0, Yoga.DIRECTION_LTR);
 	};
 	rootNode.onImmediateRender = () => {
-		const { staticOutput } = renderer(rootNode, false);
+		const { staticScreen } = renderFrame(rootNode, false, { colorProfile });
+		const staticOutput = staticScreen ? `${serializeScreen(staticScreen, {
+			colorProfile,
+			styles: colorProfile !== "none"
+		})}\n` : "";
 		if (staticOutput && staticOutput !== "\n") capturedStaticOutput += staticOutput;
 	};
 	let uncaughtError;
@@ -3708,7 +2437,11 @@ const renderToString = (node, options) => {
 	}, () => {}, () => {}, () => {});
 	reconciler.updateContainerSync(node, container, null, () => {});
 	reconciler.flushSyncWork();
-	const { output } = renderer(rootNode, false);
+	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));
@@ -3717,6 +2450,30 @@ const renderToString = (node, options) => {
 	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 */
 /**
@@ -3769,6 +2526,44 @@ function Transform({ children, transform, accessibilityLabel }) {
 	});
 }
 //#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.
@@ -3788,488 +2583,60 @@ function Spacer() {
 	return /* @__PURE__ */ jsx(Box, { flexGrow: 1 });
 }
 //#endregion
-//#region src/parse-keypress.ts
-const textDecoder = new TextDecoder();
-const metaKeyCodeRe = /^(?:\x1b)([a-zA-Z0-9])$/;
-const fnKeyRe = /^(?:\x1b+)(O|N|\[|\[\[)(?:(\d+)(?:;(\d+))?([~^$])|(?:1;)?(\d+)?([a-zA-Z]))/;
-const keyName = {
-	OP: "f1",
-	OQ: "f2",
-	OR: "f3",
-	OS: "f4",
-	"[P": "f1",
-	"[Q": "f2",
-	"[R": "f3",
-	"[S": "f4",
-	"[11~": "f1",
-	"[12~": "f2",
-	"[13~": "f3",
-	"[14~": "f4",
-	"[[A": "f1",
-	"[[B": "f2",
-	"[[C": "f3",
-	"[[D": "f4",
-	"[[E": "f5",
-	"[15~": "f5",
-	"[17~": "f6",
-	"[18~": "f7",
-	"[19~": "f8",
-	"[20~": "f9",
-	"[21~": "f10",
-	"[23~": "f11",
-	"[24~": "f12",
-	"[A": "up",
-	"[B": "down",
-	"[C": "right",
-	"[D": "left",
-	"[E": "clear",
-	"[F": "end",
-	"[H": "home",
-	OA: "up",
-	OB: "down",
-	OC: "right",
-	OD: "left",
-	OE: "clear",
-	OF: "end",
-	OH: "home",
-	"[1~": "home",
-	"[2~": "insert",
-	"[3~": "delete",
-	"[4~": "end",
-	"[5~": "pageup",
-	"[6~": "pagedown",
-	"[[5~": "pageup",
-	"[[6~": "pagedown",
-	"[7~": "home",
-	"[8~": "end",
-	"[a": "up",
-	"[b": "down",
-	"[c": "right",
-	"[d": "left",
-	"[e": "clear",
-	"[2$": "insert",
-	"[3$": "delete",
-	"[5$": "pageup",
-	"[6$": "pagedown",
-	"[7$": "home",
-	"[8$": "end",
-	Oa: "up",
-	Ob: "down",
-	Oc: "right",
-	Od: "left",
-	Oe: "clear",
-	"[2^": "insert",
-	"[3^": "delete",
-	"[5^": "pageup",
-	"[6^": "pagedown",
-	"[7^": "home",
-	"[8^": "end",
-	"[Z": "tab"
-};
-const nonAlphanumericKeys = [...Object.values(keyName), "backspace"];
-const isShiftKey = (code) => {
-	return [
-		"[a",
-		"[b",
-		"[c",
-		"[d",
-		"[e",
-		"[2$",
-		"[3$",
-		"[5$",
-		"[6$",
-		"[7$",
-		"[8$",
-		"[Z"
-	].includes(code);
-};
-const isCtrlKey = (code) => {
-	return [
-		"Oa",
-		"Ob",
-		"Oc",
-		"Od",
-		"Oe",
-		"[2^",
-		"[3^",
-		"[5^",
-		"[6^",
-		"[7^",
-		"[8^"
-	].includes(code);
-};
-const kittyKeyRe = /^\x1b\[(\d+)(?:;(\d+)(?::(\d+))?(?:;([\d:]+))?)?u$/;
-const kittySpecialKeyRe = /^\x1b\[(\d+);(\d+):(\d+)([A-Za-z~])$/;
-const kittySpecialLetterKeys = {
-	A: "up",
-	B: "down",
-	C: "right",
-	D: "left",
-	E: "clear",
-	F: "end",
-	H: "home",
-	P: "f1",
-	Q: "f2",
-	R: "f3",
-	S: "f4"
-};
-const kittySpecialNumberKeys = {
-	2: "insert",
-	3: "delete",
-	5: "pageup",
-	6: "pagedown",
-	7: "home",
-	8: "end",
-	11: "f1",
-	12: "f2",
-	13: "f3",
-	14: "f4",
-	15: "f5",
-	17: "f6",
-	18: "f7",
-	19: "f8",
-	20: "f9",
-	21: "f10",
-	23: "f11",
-	24: "f12"
-};
-const kittyCodepointNames = {
-	27: "escape",
-	9: "tab",
-	127: "backspace",
-	8: "backspace",
-	57358: "capslock",
-	57359: "scrolllock",
-	57360: "numlock",
-	57361: "printscreen",
-	57362: "pause",
-	57363: "menu",
-	57376: "f13",
-	57377: "f14",
-	57378: "f15",
-	57379: "f16",
-	57380: "f17",
-	57381: "f18",
-	57382: "f19",
-	57383: "f20",
-	57384: "f21",
-	57385: "f22",
-	57386: "f23",
-	57387: "f24",
-	57388: "f25",
-	57389: "f26",
-	57390: "f27",
-	57391: "f28",
-	57392: "f29",
-	57393: "f30",
-	57394: "f31",
-	57395: "f32",
-	57396: "f33",
-	57397: "f34",
-	57398: "f35",
-	57399: "kp0",
-	57400: "kp1",
-	57401: "kp2",
-	57402: "kp3",
-	57403: "kp4",
-	57404: "kp5",
-	57405: "kp6",
-	57406: "kp7",
-	57407: "kp8",
-	57408: "kp9",
-	57409: "kpdecimal",
-	57410: "kpdivide",
-	57411: "kpmultiply",
-	57412: "kpsubtract",
-	57413: "kpadd",
-	57414: "kpenter",
-	57415: "kpequal",
-	57416: "kpseparator",
-	57417: "kpleft",
-	57418: "kpright",
-	57419: "kpup",
-	57420: "kpdown",
-	57421: "kppageup",
-	57422: "kppagedown",
-	57423: "kphome",
-	57424: "kpend",
-	57425: "kpinsert",
-	57426: "kpdelete",
-	57427: "kpbegin",
-	57428: "mediaplay",
-	57429: "mediapause",
-	57430: "mediaplaypause",
-	57431: "mediareverse",
-	57432: "mediastop",
-	57433: "mediafastforward",
-	57434: "mediarewind",
-	57435: "mediatracknext",
-	57436: "mediatrackprevious",
-	57437: "mediarecord",
-	57438: "lowervolume",
-	57439: "raisevolume",
-	57440: "mutevolume",
-	57441: "leftshift",
-	57442: "leftcontrol",
-	57443: "leftalt",
-	57444: "leftsuper",
-	57445: "lefthyper",
-	57446: "leftmeta",
-	57447: "rightshift",
-	57448: "rightcontrol",
-	57449: "rightalt",
-	57450: "rightsuper",
-	57451: "righthyper",
-	57452: "rightmeta",
-	57453: "isoLevel3Shift",
-	57454: "isoLevel5Shift"
-};
-const isValidCodepoint = (cp) => cp >= 0 && cp <= 1114111 && !(cp >= 55296 && cp <= 57343);
-const safeFromCodePoint = (cp) => isValidCodepoint(cp) ? String.fromCodePoint(cp) : "?";
-function resolveEventType(value) {
-	if (value === 3) return "release";
-	if (value === 2) return "repeat";
-	return "press";
-}
-function parseKittyModifiers(modifiers) {
-	return {
-		ctrl: !!(modifiers & kittyModifiers.ctrl),
-		shift: !!(modifiers & kittyModifiers.shift),
-		meta: !!(modifiers & (kittyModifiers.meta | kittyModifiers.alt)),
-		super: !!(modifiers & kittyModifiers.super),
-		hyper: !!(modifiers & kittyModifiers.hyper),
-		capsLock: !!(modifiers & kittyModifiers.capsLock),
-		numLock: !!(modifiers & kittyModifiers.numLock)
-	};
-}
-const parseKittyKeypress = (s) => {
-	const match = kittyKeyRe.exec(s);
-	if (!match) return null;
-	const codepoint = parseInt(match[1], 10);
-	const modifiers = match[2] ? Math.max(0, parseInt(match[2], 10) - 1) : 0;
-	const eventType = match[3] ? parseInt(match[3], 10) : 1;
-	const textField = match[4];
-	if (!isValidCodepoint(codepoint)) return null;
-	let text;
-	if (textField) text = textField.split(":").map((cp) => safeFromCodePoint(parseInt(cp, 10))).join("");
-	let name;
-	let isPrintable;
-	if (codepoint === 32) {
-		name = "space";
-		isPrintable = true;
-	} else if (codepoint === 13) {
-		name = "return";
-		isPrintable = true;
-	} else if (kittyCodepointNames[codepoint]) {
-		name = kittyCodepointNames[codepoint];
-		isPrintable = false;
-	} else if (codepoint >= 1 && codepoint <= 26) {
-		name = String.fromCodePoint(codepoint + 96);
-		isPrintable = false;
-	} else {
-		name = safeFromCodePoint(codepoint).toLowerCase();
-		isPrintable = true;
-	}
-	if (isPrintable && !text) text = safeFromCodePoint(codepoint);
-	return {
-		name,
-		...parseKittyModifiers(modifiers),
-		eventType: resolveEventType(eventType),
-		sequence: s,
-		raw: s,
-		isKittyProtocol: true,
-		isPrintable,
-		text
-	};
-};
-const parseKittySpecialKey = (s) => {
-	const match = kittySpecialKeyRe.exec(s);
-	if (!match) return null;
-	const number = parseInt(match[1], 10);
-	const modifiers = Math.max(0, parseInt(match[2], 10) - 1);
-	const eventType = parseInt(match[3], 10);
-	const terminator = match[4];
-	const name = terminator === "~" ? kittySpecialNumberKeys[number] : kittySpecialLetterKeys[terminator];
-	if (!name) return null;
-	return {
-		name,
-		...parseKittyModifiers(modifiers),
-		eventType: resolveEventType(eventType),
-		sequence: s,
-		raw: s,
-		isKittyProtocol: true,
-		isPrintable: false
-	};
-};
-const parseKeypress = (s = "") => {
-	let parts;
-	if (s instanceof Uint8Array) {
-		if (s[0] > 127 && s[1] === void 0) {
-			s[0] -= 128;
-			s = "\x1B" + textDecoder.decode(s);
-		} else s = textDecoder.decode(s);
-	} else if (s !== void 0 && typeof s !== "string") s = String(s);
-	else if (!s) s = "";
-	const kittyResult = parseKittyKeypress(s);
-	if (kittyResult) return kittyResult;
-	const kittySpecialResult = parseKittySpecialKey(s);
-	if (kittySpecialResult) return kittySpecialResult;
-	if (kittyKeyRe.test(s)) return {
-		name: "",
-		ctrl: false,
-		meta: false,
-		shift: false,
-		sequence: s,
-		raw: s,
-		isKittyProtocol: true,
-		isPrintable: false
-	};
-	const key = {
-		name: "",
-		ctrl: false,
-		meta: false,
-		shift: false,
-		sequence: s,
-		raw: s
-	};
-	key.sequence = key.sequence || s || key.name;
-	if (s === "\r" || s === "\x1B\r") {
-		key.raw = void 0;
-		key.name = "return";
-		key.meta = s.length === 2;
-	} else if (s === "\n") key.name = "enter";
-	else if (s === "	") key.name = "tab";
-	else if (s === "\b" || s === "\x1B\b") {
-		key.name = "backspace";
-		key.meta = s.charAt(0) === "\x1B";
-	} else if (s === "" || s === "\x1B") {
-		key.name = "backspace";
-		key.meta = s.charAt(0) === "\x1B";
-	} else if (s === "\x1B" || s === "\x1B\x1B") {
-		key.name = "escape";
-		key.meta = s.length === 2;
-	} else if (s === " " || s === "\x1B ") {
-		key.name = "space";
-		key.meta = s.length === 2;
-	} else if (s.length === 1 && s <= "") {
-		key.name = String.fromCharCode(s.charCodeAt(0) + "a".charCodeAt(0) - 1);
-		key.ctrl = true;
-	} else if (s.length === 1 && s >= "0" && s <= "9") key.name = "number";
-	else if (s.length === 1 && s >= "a" && s <= "z") key.name = s;
-	else if (s.length === 1 && s >= "A" && s <= "Z") {
-		key.name = s.toLowerCase();
-		key.shift = true;
-	} else if (parts = metaKeyCodeRe.exec(s)) {
-		key.name = parts[1].toLowerCase();
-		key.meta = true;
-		key.shift = /^[A-Z]$/.test(parts[1]);
-	} else if (parts = fnKeyRe.exec(s)) {
-		const segs = [...s];
-		if (segs[0] === "\x1B" && segs[1] === "\x1B") key.meta = true;
-		const code = [
-			parts[1],
-			parts[2],
-			parts[4],
-			parts[6]
-		].filter(Boolean).join("");
-		const modifier = (parts[3] || parts[5] || 1) - 1;
-		key.ctrl = !!(modifier & 4);
-		key.meta = key.meta || !!(modifier & 10);
-		key.shift = !!(modifier & 1);
-		key.code = code;
-		key.name = keyName[code] ?? "";
-		key.shift = isShiftKey(code) || key.shift;
-		key.ctrl = isCtrlKey(code) || key.ctrl;
-	}
-	return key;
-};
-//#endregion
-//#region src/hooks/use-stdin.ts
+//#region src/hooks/use-capabilities.ts
 /**
-A React hook that returns the stdin stream and stdin-related utilities.
+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 useStdin = () => useContext(StdinContext);
-const useStdinContext = () => useContext(StdinContext);
-//#endregion
-//#region src/hooks/use-input.ts
+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;
+};
 /**
-A React hook that returns `void` and handles user input.
-It's a more convenient alternative to using `StdinContext` and listening for `data` events. The callback you pass to `useInput` is called for each character when the user enters any input. However, if the user pastes text and it's more than one character, the callback will be called only once, and the whole string will be passed as `input`.
-
-```
-import {useInput} from 'ink';
+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.
 
-const UserInput = () => {
-useInput((input, key) => {
-if (input === 'q') {
-// Exit program
-}
+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:
 
-if (key.leftArrow) {
-// Left arrow key pressed
+```tsx
+useCapabilitiesChange((next, previous) => {
+if (next.theme.appearance !== previous.theme.appearance) {
+// re-theme
 }
 });
-
-return …
-};
 ```
 */
-const useInput = (inputHandler, options = {}) => {
-	const { setRawMode, internal_exitOnCtrlC, internal_eventEmitter } = useStdinContext();
+const useCapabilitiesChange = (onChange) => {
+	const { stdout } = useStdout();
+	const { stdin } = useStdinContext();
+	const store = getCapabilities(stdin, stdout);
+	const handleChange = useEffectEvent(onChange);
 	useEffect(() => {
-		if (options.isActive === false) return;
-		setRawMode(true);
-		return () => {
-			setRawMode(false);
-		};
-	}, [options.isActive, setRawMode]);
-	const handleData = useEffectEvent((data) => {
-		const keypress = parseKeypress(data);
-		const key = {
-			upArrow: keypress.name === "up",
-			downArrow: keypress.name === "down",
-			leftArrow: keypress.name === "left",
-			rightArrow: keypress.name === "right",
-			pageDown: keypress.name === "pagedown",
-			pageUp: keypress.name === "pageup",
-			home: keypress.name === "home",
-			end: keypress.name === "end",
-			return: keypress.name === "return",
-			escape: keypress.name === "escape",
-			ctrl: keypress.ctrl,
-			shift: keypress.shift,
-			tab: keypress.name === "tab",
-			backspace: keypress.name === "backspace",
-			delete: keypress.name === "delete",
-			meta: keypress.meta,
-			super: keypress.super ?? false,
-			hyper: keypress.hyper ?? false,
-			capsLock: keypress.capsLock ?? false,
-			numLock: keypress.numLock ?? false,
-			eventType: keypress.eventType
-		};
-		let input;
-		if (keypress.isKittyProtocol) {
-			if (keypress.isPrintable) input = keypress.text ?? keypress.name;
-			else if (keypress.ctrl && keypress.name.length === 1) input = keypress.name;
-			else input = "";
-		} else if (keypress.ctrl) input = keypress.name ?? "";
-		else input = keypress.sequence;
-		if (!keypress.isKittyProtocol && nonAlphanumericKeys.includes(keypress.name)) input = "";
-		if (input.startsWith("\x1B")) input = input.slice(1);
-		if (input.length === 1 && /[A-Z]/.test(input)) key.shift = true;
-		if (input === "c" && key.ctrl && internal_exitOnCtrlC) return;
-		reconciler.discreteUpdates(() => {
-			inputHandler(input, key);
+		let previous = store.current;
+		const unsubscribe = store.subscribe((next) => {
+			const before = previous;
+			previous = next;
+			handleChange(next, before);
 		});
-	});
-	useEffect(() => {
-		if (options.isActive === false) return;
-		internal_eventEmitter.on("input", handleData);
-		return () => {
-			internal_eventEmitter.removeListener("input", handleData);
-		};
-	}, [options.isActive, internal_eventEmitter]);
+		store.query();
+		return unsubscribe;
+	}, [store]);
 };
 //#endregion
 //#region src/hooks/use-paste.ts
@@ -4333,66 +2700,12 @@ A React hook that returns app lifecycle methods like `exit()` and `waitUntilRend
 */
 const useApp = () => useContext(AppContext);
 //#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/hooks/use-stderr.ts
 /**
 A React hook that returns the stderr stream.
 */
 const useStderr = () => useContext(StderrContext);
 //#endregion
-//#region src/hooks/use-focus.ts
-/**
-A React hook that returns focus state and focus controls for the current component.
-A component that uses the `useFocus` hook becomes "focusable" to Ink, so when the user presses <kbd>Tab</kbd>, Ink will switch focus to this component. If there are multiple components that execute the `useFocus` hook, focus will be given to them in the order in which these components are rendered.
-*/
-const useFocus = ({ isActive = true, autoFocus = false, id: customId } = {}) => {
-	const { isRawModeSupported, setRawMode } = useStdin();
-	const { activeId, add, remove, activate, deactivate, focus } = useContext(FocusContext);
-	const id = useMemo(() => {
-		return customId ?? Math.random().toString().slice(2, 7);
-	}, [customId]);
-	useEffect(() => {
-		add(id, { autoFocus });
-		return () => {
-			remove(id);
-		};
-	}, [
-		id,
-		autoFocus,
-		add,
-		remove
-	]);
-	useEffect(() => {
-		if (isActive) activate(id);
-		else deactivate(id);
-	}, [
-		isActive,
-		id,
-		activate,
-		deactivate
-	]);
-	useEffect(() => {
-		if (!isRawModeSupported || !isActive) return;
-		setRawMode(true);
-		return () => {
-			setRawMode(false);
-		};
-	}, [
-		isActive,
-		isRawModeSupported,
-		setRawMode
-	]);
-	return {
-		isFocused: Boolean(id) && activeId === id,
-		focus
-	};
-};
-//#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.
@@ -4535,6 +2848,54 @@ function normalizeAnimationInterval(interval) {
 	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.
@@ -4649,4 +3010,4 @@ const measureElement = (node) => {
 	};
 };
 //#endregion
-export { Box, Newline, Spacer, Static, Text, Transform, kittyFlags, kittyModifiers, measureElement, render, renderToString, useAnimation, useApp, useBoxMetrics, useCursor, useFocus, useFocusManager, useInput, useIsScreenReaderEnabled, usePaste, useStderr, useStdin, useStdout, useWindowSize };
+export { AnsiText, Box, Hyperlink, Newline, Spacer, Static, Text, Transform, 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, useWindowSize, useWorkingDirectory };