@xp266/dshtui 0.1.0

package/lib/surface-DdxzIgIY.mjs

@@ -0,0 +1,3126 @@
+import chalk from "chalk";
+import { appendFileSync, chmodSync, mkdirSync, renameSync, statSync, unlinkSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { Box, Text, useCursor, useInput, usePaste, useStdout } from "ink";
+import { createContext, createElement, memo, useCallback, useContext, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState } from "react";
+import stringWidth from "string-width";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/harness-home.ts
+const DSH_HOME_DIR_NAME = ".dsh";
+const DSH_HOME_ENV = "DSH_HOME";
+function expandHomePath(path) {
+	if (path === "~") return homedir();
+	if (path.startsWith("~/") || path.startsWith("~\\")) return join(homedir(), path.slice(2));
+	return path;
+}
+/**
+* Resolve the DeepSeek Harness home the same way the harness does:
+* `$DSH_HOME` when set (blank counts as unset), otherwise `~/.dsh`.
+* Mirrors @deepseek-ai/dsh-home-paths without depending on it.
+*/
+function resolveDshHome(env = process.env) {
+	const fromEnv = env[DSH_HOME_ENV];
+	const selected = fromEnv !== void 0 && fromEnv.trim().length > 0 ? fromEnv : join(homedir(), DSH_HOME_DIR_NAME);
+	return resolve(expandHomePath(selected));
+}
+//#endregion
+//#region src/log.ts
+const LOG_LEVELS = [
+	"debug",
+	"info",
+	"warn",
+	"error"
+];
+const state = {
+	stderrEnabled: false,
+	fileEnabled: false,
+	minLevel: "info",
+	maxFileBytes: 5242880
+};
+const sinks = /* @__PURE__ */ new Set();
+let fileSink;
+function levelRank(level) {
+	return LOG_LEVELS.indexOf(level);
+}
+function fieldsText(fields) {
+	return fields === void 0 ? "" : ` ${JSON.stringify(fields)}`;
+}
+function formatLine(entry) {
+	return `${(/* @__PURE__ */ new Date()).toISOString()} [${entry.level}] ${entry.tag} ${entry.message}${fieldsText(entry.fields)}\n`;
+}
+function formatCrash(report) {
+	return [
+		`=== dshtui crash: ${report.kind} ===`,
+		`time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+		`node: ${process.version}`,
+		`message: ${report.message}${fieldsText(report.fields)}`,
+		report.stack === void 0 ? "" : `stack:\n${report.stack}`,
+		report.cause === void 0 ? "" : `cause: ${report.cause}`,
+		""
+	].join("\n");
+}
+function writeStderr(line) {
+	if (!state.stderrEnabled) return;
+	try {
+		process.stderr.write(line);
+	} catch {}
+}
+function resolveLogFile(dir) {
+	return join(dir ?? join(resolveDshHome(), "logs"), "dshtui.log");
+}
+function rotateIfNeeded(logFile) {
+	let size;
+	try {
+		size = statSync(logFile).size;
+	} catch {
+		return;
+	}
+	if (size < state.maxFileBytes) return;
+	try {
+		unlinkSync(`${logFile}.1`);
+	} catch {}
+	try {
+		renameSync(logFile, `${logFile}.1`);
+	} catch {}
+}
+function fileSinkFor(logFile) {
+	return {
+		line(entry) {
+			if (!state.fileEnabled) return;
+			try {
+				rotateIfNeeded(logFile);
+				try {
+					chmodSync(logFile, 384);
+				} catch {}
+				appendFileSync(logFile, formatLine(entry), { mode: 384 });
+			} catch {}
+			if (entry.level === "warn" || entry.level === "error") writeStderr(`[dshtui] ${entry.message}${fieldsText(entry.fields)}\n`);
+		},
+		crash(report) {
+			if (!state.fileEnabled) return;
+			const line = formatCrash(report);
+			try {
+				rotateIfNeeded(logFile);
+				try {
+					chmodSync(logFile, 384);
+				} catch {}
+				appendFileSync(logFile, line, { mode: 384 });
+			} catch {}
+			writeStderr(line);
+		}
+	};
+}
+function removeFileSink() {
+	if (fileSink === void 0) return;
+	sinks.delete(fileSink);
+	fileSink = void 0;
+}
+function configureLogs(options = {}) {
+	if (options.stderr !== void 0) state.stderrEnabled = options.stderr;
+	if (options.level !== void 0) state.minLevel = options.level;
+	if (options.maxFileBytes !== void 0) state.maxFileBytes = Math.max(1, options.maxFileBytes);
+	state.fileEnabled = options.file ?? state.fileEnabled;
+	removeFileSink();
+	if (state.fileEnabled) {
+		const logFile = resolveLogFile(options.dir);
+		try {
+			mkdirSync(dirname(logFile), {
+				recursive: true,
+				mode: 448
+			});
+			fileSink = fileSinkFor(logFile);
+			sinks.add(fileSink);
+		} catch {
+			state.fileEnabled = false;
+		}
+	}
+}
+function dispatch(entry) {
+	if (levelRank(entry.level) < levelRank(state.minLevel)) return;
+	for (const sink of sinks) try {
+		sink.line(entry);
+	} catch {}
+}
+function dispatchCrash(report) {
+	for (const sink of sinks) try {
+		sink.crash(report);
+	} catch {}
+}
+function log(level, tag, message, fields) {
+	dispatch({
+		level,
+		tag,
+		message,
+		fields
+	});
+}
+function warn(tag, message, fields) {
+	log("warn", tag, message, fields);
+}
+function error(tag, message, fields) {
+	log("error", tag, message, fields);
+}
+function stringifyError(cause) {
+	if (cause instanceof Error) return cause.message;
+	return String(cause);
+}
+function writeCrashReport(report) {
+	dispatchCrash(report);
+}
+function installCrashHandlers(options = {}) {
+	const onUncaught = (cause) => {
+		writeCrashReport({
+			kind: "uncaughtException",
+			message: stringifyError(cause),
+			stack: cause instanceof Error ? cause.stack : void 0
+		});
+		if (options.exit === true) process.exit(1);
+	};
+	const onRejected = (cause) => {
+		writeCrashReport({
+			kind: "unhandledRejection",
+			message: stringifyError(cause),
+			stack: cause instanceof Error ? cause.stack : void 0
+		});
+		if (options.exit === true) process.exit(1);
+	};
+	process.on("uncaughtException", onUncaught);
+	process.on("unhandledRejection", onRejected);
+	return () => {
+		process.off("uncaughtException", onUncaught);
+		process.off("unhandledRejection", onRejected);
+	};
+}
+//#endregion
+//#region src/env.ts
+/**
+Every dshtui environment variable, parsed once at import.
+*/
+function parseLogLevel(value) {
+	return LOG_LEVELS.includes(value ?? "") ? value : void 0;
+}
+function parseBytes(value) {
+	if (value === void 0 || value.trim() === "") return void 0;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+const env = {
+	/** Force color level: 0 none, 1 ansi16, 2 ansi256, 3 truecolor. */
+	color: process.env.DSH_TUI_COLOR,
+	/** Render every glyph as plain ASCII. */
+	ascii: process.env.DSH_TUI_ASCII === "1",
+	/** Force background mode: 'dark' or 'light'. */
+	background: process.env.DSH_TUI_BG,
+	/** Reload theme.ts on every save (path relative to cwd, default src/theme.ts). */
+	hotTheme: process.env.DSH_TUI_HOT_THEME === "1",
+	themePath: process.env.DSH_TUI_THEME_PATH,
+	/** Mirror warnings and errors to stderr; only the exact value '1' enables it. */
+	debug: process.env.DSH_TUI_DEBUG === "1",
+	/** Write diagnostics under the harness home logs directory (default: on). */
+	logFile: process.env.DSH_TUI_LOG_FILE !== "0",
+	/** Override the harness home base directory used for logs. */
+	logDir: process.env.DSH_TUI_LOG_DIR,
+	/** Minimum level written to the log file: debug | info | warn | error. */
+	logLevel: parseLogLevel(process.env.DSH_TUI_LOG_LEVEL),
+	/** Rotation cap for the log file in bytes. */
+	logMaxBytes: parseBytes(process.env.DSH_TUI_LOG_MAX_BYTES),
+	/** Exit the host process on an uncaught crash (default: record only). */
+	crashExit: process.env.DSH_TUI_CRASH_EXIT === "1"
+};
+//#endregion
+//#region src/terminal/capabilities.ts
+function parseForcedColorLevel(value) {
+	if (value === "0" || value === "1" || value === "2" || value === "3") return Number(value);
+	if (value === "truecolor") return 3;
+	if (value === "none" || value === "false") return 0;
+}
+function detectColorLevel() {
+	const forced = parseForcedColorLevel(env.color);
+	if (forced !== void 0) return forced;
+	if (process.env.NO_COLOR !== void 0) return 0;
+	const forceColor = process.env.FORCE_COLOR;
+	if (forceColor !== void 0) {
+		if (forceColor === "false" || forceColor === "0") return 0;
+		if (forceColor === "true" || forceColor === "") return 1;
+		const parsed = Number(forceColor);
+		if (parsed === 1 || parsed === 2 || parsed === 3) return parsed;
+	}
+	const term = process.env.TERM ?? "";
+	if (term === "dumb") return 0;
+	const colorterm = process.env.COLORTERM ?? "";
+	if (colorterm === "truecolor" || colorterm === "24bit") return 3;
+	if (term.includes("truecolor")) return 3;
+	if (process.env.WT_SESSION !== void 0) return 3;
+	if (term.includes("256color")) return 2;
+	if (term !== "" || process.env.TERM_PROGRAM !== void 0) return 1;
+	return 0;
+}
+function detectUnicode() {
+	if (env.ascii) return false;
+	if ((process.env.TERM ?? "") === "dumb") return false;
+	const locale = process.env.LC_ALL ?? process.env.LANG ?? "";
+	if (locale === "" || /utf-?8/i.test(locale)) return true;
+	const base = locale.split(".")[0] ?? locale;
+	if (base === "C" || base === "POSIX") return false;
+	return !locale.includes(".");
+}
+let colorLevel = detectColorLevel();
+function setColorLevel(level) {
+	colorLevel = level;
+	chalk.level = level;
+}
+chalk.level = colorLevel;
+const unicode = detectUnicode();
+//#endregion
+//#region src/kernel/registry.ts
+/**
+* Keyed contribution registry with layered override semantics: registering
+* an existing key displaces the previous layer, and disposing a layer
+* restores the nearest live layer below it, so an overriding plugin that
+* unmounts hands the slot back to whatever it replaced.
+*
+* `get(key)` resolves to the live layer with the lowest order (the one that
+* would win a dispatch loop), not merely the most recently registered one, so
+* single-key lookups agree with the iteration order plugins observe.
+*/
+function keyedRegistry(compareKeys = (a, b) => a < b ? -1 : a > b ? 1 : 0) {
+	const map = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	function notify() {
+		for (const listener of [...listeners]) try {
+			listener();
+		} catch {}
+	}
+	function winningLayer(key) {
+		let best;
+		let layer = map.get(key);
+		while (layer !== void 0) {
+			if (!layer.dead && (best === void 0 || layer.order < best.order)) best = layer;
+			layer = layer.prev;
+		}
+		return best;
+	}
+	return {
+		register(key, value, options) {
+			const prev = map.get(key);
+			const layer = {
+				key,
+				order: options?.order ?? 100,
+				value,
+				prev,
+				dead: false
+			};
+			map.set(key, layer);
+			notify();
+			return () => {
+				if (layer.dead) return;
+				layer.dead = true;
+				if (map.get(key) !== layer) return;
+				let restore = layer.prev;
+				while (restore !== void 0 && restore.dead) restore = restore.prev;
+				if (restore === void 0) map.delete(key);
+				else map.set(key, restore);
+				notify();
+			};
+		},
+		entries() {
+			return [...map.values()].map((layer) => ({
+				key: layer.key,
+				order: layer.order,
+				value: layer.value
+			})).sort((a, b) => a.order - b.order || compareKeys(a.key, b.key));
+		},
+		values() {
+			return this.entries().map((entry) => entry.value);
+		},
+		get(key) {
+			return winningLayer(key)?.value;
+		},
+		has(key) {
+			return map.has(key);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+//#endregion
+//#region src/theme.ts
+const paletteContributions = keyedRegistry();
+function registerPalette(contribution) {
+	const dispose = paletteContributions.register(contribution.id, contribution, { order: contribution.order });
+	materialize(currentMode);
+	return () => {
+		dispose();
+		materialize(currentMode);
+	};
+}
+function subscribePalettes(listener) {
+	return paletteContributions.subscribe(listener);
+}
+const DARK_LADDER = {
+	base: "#0d0d0d",
+	sunken: "#1a1a1a",
+	surface: "#262626",
+	raised: "#333333",
+	line: "#686868",
+	text: "#9a9a9a",
+	ink: "#cccccc"
+};
+const LIGHT_LADDER = {
+	base: "#ffffff",
+	sunken: "#f2f2f2",
+	surface: "#e6e6e6",
+	raised: "#d9d9d9",
+	line: "#999999",
+	text: "#595959",
+	ink: "#1a1a1a"
+};
+const DARK_HUES = {
+	accent: "#ffae00",
+	info: "#4da0e8",
+	success: "#4caf50",
+	error: "#ff6753",
+	added: "#5d9e50",
+	removed: "#d25044"
+};
+const LIGHT_HUES = {
+	accent: "#a86800",
+	info: "#2f6fd0",
+	success: "#2e8b3d",
+	error: "#d44a3a",
+	added: "#0a8a2c",
+	removed: "#c22318"
+};
+const DARK_CODE = {
+	comment: "#5d9e50",
+	string: "#d78f6e",
+	number: "#82c46e",
+	keyword: "#c883c8",
+	fn: "#d8d89e",
+	type: "#52a898",
+	variable: "#4d9fd6",
+	fallback: "#a3b56a"
+};
+const LIGHT_CODE = {
+	comment: "#4a8a3d",
+	string: "#a05f42",
+	number: "#3f9a63",
+	keyword: "#8f4a88",
+	fn: "#7a7a3d",
+	type: "#2a7a6e",
+	variable: "#3a76a8",
+	fallback: "#647a34"
+};
+/** Mix two hex colors channel-wise; t=0 keeps the hue, t=1 keeps the gray. */
+function tint(hue, gray, t) {
+	const channel = (hex, at) => parseInt(hex.slice(at, at + 2), 16);
+	const mix = (at) => {
+		return Math.round(channel(hue, at) * (1 - t) + channel(gray, at) * t).toString(16).padStart(2, "0");
+	};
+	return `#${mix(1)}${mix(3)}${mix(5)}`;
+}
+const THINK_DESATURATE = .55;
+function buildPalette(ladder, hues, code, mode) {
+	const think = (hue) => tint(hue, ladder.text, mode === "dark" ? THINK_DESATURATE : .35);
+	const thinkCode = Object.fromEntries(Object.entries(code).map(([key, hue]) => [key, think(hue)]));
+	return {
+		ink: ladder.ink,
+		userBubbleBackground: ladder.surface,
+		aiBubbleBackground: ladder.sunken,
+		permissionBackground: ladder.sunken,
+		workspaceWriteText: hues.info,
+		dangerFullAccessText: hues.accent,
+		readOnlyText: hues.success,
+		dialogBackground: ladder.base,
+		dialogInputBackground: ladder.raised,
+		dialogHintText: ladder.text,
+		carouselCurrentBg: ladder.raised,
+		carouselButtonBg: ladder.sunken,
+		carouselButtonPressedBg: ladder.surface,
+		carouselSelectedText: hues.accent,
+		sectionHeader: hues.accent,
+		panelQuestionText: ladder.ink,
+		panelKeyText: ladder.ink,
+		modelText: ladder.ink,
+		effortText: hues.accent,
+		statusSeparator: ladder.text,
+		presetText: ladder.text,
+		cwdText: ladder.text,
+		statsText: ladder.text,
+		errorText: hues.error,
+		success: hues.success,
+		warning: hues.accent,
+		specialFieldText: mode === "dark" ? "#1a1a1a" : "#3d2800",
+		specialFieldBackground: hues.accent,
+		toolLabel: mode === "dark" ? "#2fc0e0" : "#0092b8",
+		toolBodyText: ladder.text,
+		diffAdded: hues.added,
+		diffRemoved: hues.removed,
+		diffAddedBackground: mode === "dark" ? "#384751" : "#e1f1e5",
+		diffRemovedBackground: mode === "dark" ? "#4f312c" : "#f5e8e5",
+		scrollTrackBackground: ladder.sunken,
+		scrollThumbBackground: ladder.line,
+		selectionBg: "#0066ff",
+		selectionFg: "#cccccc",
+		mdLink: hues.info,
+		mdInlineCode: hues.added,
+		mdQuoteBar: ladder.line,
+		mdHr: ladder.line,
+		mdList: hues.accent,
+		mdTaskDone: hues.added,
+		mdTaskTodo: ladder.line,
+		mdH1: mode === "dark" ? "#e0b568" : "#8a6d2f",
+		mdH3: mode === "dark" ? "#64b5d6" : "#2f6fa8",
+		mdCodePlain: ladder.ink,
+		mdCodeFallback: code.fallback,
+		codeComment: code.comment,
+		codeString: code.string,
+		codeNumber: code.number,
+		codeKeyword: code.keyword,
+		codeFunction: code.fn,
+		codeType: code.type,
+		codeVariable: code.variable,
+		codeConstant: code.variable,
+		codeOperator: ladder.ink,
+		thinkLink: think(hues.info),
+		thinkInlineCode: think(hues.added),
+		thinkHr: tint(ladder.line, ladder.base, mode === "dark" ? .35 : .15),
+		thinkList: ladder.text,
+		thinkTaskDone: think(hues.added),
+		thinkTaskTodo: ladder.line,
+		thinkH1: ladder.text,
+		thinkH3: ladder.text,
+		thinkCodePlain: ladder.text,
+		thinkCodeFallback: thinkCode.fallback,
+		thinkCodeComment: thinkCode.comment,
+		thinkCodeString: thinkCode.string,
+		thinkCodeNumber: thinkCode.number,
+		thinkCodeKeyword: thinkCode.keyword,
+		thinkCodeFunction: thinkCode.fn,
+		thinkCodeType: thinkCode.type,
+		thinkCodeVariable: thinkCode.variable,
+		thinkCodeConstant: thinkCode.variable,
+		homeLogoTop: mode === "dark" ? "#2181ff" : "#0381ff",
+		homeLogoBottom: mode === "dark" ? "#3a9aa0" : "#97c4ff"
+	};
+}
+const darkPalette = buildPalette(DARK_LADDER, DARK_HUES, DARK_CODE, "dark");
+const palettes = {
+	dark: darkPalette,
+	light: buildPalette(LIGHT_LADDER, LIGHT_HUES, LIGHT_CODE, "light")
+};
+const COLORS = { ...darkPalette };
+let currentMode = "dark";
+function themeMode() {
+	return currentMode;
+}
+function permissionModes() {
+	return {
+		"workspace-write": {
+			color: COLORS.permissionBackground,
+			textColor: COLORS.workspaceWriteText,
+			name: "Workspace Write"
+		},
+		"danger-full-access": {
+			color: COLORS.permissionBackground,
+			textColor: COLORS.dangerFullAccessText,
+			name: "Full access"
+		},
+		"read-only": {
+			color: COLORS.permissionBackground,
+			textColor: COLORS.readOnlyText,
+			name: "Read Only"
+		}
+	};
+}
+function effectivePalette(mode) {
+	const merged = { ...palettes[mode] };
+	for (const contribution of paletteContributions.values()) {
+		if (contribution.mode !== void 0 && contribution.mode !== "both" && contribution.mode !== mode) continue;
+		Object.assign(merged, contribution.colors);
+	}
+	return merged;
+}
+function materialize(mode) {
+	Object.assign(COLORS, effectivePalette(mode));
+	Object.assign(PERMISSION_MODES, permissionModes());
+}
+/**
+* Read a palette color by key, including keys contributed by plugins that
+* are not part of the built-in Theme type. Falls back to the raw key when
+* nothing defines it, so custom semantic names remain visible.
+*/
+function paletteColor(key) {
+	return COLORS[key] ?? key;
+}
+function setThemeMode(mode) {
+	currentMode = mode;
+	materialize(mode);
+}
+function replacePalettes(next) {
+	Object.assign(palettes.dark, next.dark);
+	Object.assign(palettes.light, next.light);
+	materialize(currentMode);
+}
+const PERMISSION_MODES = permissionModes();
+materialize(currentMode);
+function permissionModeInfo(mode) {
+	return PERMISSION_MODES[mode] ?? {
+		color: COLORS.permissionBackground,
+		textColor: COLORS.workspaceWriteText,
+		name: mode
+	};
+}
+//#endregion
+//#region src/core/fields.ts
+const FIELD_CHAR_BASE = 57344;
+const FIELD_CHAR_END = 63743;
+const FIELD_CHAR_COUNT = 6400;
+const slots = /* @__PURE__ */ new Map();
+const kindDefs = /* @__PURE__ */ new Map();
+const labelWidthCache = /* @__PURE__ */ new Map();
+let cursor = 0;
+function specialFieldStyle() {
+	return {
+		color: COLORS.specialFieldText,
+		background: COLORS.specialFieldBackground,
+		bold: true
+	};
+}
+function registerFieldKind(def) {
+	kindDefs.set(def.kind, def);
+	return () => {
+		if (kindDefs.get(def.kind) === def) kindDefs.delete(def.kind);
+	};
+}
+function fieldStyleOf(slot) {
+	const def = kindDefs.get(slot.kind);
+	if (def !== void 0) return def.style();
+	return specialFieldStyle();
+}
+function fieldExpandOf(kind) {
+	return kindDefs.get(kind)?.expand;
+}
+function specialFieldFactory() {
+	return {
+		create: (input) => allocateField(input.kind, input.label, input.owner ?? "composer"),
+		release: releaseField,
+		pin: pinField,
+		isFieldChar,
+		labelOf: (char) => fieldSlotOf(char)?.label
+	};
+}
+function isFieldCode(code) {
+	return code >= FIELD_CHAR_BASE && code <= FIELD_CHAR_END;
+}
+function hasFieldChar(text) {
+	for (let i = 0; i < text.length; i++) if (isFieldCode(text.charCodeAt(i))) return true;
+	return false;
+}
+function isFieldChar(char) {
+	return char.length === 1 && isFieldCode(char.charCodeAt(0));
+}
+function fieldCodeWidth(code) {
+	const slot = slots.get(code - FIELD_CHAR_BASE);
+	if (slot === void 0) return 1;
+	return labelWidth(slot.label);
+}
+function labelWidth(label) {
+	const hit = labelWidthCache.get(label);
+	if (hit !== void 0) return hit;
+	const width = stringWidth(label);
+	if (labelWidthCache.size >= 4096) labelWidthCache.clear();
+	labelWidthCache.set(label, width);
+	return width;
+}
+function allocateField(kind, label, owner) {
+	for (let i = 0; i < FIELD_CHAR_COUNT; i++) {
+		const index = (cursor + i) % FIELD_CHAR_COUNT;
+		if (slots.has(index)) continue;
+		cursor = (index + 1) % FIELD_CHAR_COUNT;
+		slots.set(index, {
+			kind,
+			label,
+			owner,
+			pins: 0
+		});
+		return String.fromCharCode(FIELD_CHAR_BASE + index);
+	}
+	return null;
+}
+function fieldSlotOf(char) {
+	if (char.length !== 1) return void 0;
+	const code = char.charCodeAt(0);
+	if (!isFieldCode(code)) return void 0;
+	return slots.get(code - FIELD_CHAR_BASE);
+}
+function releaseField(char) {
+	if (char.length !== 1) return;
+	const index = char.charCodeAt(0) - FIELD_CHAR_BASE;
+	const slot = slots.get(index);
+	if (slot === void 0 || slot.pins > 0) return;
+	slots.delete(index);
+}
+/**
+* Hold a field slot against the automatic reclaim scans (composer edits and
+* message-list rebuilds drop every slot whose char is absent from the live
+* text). Callers that create chips outside the composer value — custom
+* windows, overlays, background tasks — must pin them and call the returned
+* disposer when done.
+*/
+function pinField(char) {
+	if (char.length !== 1) return void 0;
+	const slot = slots.get(char.charCodeAt(0) - FIELD_CHAR_BASE);
+	if (slot === void 0) return void 0;
+	slot.pins += 1;
+	return () => {
+		slot.pins -= 1;
+	};
+}
+function hasFieldSlots(owner) {
+	for (const slot of slots.values()) if (slot.owner === owner) return true;
+	return false;
+}
+function releaseUnreferenced(owner, keepText) {
+	for (const [index, slot] of slots) {
+		if (slot.owner !== owner || slot.pins > 0) continue;
+		const char = String.fromCharCode(FIELD_CHAR_BASE + index);
+		if (!keepText.includes(char)) slots.delete(index);
+	}
+}
+function releaseFields(owner) {
+	for (const [index, slot] of slots) if (slot.owner === owner && slot.pins === 0) slots.delete(index);
+}
+function imageChipLabel(count) {
+	return `[${count} images]`;
+}
+function linesChipLabel(count) {
+	return `[${count} lines]`;
+}
+function charactersChipLabel(count) {
+	return `[${count} characters]`;
+}
+//#endregion
+//#region src/core/text.ts
+const WIDTH_CACHE_LIMIT = 8192;
+function cachedWidth(cache, text, compute) {
+	const hit = cache.get(text);
+	if (hit !== void 0) return hit;
+	const width = compute();
+	if (cache.size >= WIDTH_CACHE_LIMIT) cache.clear();
+	cache.set(text, width);
+	return width;
+}
+const widthCache = /* @__PURE__ */ new Map();
+function textWidth(text) {
+	if (isAsciiPrintable(text)) return text.length;
+	const hit = widthCache.get(text);
+	if (hit !== void 0) return hit;
+	let total = 0;
+	let run = "";
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (isFieldCode(code)) {
+			if (run !== "") {
+				total += stringWidth(run);
+				run = "";
+			}
+			total += fieldCodeWidth(code);
+			continue;
+		}
+		run += text[i];
+	}
+	if (run !== "") total += stringWidth(run);
+	if (widthCache.size >= WIDTH_CACHE_LIMIT) widthCache.clear();
+	widthCache.set(text, total);
+	return total;
+}
+function isAsciiPrintable(text) {
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (code < 32 || code > 126) return false;
+	}
+	return true;
+}
+const charWidthCache = /* @__PURE__ */ new Map();
+const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function segmentGraphemes(text) {
+	return graphemeSegmenter.segment(text);
+}
+function charWidth(cluster) {
+	if (cluster.length === 1) {
+		const code = cluster.charCodeAt(0);
+		if (code >= 32 && code <= 126) return 1;
+		if (isFieldCode(code)) return fieldCodeWidth(code);
+	}
+	return cachedWidth(charWidthCache, cluster, () => stringWidth(cluster));
+}
+const NO_START_CHARS = /* @__PURE__ */ new Set("!%,.:;?)]}'\"。，、：；！？）］｝》〉」』】〕〗〙〛…—～·％°′″‰");
+const NO_END_CHARS = /* @__PURE__ */ new Set("([{'\"$#@`（［｛《〈「『【〔〖＄￥");
+const BREAK_DELIM_CHARS = /* @__PURE__ */ new Set("-/\\,.;:!?)]}");
+function matchesAny(cluster, set) {
+	for (const ch of cluster) if (set.has(ch)) return true;
+	return false;
+}
+const ASCII_NO_START = /* @__PURE__ */ new Set();
+for (const ch of "!%,.:;?)]}'\"") ASCII_NO_START.add(ch.charCodeAt(0));
+const ASCII_NO_END = /* @__PURE__ */ new Set();
+for (const ch of "([{'\"$#@`") ASCII_NO_END.add(ch.charCodeAt(0));
+function canBreakBefore(prev, cur) {
+	if (prev.length === 1 && cur.length === 1) {
+		const pc = prev.charCodeAt(0);
+		const cc = cur.charCodeAt(0);
+		if (pc >= 32 && pc < 127 && cc >= 32 && cc < 127) {
+			if (ASCII_NO_START.has(cc) || ASCII_NO_END.has(pc)) return false;
+			if (pc === 32 || BREAK_DELIM_CHARS.has(prev)) return true;
+			return false;
+		}
+	}
+	if (matchesAny(cur, NO_START_CHARS) || matchesAny(prev, NO_END_CHARS)) return false;
+	if (charWidth(prev) >= 2 || charWidth(cur) >= 2) return true;
+	if (prev === " " || prev === "	") return true;
+	if (BREAK_DELIM_CHARS.has(prev)) return true;
+	return false;
+}
+function computeWrapStarts(clusters, width) {
+	const total = clusters.length;
+	const starts = [0];
+	let start = 0;
+	let lineW = 0;
+	let lastBreak = -1;
+	for (let i = 0; i < total; i++) {
+		const w = charWidth(clusters[i]);
+		if (lineW + w > width && i > start) {
+			let j;
+			if (lastBreak > start) j = lastBreak;
+			else {
+				j = i;
+				while (j > start + 1 && matchesAny(clusters[j], NO_START_CHARS)) j--;
+				while (j > start + 1 && matchesAny(clusters[j - 1], NO_END_CHARS)) j--;
+			}
+			starts.push(j);
+			lineW = 0;
+			for (let k = j; k < i; k++) lineW += charWidth(clusters[k]);
+			start = j;
+			lastBreak = -1;
+		}
+		const next = i + 1;
+		if (next < total && canBreakBefore(clusters[i], clusters[next])) lastBreak = next;
+		lineW += w;
+	}
+	return starts;
+}
+function pushWrapped(line, width, out) {
+	if (line.length === 0) {
+		out.push("");
+		return;
+	}
+	const clusters = [];
+	for (const { segment } of segmentGraphemes(line)) clusters.push(segment);
+	const starts = computeWrapStarts(clusters, width);
+	for (let r = 0; r < starts.length; r++) {
+		const from = starts[r];
+		const to = r + 1 < starts.length ? starts[r + 1] : clusters.length;
+		out.push(clusters.slice(from, to).join(""));
+	}
+}
+/**
+* Single normalization applied before every wrap pass. Terminal rendering
+* expands tabs and a lone carriage return rewinds the cursor, so both would
+* make the visually rendered line wider than the width computation assumed
+* and every later row would land on the wrong column. Both are replaced
+* with spaces / newlines here so wrap math and rendering always agree.
+*/
+function normalizeWrapText(text) {
+	if (!text.includes("\r") && !text.includes("	")) return text;
+	return text.replace(/\r\n?/g, "\n").replace(/\t/g, "    ");
+}
+function wrapLines(text, width) {
+	if (width <= 0) return [""];
+	const cacheKey = `${width}\u0000${text}`;
+	const hit = wrapCache.get(cacheKey);
+	if (hit !== void 0) return hit.lines;
+	const lines = [];
+	for (const rawLine of normalizeWrapText(text).split("\n")) pushWrapped(rawLine, width, lines);
+	evictWrapCacheIfNeeded();
+	wrapCache.set(cacheKey, {
+		lines,
+		bytes: text.length
+	});
+	return lines;
+}
+const WRAP_CACHE_MAX_BYTES = 4194304;
+const wrapCache = /* @__PURE__ */ new Map();
+let wrapCacheBytes = 0;
+function evictWrapCacheIfNeeded() {
+	while (wrapCache.size > 0 && wrapCacheBytes >= WRAP_CACHE_MAX_BYTES) {
+		const oldest = wrapCache.keys().next();
+		if (oldest.done) return;
+		const entry = wrapCache.get(oldest.value);
+		if (entry !== void 0) wrapCacheBytes -= entry.bytes;
+		wrapCache.delete(oldest.value);
+	}
+}
+function pushWrappedOffsets(line, width, base, out) {
+	if (line.length === 0) {
+		out.push({
+			start: base,
+			end: base
+		});
+		return;
+	}
+	const clusters = [];
+	const offsets = [];
+	for (const { segment, index } of segmentGraphemes(line)) {
+		clusters.push(segment);
+		offsets.push(index);
+	}
+	const starts = computeWrapStarts(clusters, width);
+	for (let r = 0; r < starts.length; r++) {
+		const from = starts[r];
+		const to = r + 1 < starts.length ? offsets[starts[r + 1]] : line.length;
+		out.push({
+			start: base + offsets[from],
+			end: base + to
+		});
+	}
+}
+function lineBreaks(text, width) {
+	const breaks = [];
+	let start = 0;
+	for (const rawLine of text.split("\n")) {
+		pushWrappedOffsets(rawLine, width, start, breaks);
+		start += rawLine.length + 1;
+	}
+	return breaks;
+}
+function locToPoint(text, width, index) {
+	const breaks = lineBreaks(text, width);
+	for (let row = 0; row < breaks.length; row++) {
+		const { start, end } = breaks[row];
+		if (index < end || index === end && row < breaks.length - 1 && breaks[row + 1].start > end) return {
+			row,
+			col: textWidth(text.slice(start, index))
+		};
+	}
+	const last = breaks[breaks.length - 1];
+	return {
+		row: breaks.length - 1,
+		col: textWidth(text.slice(last.start, last.end))
+	};
+}
+function colToCharIndex(line, col) {
+	let width = 0;
+	for (const { segment, index } of segmentGraphemes(line)) {
+		if (width >= col) return index;
+		width += charWidth(segment);
+	}
+	return line.length;
+}
+function caretScrollStart(text, caret, width) {
+	const clamped = Math.min(Math.max(0, caret), text.length);
+	const caretCol = textWidth(text.slice(0, clamped));
+	if (caretCol <= width) return 0;
+	const minPrefix = caretCol - width;
+	let prefix = 0;
+	for (const { segment, index } of segmentGraphemes(text)) {
+		if (index >= clamped) break;
+		if (prefix >= minPrefix) return index;
+		prefix += charWidth(segment);
+	}
+	return clamped;
+}
+function padToWidth(text, width) {
+	const used = textWidth(text);
+	return text + " ".repeat(Math.max(0, width - used));
+}
+function truncate(text, width) {
+	let used = 0;
+	for (const { segment, index } of segmentGraphemes(text)) {
+		const w = charWidth(segment);
+		if (used + w > width) return text.slice(0, index);
+		used += w;
+	}
+	return text;
+}
+function errorText(cause) {
+	return cause instanceof Error ? cause.message : String(cause);
+}
+//#endregion
+//#region src/model/selection.ts
+function selectedRange(sel, row) {
+	const top = Math.min(sel.anchorRow, sel.focusRow);
+	const bottom = Math.max(sel.anchorRow, sel.focusRow);
+	if (row < top || row > bottom) return null;
+	if (sel.anchorRow === sel.focusRow) return {
+		start: Math.min(sel.anchorCol, sel.focusCol),
+		end: Math.max(sel.anchorCol, sel.focusCol)
+	};
+	const upward = sel.focusRow < sel.anchorRow;
+	if (row === sel.anchorRow) return upward ? {
+		start: 0,
+		end: sel.anchorCol
+	} : {
+		start: sel.anchorCol,
+		end: Infinity
+	};
+	if (row === sel.focusRow) return upward ? {
+		start: sel.focusCol,
+		end: Infinity
+	} : {
+		start: 0,
+		end: sel.focusCol
+	};
+	return {
+		start: 0,
+		end: Infinity
+	};
+}
+function toScreenSelection(selection, scrollTop, messageHeight) {
+	if (selection === null) return null;
+	if (!selection.inMessage) return selection;
+	const rawAnchor = selection.anchorRow - scrollTop;
+	const rawFocus = selection.focusRow - scrollTop;
+	const visible = (row) => row >= 0 && row < messageHeight;
+	if (!visible(rawAnchor) && !visible(rawFocus)) return null;
+	const clampRow = (row) => row < 0 ? 0 : row >= messageHeight ? messageHeight - 1 : row;
+	const snapCol = (raw, col) => raw < 0 ? 0 : raw >= messageHeight ? Infinity : col;
+	return {
+		anchorRow: clampRow(rawAnchor),
+		anchorCol: snapCol(rawAnchor, selection.anchorCol),
+		focusRow: clampRow(rawFocus),
+		focusCol: snapCol(rawFocus, selection.focusCol),
+		inMessage: true
+	};
+}
+function clampFocusRow(inMessage, eventY, scrollTop, messageHeight, rows, dialogOpen) {
+	if (inMessage) return Math.min(eventY + scrollTop, scrollTop + messageHeight - 1);
+	if (dialogOpen) return Math.max(0, Math.min(eventY, rows - 1));
+	return Math.max(messageHeight, eventY);
+}
+//#endregion
+//#region src/ui/selection-registry.ts
+const rows = /* @__PURE__ */ new Map();
+function registerRowPiece(id, y, piece) {
+	let pieces = rows.get(y);
+	if (piece === null) {
+		if (pieces !== void 0) {
+			pieces.delete(id);
+			if (pieces.size === 0) rows.delete(y);
+		}
+		return;
+	}
+	if (pieces === void 0) {
+		pieces = /* @__PURE__ */ new Map();
+		rows.set(y, pieces);
+	}
+	pieces.set(id, piece);
+}
+function rowPieces(y) {
+	const pieces = rows.get(y);
+	if (pieces === void 0) return [];
+	return [...pieces.values()].sort((a, b) => a.col - b.col);
+}
+function visiblePieces(y) {
+	const pieces = rowPieces(y);
+	const chrome = pieces.filter((piece) => piece.layer !== "message");
+	return chrome.length > 0 ? chrome : pieces;
+}
+function envelopeOf(selection) {
+	return {
+		start: Math.min(selection.anchorCol, selection.focusCol),
+		end: Math.max(selection.anchorCol, selection.focusCol)
+	};
+}
+function envelopeOverlaps(selection, col, width) {
+	const env = envelopeOf(selection);
+	return env.end > col && env.start < col + width;
+}
+function sliceByColumns(text, startCol, endCol) {
+	const startIndex = colToCharIndex(text, Math.max(0, startCol));
+	const endIndex = colToCharIndex(text, Math.max(0, endCol));
+	return text.slice(startIndex, endIndex);
+}
+function chromeSelectionText(selection) {
+	const top = Math.min(selection.anchorRow, selection.focusRow);
+	const bottom = Math.max(selection.anchorRow, selection.focusRow);
+	const env = envelopeOf(selection);
+	const lines = [];
+	for (let row = top; row <= bottom; row++) {
+		const range = selectedRange(selection, row);
+		if (range === null) continue;
+		let line = "";
+		let prevEnd = -1;
+		for (const piece of visiblePieces(row)) {
+			const width = textWidth(piece.text);
+			if (!(env.end > piece.col && env.start < piece.col + width)) continue;
+			const start = Math.max(range.start, piece.col);
+			const end = Math.min(range.end, piece.col + width);
+			if (start >= end) continue;
+			const text = sliceByColumns(piece.text, start - piece.col, end - piece.col);
+			if (text === "") continue;
+			if (line !== "") line += prevEnd === piece.col ? "" : " ";
+			line += text;
+			prevEnd = piece.col + width;
+		}
+		lines.push(line);
+	}
+	return lines.join("\n").replace(/[ \t]+$/gm, "").replace(/\n+$/, "");
+}
+//#endregion
+//#region src/core/segments.ts
+function wrapSegments(segments, width) {
+	if (width <= 0) return [[]];
+	const rows = [];
+	let clusters = [];
+	let styles = [];
+	const flushLine = () => {
+		const starts = computeWrapStarts(clusters, width);
+		for (let r = 0; r < starts.length; r++) {
+			const from = starts[r];
+			const to = r + 1 < starts.length ? starts[r + 1] : clusters.length;
+			if (from >= to) {
+				rows.push([]);
+				continue;
+			}
+			const row = [];
+			let runText = "";
+			let runStyle = styles[from];
+			for (let k = from; k < to; k++) {
+				const style = styles[k];
+				if (k > from && !sameStyle(runStyle, style)) {
+					row.push({
+						text: runText,
+						style: runStyle
+					});
+					runText = "";
+					runStyle = style;
+				}
+				runText += clusters[k];
+			}
+			row.push({
+				text: runText,
+				style: runStyle
+			});
+			rows.push(row);
+		}
+		clusters = [];
+		styles = [];
+	};
+	for (const seg of segments) {
+		const parts = normalizeWrapText(seg.text).split("\n");
+		for (let p = 0; p < parts.length; p++) {
+			if (p > 0) flushLine();
+			appendClusters(parts[p], seg.style, clusters, styles);
+		}
+	}
+	flushLine();
+	return rows;
+}
+function sameStyle(a, b) {
+	return a.color === b.color && a.background === b.background && a.bold === b.bold && a.italic === b.italic && a.strike === b.strike && a.underline === b.underline;
+}
+function appendClusters(text, style, clusters, styles) {
+	let ascii = true;
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (code < 32 || code > 126) {
+			ascii = false;
+			break;
+		}
+	}
+	if (ascii) {
+		for (let i = 0; i < text.length; i++) {
+			clusters.push(text[i]);
+			styles.push(style);
+		}
+		return;
+	}
+	for (const { segment } of segmentGraphemes(text)) {
+		clusters.push(segment);
+		styles.push(style);
+	}
+}
+function mergeRuns(segments) {
+	if (segments.length === 0) return segments;
+	const out = [];
+	for (const seg of segments) {
+		const last = out[out.length - 1];
+		if (last !== void 0 && sameStyle(last.style, seg.style)) last.text += seg.text;
+		else out.push({
+			text: seg.text,
+			style: seg.style
+		});
+	}
+	return out;
+}
+function segmentsKey(segments) {
+	let key = "";
+	for (const seg of segments) {
+		const flags = `${seg.style.bold ? "b" : ""}${seg.style.italic ? "i" : ""}${seg.style.strike ? "s" : ""}${seg.style.underline ? "u" : ""}${seg.style.background ? "g" : ""}`;
+		key += `${seg.text.length}:${seg.text}\x1f${seg.style.color ?? ""}\x1e${seg.style.background ?? ""}\x1e${flags}\x1d`;
+	}
+	return key;
+}
+const glyphs = {
+	spinnerFrames: unicode ? [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	] : [
+		"|",
+		"/",
+		"-",
+		"\\"
+	],
+	bullets: unicode ? [
+		"•",
+		"◦",
+		"▪"
+	] : [
+		"*",
+		"o",
+		"-"
+	],
+	horizontal: unicode ? "─" : "-",
+	tableVertical: unicode ? "│" : "|",
+	tableBorders: {
+		top: unicode ? [
+			"┌",
+			"┬",
+			"┐"
+		] : [
+			"+",
+			"-",
+			"+"
+		],
+		middle: unicode ? [
+			"├",
+			"┼",
+			"┤"
+		] : [
+			"+",
+			"-",
+			"+"
+		],
+		bottom: unicode ? [
+			"└",
+			"┴",
+			"┘"
+		] : [
+			"+",
+			"-",
+			"+"
+		]
+	},
+	quoteBar: unicode ? "▌" : "|",
+	taskChecked: unicode ? "☑" : "[x]",
+	taskUnchecked: unicode ? "☐" : "[ ]",
+	headerExpanded: unicode ? "↓" : "v",
+	headerCollapsed: "-",
+	treeBranch: unicode ? "└" : "+",
+	separator: unicode ? "·" : "-",
+	tokenArrow: unicode ? "→" : "->",
+	ellipsis: unicode ? "…" : "...",
+	focusMarker: unicode ? "❯" : ">",
+	tick: unicode ? "✓" : "x",
+	checkboxOn: unicode ? "[✓]" : "[x]",
+	checkboxOff: "[ ]",
+	pageFlip: unicode ? "⇄" : "<->",
+	wrapArrows: unicode ? "⇅" : "^v",
+	carouselLeft: unicode ? "◀" : "<",
+	carouselRight: unicode ? "▶" : ">",
+	todoPending: "[ ]",
+	todoInProgress: unicode ? "[●]" : "[o]",
+	todoDone: unicode ? "[√]" : "[x]",
+	halfBlockCaps: unicode,
+	blockCapTop: "▄",
+	blockCapBottom: "▀"
+};
+function inputFrameTop(rows, realRows) {
+	return rows - 4 - realRows;
+}
+function inputStatusRow(rows) {
+	return rows - 4 + 1;
+}
+function hintBlockTop(rows, inputHeight, visibleCount) {
+	return Math.max(0, rows - inputHeight - 1 - visibleCount);
+}
+//#endregion
+//#region src/ui/layout-service.ts
+function inputContentTop(rows, inputHeight) {
+	return rows - inputHeight;
+}
+/** Inclusive bottom row of the input's editable content area. */
+function inputContentBottom(rows, inputHeight) {
+	return inputContentTop(rows, inputHeight) + inputHeight - 4;
+}
+function inputContentContains(y, rows, inputHeight) {
+	return y >= inputContentTop(rows, inputHeight) && y <= inputContentBottom(rows, inputHeight);
+}
+/** Inclusive row span of the active interaction panel (message bottom .. above the status line). */
+function panelSpan(geometry) {
+	return {
+		top: geometry.messageHeight,
+		bottom: geometry.rows - 2
+	};
+}
+function panelContains(y, geometry) {
+	const span = panelSpan(geometry);
+	return y >= span.top && y <= span.bottom;
+}
+/** Anchor row where a panel of `bodyRows` lines must start to sit above the status line. */
+function panelAnchorRow(rows, bodyRows) {
+	return rows - 2 - bodyRows;
+}
+function hintSpan(rows, inputHeight, visibleCount, dialogOpen) {
+	if (dialogOpen || visibleCount <= 0) return null;
+	return {
+		top: hintBlockTop(rows, inputHeight, visibleCount),
+		bottom: rows - inputHeight - 1 - 1
+	};
+}
+function scrollbarColumn(columns) {
+	return columns - 3;
+}
+function messageBackgroundWidth(width) {
+	return width - 2 - 3 - 1;
+}
+const RegionContext = createContext({
+	x: 0,
+	y: 0
+});
+function useOrigin() {
+	return useContext(RegionContext);
+}
+function translate(parent, x, y) {
+	return {
+		x: parent.x + x,
+		y: parent.y + y
+	};
+}
+function Region({ x = 0, y = 0, children }) {
+	const parent = useOrigin();
+	const value = useMemo(() => translate(parent, x, y), [
+		parent.x,
+		parent.y,
+		x,
+		y
+	]);
+	return /* @__PURE__ */ jsx(RegionContext.Provider, {
+		value,
+		children
+	});
+}
+//#endregion
+//#region src/ui/selection.tsx
+const SelectionContext = createContext(null);
+const SelectableContent = memo(function SelectableContent({ content, segments, color, bold, inverse, backgroundColor, sliceStart, sliceEnd }) {
+	if (sliceStart >= 0 && sliceEnd > sliceStart) {
+		const highlight = /* @__PURE__ */ jsx(Text, {
+			backgroundColor: COLORS.selectionBg,
+			color: COLORS.selectionFg,
+			children: content.slice(sliceStart, sliceEnd)
+		});
+		if (segments !== void 0) return /* @__PURE__ */ jsxs(Text, {
+			backgroundColor,
+			children: [
+				renderSegments(segments, 0, sliceStart, color ?? COLORS.ink),
+				highlight,
+				renderSegments(segments, sliceEnd, content.length, color ?? COLORS.ink)
+			]
+		});
+		return /* @__PURE__ */ jsxs(Text, {
+			backgroundColor,
+			inverse,
+			color: color ?? COLORS.ink,
+			bold,
+			children: [
+				content.slice(0, sliceStart),
+				highlight,
+				content.slice(sliceEnd)
+			]
+		});
+	}
+	if (segments !== void 0) return /* @__PURE__ */ jsx(Text, {
+		backgroundColor,
+		children: renderSegments(segments, 0, content.length, color ?? COLORS.ink)
+	});
+	return /* @__PURE__ */ jsx(Text, {
+		backgroundColor,
+		inverse,
+		color: color ?? COLORS.ink,
+		bold,
+		children: content
+	});
+}, (prev, next) => prev.content === next.content && prev.segments === next.segments && prev.color === next.color && prev.bold === next.bold && prev.inverse === next.inverse && prev.backgroundColor === next.backgroundColor && prev.sliceStart === next.sliceStart && prev.sliceEnd === next.sliceEnd);
+const SelectableText = function SelectableText({ y, col, text, segments, color, bold = false, inverse = false, backgroundColor, messageLayer = false, flow = false }) {
+	const selection = useContext(SelectionContext);
+	const origin = useOrigin();
+	const absY = origin.y + y;
+	const absCol = origin.x + col;
+	const content = text ?? segments?.map((segment) => segment.text).join("") ?? "";
+	const pieceId = useRef({});
+	useLayoutEffect(() => {
+		registerRowPiece(pieceId.current, absY, {
+			col: absCol,
+			text: content,
+			...messageLayer ? { layer: "message" } : {}
+		});
+		return () => registerRowPiece(pieceId.current, absY, null);
+	}, [
+		absY,
+		absCol,
+		content,
+		messageLayer
+	]);
+	let sliceStart = -1;
+	let sliceEnd = -1;
+	if (selection !== null) {
+		const range = selectedRange(selection, absY);
+		if (range !== null && (flow || envelopeOverlaps(selection, absCol, textWidth(content)))) {
+			const lineWidth = textWidth(content);
+			const start = Math.max(range.start, absCol);
+			const end = Math.min(range.end, absCol + lineWidth);
+			if (start < end) {
+				sliceStart = colToCharIndex(content, start - absCol);
+				sliceEnd = colToCharIndex(content, end - absCol);
+			}
+		}
+	}
+	return /* @__PURE__ */ jsx(SelectableContent, {
+		content,
+		segments,
+		color,
+		bold,
+		inverse,
+		backgroundColor,
+		sliceStart,
+		sliceEnd
+	});
+};
+function renderSegments(segments, start, end, baseColor) {
+	const out = [];
+	let offset = 0;
+	for (const segment of segments) {
+		const segmentStart = offset;
+		const segmentEnd = offset + segment.text.length;
+		offset = segmentEnd;
+		if (segmentEnd <= start || segmentStart >= end) continue;
+		const from = Math.max(0, start - segmentStart);
+		const to = Math.min(segment.text.length, end - segmentStart);
+		if (from >= to) continue;
+		out.push(/* @__PURE__ */ jsx(Text, {
+			color: segment.style.color ?? baseColor,
+			bold: segment.style.bold,
+			italic: segment.style.italic,
+			underline: segment.style.underline,
+			strikethrough: segment.style.strike,
+			backgroundColor: segment.style.background,
+			children: segment.text.slice(from, to)
+		}, out.length));
+	}
+	return out;
+}
+//#endregion
+//#region src/terminal/mouse.ts
+const MOUSE_ENABLE_SEQUENCES = "\x1B[?1003l\x1B[?1000h\x1B[?1002h\x1B[?1006h";
+const MOUSE_DISABLE_SEQUENCES = "\x1B[?1003l\x1B[?1000l\x1B[?1002l\x1B[?1006l";
+function writeMouseEnable() {
+	process.stdout.write(MOUSE_ENABLE_SEQUENCES);
+}
+function writeMouseDisable() {
+	process.stdout.write(MOUSE_DISABLE_SEQUENCES);
+}
+const MAX_BUFFER = 64;
+const SGR_PREFIX = "\x1B[<";
+function partialPrefixLength(buffer) {
+	for (let keep = Math.min(2, buffer.length); keep > 0; keep--) if (SGR_PREFIX.startsWith(buffer.slice(-keep))) return keep;
+	return 0;
+}
+function createMouseParser(onEvent) {
+	let buffer = "";
+	const pressedButtons = /* @__PURE__ */ new Set();
+	function parseSequenceAt(str, offset) {
+		if (!str.startsWith("\x1B[<", offset)) return null;
+		let index = offset + 3;
+		const values = [];
+		let current = 0;
+		let hasDigit = false;
+		let terminator = "";
+		for (; index < str.length; index++) {
+			const ch = str[index];
+			if (ch >= "0" && ch <= "9") {
+				current = current * 10 + (ch.charCodeAt(0) - 48);
+				hasDigit = true;
+			} else if (ch === ";" && hasDigit) {
+				values.push(current);
+				current = 0;
+				hasDigit = false;
+			} else if (ch === "M" || ch === "m") {
+				if (!hasDigit) return null;
+				values.push(current);
+				terminator = ch;
+				break;
+			} else return null;
+		}
+		if (terminator === "") return null;
+		if (values.length !== 3) return null;
+		return {
+			event: decodeSgrEvent(values[0], values[1], values[2], terminator, pressedButtons),
+			consumed: index - offset + 1
+		};
+	}
+	return { feed(chunk) {
+		buffer += chunk;
+		while (true) {
+			const start = buffer.indexOf("\x1B[<");
+			if (start === -1) {
+				const keep = partialPrefixLength(buffer);
+				buffer = keep === 0 ? "" : buffer.slice(-keep);
+				return;
+			}
+			if (start > 0) {
+				buffer = buffer.slice(start);
+				continue;
+			}
+			if (buffer.length > MAX_BUFFER) {
+				buffer = "";
+				return;
+			}
+			const parsed = parseSequenceAt(buffer, 0);
+			if (parsed === null) return;
+			const { event, consumed } = parsed;
+			buffer = buffer.slice(consumed);
+			onEvent(event);
+		}
+	} };
+}
+function decodeSgrEvent(rawButtonCode, wireX, wireY, pressRelease, pressed) {
+	const button = rawButtonCode & 3;
+	const isScroll = (rawButtonCode & 64) !== 0;
+	const isMotion = (rawButtonCode & 32) !== 0;
+	const modifiers = {
+		shift: (rawButtonCode & 4) !== 0,
+		alt: (rawButtonCode & 8) !== 0,
+		ctrl: (rawButtonCode & 16) !== 0
+	};
+	let type;
+	let scrollDirection;
+	if (isScroll) {
+		type = "scroll";
+		scrollDirection = button === 0 ? "up" : "down";
+	} else if (isMotion) type = pressed.size > 0 ? "drag" : "move";
+	else if (pressRelease === "M") {
+		type = "down";
+		if (button !== 3) pressed.add(button);
+	} else {
+		type = "up";
+		if (button === 3) pressed.clear();
+		else pressed.delete(button);
+	}
+	return {
+		type,
+		button: button === 3 ? 0 : button,
+		x: wireX - 1,
+		y: wireY - 1,
+		modifiers,
+		...scrollDirection === void 0 ? {} : { scrollDirection }
+	};
+}
+function isMouseResidue(input) {
+	return input.includes("\x1B") || /^\[<\d+(;\d+)*[Mm]$/.test(input);
+}
+function createMouseController(onEvent) {
+	const parser = createMouseParser(onEvent);
+	const onData = (chunk) => parser.feed(chunk.toString("latin1"));
+	return {
+		enable() {
+			writeMouseEnable();
+			process.stdin.on("data", onData);
+		},
+		disable() {
+			writeMouseDisable();
+			process.stdin.off("data", onData);
+		}
+	};
+}
+//#endregion
+//#region src/ui/key-arbiter.ts
+/**
+* Key-event suppression for ink's broadcast-based useInput.
+*
+* ink delivers every stdin chunk to every useInput subscriber, and delivery
+* order follows subscription order: KeymapGate (chrome key contributions,
+* mounted as the first child) -> message list -> composer -> panels ->
+* dialog -> the App shell. A participant that must win over the later ones
+* marks the current event consumed; later participants skip it.
+*
+* The consumed flag is scoped to one stdin chunk. KeymapGate bumps the
+* generation from its own stdin data listener, so even several synchronous
+* writes (as tests do) each get a fresh generation and no flag leaks across
+* events.
+*/
+let generation = 0;
+let consumedAtGeneration = -1;
+/** Start a new key-event generation; called once per stdin chunk. */
+function beginKeyEvent() {
+	generation += 1;
+}
+/** Chrome key contributions consumed the event; later participants must skip it. */
+function markKeymapConsumed() {
+	consumedAtGeneration = generation;
+}
+/** True when the chrome key chain consumed the current key event. */
+function isKeyConsumed() {
+	return consumedAtGeneration === generation;
+}
+//#endregion
+//#region src/ui/hooks/use-caret.ts
+/**
+* Ink 7.1.1 rests the hardware cursor one row above where frames without a
+* trailing newline end; this layout fills the viewport, so request one row
+* lower.
+*/
+function useCaret() {
+	const { setCursorPosition } = useCursor();
+	return { setCursorPosition: useCallback((position) => {
+		if (position === void 0) {
+			setCursorPosition(void 0);
+			return;
+		}
+		setCursorPosition({
+			x: position.x,
+			y: position.y + 1
+		});
+	}, [setCursorPosition]) };
+}
+//#endregion
+//#region src/core/caret-nonce.ts
+/**
+* Ink 7.1.1 places the caret one row high on the rewrite path; every caret
+* move changes these frame bytes so the diff renderer stays on the rewrite
+* path that useCaret() compensates for. The variant span exceeds any
+* terminal width, so no frame follows the misplaced cursor-only path.
+*/
+const NONCE_SPAN = 240;
+function caretNonceColor(cursor) {
+	return `ansi256(${16 + cursor % NONCE_SPAN})`;
+}
+function caretNonceText(cursor) {
+	return Math.floor(cursor / NONCE_SPAN) % 2 === 0 ? " " : "\xA0";
+}
+function caretNonceBold(cursor) {
+	return Math.floor(cursor / 480) % 2 === 0;
+}
+//#endregion
+//#region src/terminal/cursor-shape.ts
+const SEQUENCES = {
+	beam: "\x1B[1 q",
+	block: "\x1B[2 q",
+	reset: "\x1B[0 q",
+	hide: "\x1B[?25l",
+	show: "\x1B[?25h"
+};
+function writeCursorShape(shape) {
+	process.stdout.write(SEQUENCES[shape]);
+}
+//#endregion
+//#region src/ui/chrome/caps.tsx
+function CapText({ background, top, width }) {
+	if (glyphs.halfBlockCaps) return /* @__PURE__ */ jsx(Text, {
+		color: background,
+		children: (top ? glyphs.blockCapTop : glyphs.blockCapBottom).repeat(width)
+	});
+	return /* @__PURE__ */ jsx(Text, {
+		backgroundColor: background,
+		children: " ".repeat(width)
+	});
+}
+//#endregion
+//#region src/core/edit.ts
+function clamp(state, cursor) {
+	return {
+		value: state.value,
+		cursor: Math.max(0, Math.min(cursor, state.value.length))
+	};
+}
+function spanAtOrBefore(value, cursor) {
+	for (const segment of segmentGraphemes(value)) {
+		const end = segment.index + segment.segment.length;
+		if (end >= cursor) return {
+			start: segment.index,
+			end
+		};
+	}
+}
+function spanAtOrAfter(value, cursor) {
+	for (const segment of segmentGraphemes(value)) if (segment.index >= cursor) return {
+		start: segment.index,
+		end: segment.index + segment.segment.length
+	};
+}
+function editInsert(state, text) {
+	if (text === "") return clamp(state, state.cursor);
+	const cursor = Math.max(0, Math.min(state.cursor, state.value.length));
+	return {
+		value: state.value.slice(0, cursor) + text + state.value.slice(cursor),
+		cursor: cursor + text.length
+	};
+}
+function editBackspace(state) {
+	if (state.cursor <= 0) return null;
+	const span = spanAtOrBefore(state.value, state.cursor);
+	if (span === void 0) return null;
+	return {
+		value: state.value.slice(0, span.start) + state.value.slice(span.end),
+		cursor: span.start
+	};
+}
+function editDelete(state) {
+	if (state.cursor >= state.value.length) return null;
+	const span = spanAtOrAfter(state.value, state.cursor);
+	if (span === void 0) return null;
+	return {
+		value: state.value.slice(0, state.cursor) + state.value.slice(span.end),
+		cursor: state.cursor
+	};
+}
+function editCursorLeft(state) {
+	if (state.cursor <= 0) return state;
+	const span = spanAtOrBefore(state.value, state.cursor);
+	return clamp(state, span === void 0 ? state.cursor - 1 : span.start);
+}
+function editCursorRight(state) {
+	if (state.cursor >= state.value.length) return state;
+	const span = spanAtOrAfter(state.value, state.cursor);
+	return clamp(state, span === void 0 ? state.cursor + 1 : span.end);
+}
+const SEPARATOR_RANGES = [
+	[8208, 8231],
+	[12288, 12351],
+	[65281, 65295],
+	[65306, 65312],
+	[65339, 65344],
+	[65371, 65381],
+	[65504, 65508]
+];
+function isAsciiWordChar(code) {
+	return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95;
+}
+function isLineBreakAt(value, index) {
+	const code = value.charCodeAt(index);
+	return code === 10 || code === 13;
+}
+function isSeparatorAt(value, index) {
+	const code = value.charCodeAt(index);
+	if (code === 10 || code === 13) return true;
+	if (isAsciiWordChar(code)) return false;
+	if (code >= 128) {
+		for (const [start, end] of SEPARATOR_RANGES) if (code >= start && code <= end) return true;
+		return false;
+	}
+	if (code === 32) return true;
+	return code >= 33 && code <= 126;
+}
+function wordLeftBoundary(value, cursor) {
+	let i = cursor - 1;
+	while (i >= 0 && !isLineBreakAt(value, i) && isSeparatorAt(value, i)) i--;
+	while (i >= 0 && !isSeparatorAt(value, i)) i--;
+	return i + 1;
+}
+function wordRightBoundary(value, cursor) {
+	if (cursor >= value.length) return cursor;
+	if (!isSeparatorAt(value, cursor)) {
+		let i = cursor;
+		while (i < value.length && !isSeparatorAt(value, i)) i++;
+		return i;
+	}
+	let i = cursor;
+	while (i < value.length && !isLineBreakAt(value, i) && isSeparatorAt(value, i)) i++;
+	while (i < value.length && !isSeparatorAt(value, i)) i++;
+	return i;
+}
+function editCursorWordLeft(state) {
+	const boundary = wordLeftBoundary(state.value, state.cursor);
+	return boundary >= state.cursor ? state : {
+		value: state.value,
+		cursor: boundary
+	};
+}
+function editCursorWordRight(state) {
+	const boundary = wordRightBoundary(state.value, state.cursor);
+	return boundary <= state.cursor ? state : {
+		value: state.value,
+		cursor: boundary
+	};
+}
+function editDeleteWordLeft(state) {
+	const boundary = wordLeftBoundary(state.value, state.cursor);
+	if (boundary >= state.cursor) return null;
+	return {
+		value: state.value.slice(0, boundary) + state.value.slice(state.cursor),
+		cursor: boundary
+	};
+}
+function editDeleteWordRight(state) {
+	const boundary = wordRightBoundary(state.value, state.cursor);
+	if (boundary <= state.cursor) return null;
+	return {
+		value: state.value.slice(0, state.cursor) + state.value.slice(boundary),
+		cursor: state.cursor
+	};
+}
+//#endregion
+//#region src/ui/widgets/registry.ts
+const widgets = keyedRegistry();
+function fallbackWidget(type) {
+	return {
+		height: () => 1,
+		paintWidth: () => 24,
+		render: ({ item }) => {
+			const label = item.label;
+			const text = typeof label === "string" && label !== "" ? `${type}: ${label}` : `${type}: (unknown item)`;
+			return createElement(Text, { dimColor: true }, text);
+		}
+	};
+}
+function registerWidget(type, def, options) {
+	return widgets.register(type, def, options);
+}
+function widgetOf(type) {
+	return widgets.get(type) ?? fallbackWidget(type);
+}
+//#endregion
+//#region src/ui/dialog/items.ts
+function isSelectableRow(row) {
+	if (row === void 0) return false;
+	return row.items.some((item) => widgetOf(item.type).selectable === true);
+}
+function selectableSpan(row) {
+	if (row === void 0) return 0;
+	let stops = 0;
+	for (const item of row.items) stops += widgetOf(item.type).stops?.(item) ?? 1;
+	return Math.max(0, stops - 1);
+}
+function snapRow(rows, row) {
+	const count = rows.length;
+	if (count === 0) return 0;
+	const index = Math.min(Math.max(row, 0), count - 1);
+	if (isSelectableRow(rows[index])) return index;
+	for (let down = index + 1; down < count; down++) if (isSelectableRow(rows[down])) return down;
+	for (let up = index - 1; up >= 0; up--) if (isSelectableRow(rows[up])) return up;
+	return index;
+}
+function stepRow(rows, from, delta) {
+	let row = from + delta;
+	while (row >= 0 && row < rows.length && !isSelectableRow(rows[row])) row += delta;
+	return row >= 0 && row < rows.length ? row : from;
+}
+function focusedItem(row, col) {
+	if (row === void 0) return void 0;
+	const only = row.items.length === 1 ? row.items[0] : void 0;
+	if (only !== void 0 && widgetOf(only.type).fullRowFocus === true) return only;
+	return row.items[col];
+}
+function moveFocus(rows, focus, key) {
+	switch (key) {
+		case "up": return {
+			row: stepRow(rows, focus.row, -1),
+			col: 0
+		};
+		case "down": return {
+			row: stepRow(rows, focus.row, 1),
+			col: 0
+		};
+		case "left": return {
+			row: focus.row,
+			col: Math.max(0, focus.col - 1)
+		};
+		case "right": {
+			const max = selectableSpan(rows[focus.row]);
+			return {
+				row: focus.row,
+				col: Math.max(0, Math.min(max, focus.col + 1))
+			};
+		}
+	}
+}
+function clampFocus(rows, focus, minRow, maxRow) {
+	const row = snapRow(rows, Math.min(Math.max(focus.row, minRow), maxRow));
+	return {
+		row,
+		col: Math.min(focus.col, selectableSpan(rows[row]))
+	};
+}
+function asTextItem(item) {
+	return widgetOf(item.type).editable === true ? item : null;
+}
+function filterRowsWithHeaders(rows, query, searchRight) {
+	const q = query.trim().toLowerCase();
+	if (q === "") return rows;
+	const matches = (item) => {
+		const texts = widgetOf(item.type).searchTexts?.(item, searchRight);
+		if (texts === void 0) return false;
+		return texts.some((text) => text.toLowerCase().includes(q));
+	};
+	const out = [];
+	let pendingHeader;
+	for (const row of rows) {
+		if (!isSelectableRow(row)) {
+			pendingHeader = row;
+			continue;
+		}
+		if (!row.items.some(matches)) continue;
+		if (pendingHeader !== void 0) {
+			out.push(pendingHeader);
+			pendingHeader = void 0;
+		}
+		out.push(row);
+	}
+	const first = out[0];
+	if (first !== void 0 && first.items.length === 1 && first.items[0]?.type === "header") out[0] = { items: [{
+		...first.items[0],
+		leadingBlank: false
+	}] };
+	return out;
+}
+const SELECT_BLOCK_WIDTH_RATIO = .6;
+const ACTION_EDGE_RATIO = .2;
+const FOOTER_MAX_LINES_PER_ENTRY = 2;
+function wrapFooter(footer, width) {
+	if (footer === void 0) return [];
+	const rows = [];
+	for (const line of footer) {
+		if (line.text === "") continue;
+		const wrapped = wrapLines(line.text, width);
+		const capped = wrapped.slice(0, FOOTER_MAX_LINES_PER_ENTRY);
+		if (wrapped.length > FOOTER_MAX_LINES_PER_ENTRY) capped[1] = truncate(capped[1] ?? "", Math.max(1, width - glyphs.ellipsis.length)) + glyphs.ellipsis;
+		for (const text of capped) rows.push({
+			text,
+			color: line.color
+		});
+	}
+	return rows;
+}
+function wrapStatusLines(lines, width) {
+	if (lines === void 0) return [];
+	const rows = [];
+	for (const line of lines) {
+		if (line.text === "") continue;
+		for (const text of wrapLines(line.text, width)) rows.push({
+			text,
+			color: line.color
+		});
+	}
+	return rows;
+}
+function rowHeight(row, width) {
+	let height = 1;
+	for (const item of row.items) {
+		const itemHeight = widgetOf(item.type).height(item, width);
+		if (itemHeight > height) height = itemHeight;
+	}
+	return height;
+}
+function rowTopOffset(rows, rowIndex, width) {
+	let offset = 0;
+	for (let i = 0; i < rowIndex; i++) offset += rowHeight(rows[i], width);
+	return offset;
+}
+function rowBlockSpan(rows, rowIndex, width) {
+	const top = rowTopOffset(rows, rowIndex, width);
+	let blockTop = top;
+	let bottom = top + rowHeight(rows[rowIndex] ?? { items: [] }, width) - 1;
+	for (let i = rowIndex - 1; i >= 0 && !isSelectableRow(rows[i]); i--) blockTop -= rowHeight(rows[i], width);
+	for (let i = rowIndex + 1; i < rows.length && !isSelectableRow(rows[i]); i++) bottom += rowHeight(rows[i], width);
+	return {
+		top: blockTop,
+		bottom
+	};
+}
+function adjustScroll(rows, focus, scrollTop, contentHeight, width) {
+	const { top, bottom } = rowBlockSpan(rows, focus.row, width);
+	if (top < scrollTop) return top;
+	if (bottom >= scrollTop + contentHeight) return Math.max(0, bottom - contentHeight + 1);
+	return scrollTop;
+}
+function listCenterScroll(rows, focusRow, viewportHeight, width, direction) {
+	const total = rows.reduce((sum, row) => sum + rowHeight(row, width), 0);
+	const maxScroll = Math.max(0, total - viewportHeight);
+	const anchor = direction === "down" ? Math.floor(viewportHeight / 2) : Math.floor((viewportHeight - 1) / 2);
+	const top = rowTopOffset(rows, focusRow, width);
+	return Math.max(0, Math.min(top - anchor, maxScroll));
+}
+function hitRowIndex(y, top, titleLines, rows, scrollTop = 0, width = Number.POSITIVE_INFINITY) {
+	const localY = y - top - 1 - titleLines + scrollTop;
+	let offset = 0;
+	for (let i = 0; i < rows.length; i++) {
+		const height = rowHeight(rows[i], width);
+		if (localY >= offset && localY < offset + height) return i;
+		offset += height;
+	}
+	return null;
+}
+function selectBlock(contentWidth, value) {
+	const blockWidth = Math.max(3, Math.floor(contentWidth * SELECT_BLOCK_WIDTH_RATIO));
+	const innerWidth = Math.max(1, blockWidth - 6);
+	const text = truncate(value || "(none)", innerWidth);
+	const padding = innerWidth - textWidth(text);
+	const fullPadding = blockWidth - textWidth(text);
+	return {
+		blockWidth,
+		blockStart: contentWidth - blockWidth,
+		text,
+		leftPad: Math.floor(padding / 2),
+		fullLeftPad: Math.floor(fullPadding / 2),
+		cursorX: 3 + Math.floor(padding / 2) + textWidth(text)
+	};
+}
+function actionPositions(contentWidth, confirmLabel, cancelLabel) {
+	const edge = Math.floor(contentWidth * ACTION_EDGE_RATIO);
+	const confirmX = Math.min(edge, Math.max(0, contentWidth - textWidth(confirmLabel)));
+	return {
+		confirmX,
+		cancelX: Math.max(confirmX + textWidth(confirmLabel), contentWidth - edge - textWidth(cancelLabel))
+	};
+}
+//#endregion
+//#region src/ui/widgets/header.tsx
+registerWidget("header", {
+	selectable: false,
+	height(item) {
+		return item.leadingBlank === true ? 2 : 1;
+	},
+	paintWidth(item) {
+		return textWidth(item.label);
+	},
+	onEnter() {
+		return true;
+	},
+	render({ item, y, x, clip }) {
+		const lead = item.leadingBlank === true && clip === 0 ? 1 : 0;
+		const label = /* @__PURE__ */ jsx(SelectableText, {
+			y: y + lead,
+			col: x,
+			text: item.label,
+			color: COLORS.sectionHeader,
+			bold: true
+		});
+		if (lead === 0) return label;
+		return /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "column",
+			children: [/* @__PURE__ */ jsx(Box, {
+				height: 1,
+				children: /* @__PURE__ */ jsx(Text, { children: " " })
+			}), label]
+		});
+	}
+}, { order: 500 });
+//#endregion
+//#region src/ui/widgets/actions.tsx
+function paddedLabel(label) {
+	return ` ${label} `;
+}
+function hitActionZone(item, width, localX) {
+	const positions = actionPositions(width, paddedLabel(item.confirmLabel), paddedLabel(item.cancelLabel));
+	if (localX >= positions.confirmX && localX < positions.confirmX + textWidth(paddedLabel(item.confirmLabel))) return "confirm";
+	if (localX >= positions.cancelX && localX < positions.cancelX + textWidth(paddedLabel(item.cancelLabel))) return "cancel";
+	return null;
+}
+registerWidget("actions", {
+	selectable: true,
+	fullRowFocus: true,
+	stops: () => 2,
+	height() {
+		return 1;
+	},
+	paintWidth() {
+		return 0;
+	},
+	render({ item, focused, width, y, x, subCol }) {
+		const confirmLabel = paddedLabel(item.confirmLabel);
+		const cancelLabel = paddedLabel(item.cancelLabel);
+		const positions = actionPositions(width, confirmLabel, cancelLabel);
+		const mid = positions.cancelX - (positions.confirmX + textWidth(confirmLabel));
+		return /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "row",
+			children: [
+				/* @__PURE__ */ jsx(Text, { children: " ".repeat(positions.confirmX) }),
+				/* @__PURE__ */ jsx(SelectableText, {
+					y,
+					col: x + positions.confirmX,
+					text: confirmLabel,
+					inverse: focused && subCol === 0
+				}),
+				/* @__PURE__ */ jsx(Text, { children: " ".repeat(Math.max(0, mid)) }),
+				/* @__PURE__ */ jsx(SelectableText, {
+					y,
+					col: x + positions.cancelX,
+					text: cancelLabel,
+					inverse: focused && subCol === 1
+				})
+			]
+		});
+	},
+	onLeftRight(item, direction, api) {
+		api.navigate(direction === 1 ? "right" : "left");
+		return true;
+	},
+	onEnter(item, api) {
+		if (api.subCol === 1) item.onCancel();
+		else item.onConfirm();
+		return true;
+	},
+	onClick(item, hit, actions) {
+		if (hit.localY !== 0) {
+			actions.focus(0);
+			return true;
+		}
+		const zone = hitActionZone(item, hit.width, hit.localX);
+		if (zone === "confirm") {
+			actions.focus(0);
+			item.onConfirm();
+			return true;
+		}
+		if (zone === "cancel") {
+			actions.focus(1);
+			item.onCancel();
+			return true;
+		}
+		actions.focus(0);
+		return true;
+	}
+}, { order: 500 });
+//#endregion
+//#region src/ui/dialog/sizes.ts
+const DIALOG_MAX_HEIGHT = .6;
+//#endregion
+//#region src/ui/widgets/input.tsx
+function scrollStart(lines, caretRow) {
+	return Math.min(Math.max(caretRow - 2, 0), Math.max(0, lines - 3));
+}
+registerWidget("input", {
+	selectable: true,
+	editable: true,
+	height(item, width) {
+		return 2 + Math.min(wrapLines(item.value, width).length, 3);
+	},
+	paintWidth(item) {
+		return textWidth(item.label);
+	},
+	caret(item, cursor, width) {
+		const point = locToPoint(item.value, width, cursor);
+		const lines = wrapLines(item.value, width).length;
+		return {
+			dy: 1 + point.row - scrollStart(lines, point.row),
+			dx: point.col
+		};
+	},
+	render({ item, focused, cursor, width, y, x, clip }) {
+		const lines = wrapLines(item.value, width);
+		const shown = Math.min(lines.length, 3);
+		const point = cursor === void 0 ? null : locToPoint(item.value, width, cursor);
+		const first = point === null ? 0 : scrollStart(lines.length, point.row);
+		const parts = [];
+		if (clip === 0) parts.push(/* @__PURE__ */ jsx(Box, {
+			height: 1,
+			children: /* @__PURE__ */ jsx(SelectableText, {
+				y,
+				col: x,
+				text: item.label,
+				color: focused ? void 0 : COLORS.dialogHintText
+			})
+		}, "label"));
+		for (let index = 0; index < shown; index++) {
+			if (1 + index < clip) continue;
+			const currentY = y + 1 + index - clip;
+			parts.push(/* @__PURE__ */ jsx(Box, {
+				width,
+				height: 1,
+				backgroundColor: COLORS.dialogInputBackground,
+				children: /* @__PURE__ */ jsx(SelectableText, {
+					y: currentY,
+					col: x,
+					text: lines[first + index]
+				})
+			}, index));
+		}
+		parts.push(/* @__PURE__ */ jsx(Box, {
+			height: 1,
+			children: /* @__PURE__ */ jsx(Text, {
+				color: focused && cursor !== void 0 ? caretNonceColor(cursor) : void 0,
+				bold: focused && cursor !== void 0 ? caretNonceBold(cursor) : void 0,
+				children: focused && cursor !== void 0 ? caretNonceText(cursor) : " "
+			})
+		}, "pad"));
+		return /* @__PURE__ */ jsx(Box, {
+			flexDirection: "column",
+			children: parts
+		});
+	},
+	onLeftRight(item, direction, api) {
+		if (direction === -1 && api.cursor > 0) api.setCursor(api.cursor - 1);
+		if (direction === 1 && api.cursor < item.value.length) api.setCursor(api.cursor + 1);
+		return true;
+	},
+	onEnter(item) {
+		if (item.onEnter !== void 0) {
+			item.onEnter();
+			return true;
+		}
+		return false;
+	}
+}, { order: 500 });
+//#endregion
+//#region src/ui/widgets/select.tsx
+function carouselHit(item, width, localX) {
+	if (item.options.length <= 1) return null;
+	const block = selectBlock(width, item.value);
+	if (localX >= block.blockStart && localX < block.blockStart + 3) return -1;
+	if (localX >= block.blockStart + block.blockWidth - 3 && localX < block.blockStart + block.blockWidth) return 1;
+	return null;
+}
+function paintSelect(paint) {
+	const { item, width, y, x } = paint;
+	const block = selectBlock(width, item.value);
+	const hasArrows = item.options.length > 1;
+	const pad = hasArrows ? block.leftPad : block.fullLeftPad;
+	const inner = block.blockWidth - (hasArrows ? 6 : 0);
+	const valueCol = x + block.blockStart + (hasArrows ? 3 : 0);
+	const valueText = " ".repeat(pad) + block.text + " ".repeat(Math.max(0, inner - pad - textWidth(block.text)));
+	const carousel = /* @__PURE__ */ jsxs(Box, {
+		width,
+		justifyContent: "space-between",
+		children: [/* @__PURE__ */ jsx(SelectableText, {
+			y,
+			col: x,
+			text: `${item.label}:`
+		}), /* @__PURE__ */ jsxs(Box, {
+			width: block.blockWidth,
+			flexDirection: "row",
+			children: [
+				hasArrows && /* @__PURE__ */ jsx(Text, {
+					color: COLORS.ink,
+					backgroundColor: paint.pressed === "left" ? COLORS.carouselButtonPressedBg : COLORS.carouselButtonBg,
+					children: ` ${glyphs.carouselLeft} `
+				}),
+				/* @__PURE__ */ jsx(SelectableText, {
+					y,
+					col: valueCol,
+					text: valueText,
+					color: paint.focused ? COLORS.carouselSelectedText : COLORS.ink,
+					backgroundColor: COLORS.carouselCurrentBg
+				}),
+				hasArrows && /* @__PURE__ */ jsx(Text, {
+					color: COLORS.ink,
+					backgroundColor: paint.pressed === "right" ? COLORS.carouselButtonPressedBg : COLORS.carouselButtonBg,
+					children: ` ${glyphs.carouselRight} `
+				})
+			]
+		})]
+	});
+	if (!item.spaced) return carousel;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [paint.clip === 0 && carousel, /* @__PURE__ */ jsx(Box, {
+			height: 1,
+			children: /* @__PURE__ */ jsx(Text, { children: " " })
+		})]
+	});
+}
+function cycle(item, direction) {
+	const index = Math.max(0, item.options.indexOf(item.value));
+	const length = item.options.length;
+	const next = item.options[(index + direction + length) % length];
+	if (next !== void 0) item.onChange(next);
+}
+registerWidget("select", {
+	selectable: true,
+	height(item) {
+		return item.spaced === true ? 2 : 1;
+	},
+	paintWidth(item) {
+		return textWidth(item.label);
+	},
+	render: paintSelect,
+	onLeftRight(item, direction) {
+		if (item.options.length <= 1) return false;
+		cycle(item, direction);
+		return true;
+	},
+	onEnter(item, api) {
+		if (item.onEnter !== void 0) {
+			item.onEnter();
+			return true;
+		}
+		api.navigate("down");
+		return true;
+	},
+	onClick(item, hit, actions) {
+		if (hit.localY !== 0) return false;
+		const direction = carouselHit(item, hit.width, hit.localX);
+		if (direction === null) return false;
+		cycle(item, direction);
+		actions.flash(direction === -1 ? "left" : "right");
+		return true;
+	}
+}, { order: 500 });
+//#endregion
+//#region src/ui/widgets/button.tsx
+function paintButton(item, paint) {
+	const { width, y, x, focused } = paint;
+	if (item.right !== void 0) {
+		const right = truncate(item.right, Math.floor(width / 2));
+		const leftWidth = Math.max(1, width - textWidth(right));
+		const label = padToWidth(truncate(item.label, leftWidth), leftWidth);
+		if (focused) return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(SelectableText, {
+			y,
+			col: x,
+			text: label,
+			inverse: true,
+			color: item.rightColor
+		}), /* @__PURE__ */ jsx(SelectableText, {
+			y,
+			col: x + leftWidth,
+			text: right,
+			inverse: true,
+			color: item.rightColor
+		})] });
+		return /* @__PURE__ */ jsxs(Box, {
+			width,
+			justifyContent: "space-between",
+			children: [/* @__PURE__ */ jsx(SelectableText, {
+				y,
+				col: x,
+				text: item.label
+			}), /* @__PURE__ */ jsx(SelectableText, {
+				y,
+				col: x + width - textWidth(right),
+				text: right,
+				color: item.rightColor ?? COLORS.dialogHintText
+			})]
+		});
+	}
+	if (focused) return /* @__PURE__ */ jsx(SelectableText, {
+		y,
+		col: x,
+		text: padToWidth(truncate(item.label, width), width),
+		inverse: true
+	});
+	return /* @__PURE__ */ jsx(SelectableText, {
+		y,
+		col: x,
+		text: item.label
+	});
+}
+registerWidget("button", {
+	selectable: true,
+	height() {
+		return 1;
+	},
+	paintWidth(item) {
+		return textWidth(item.label + (item.right ?? ""));
+	},
+	searchTexts(item, searchRight) {
+		return searchRight && item.right !== void 0 ? [item.label, item.right] : [item.label];
+	},
+	render(paint) {
+		return paintButton(paint.item, paint);
+	},
+	onEnter(item) {
+		item.onPress();
+		return true;
+	},
+	activate(item) {
+		item.onPress();
+	}
+}, { order: 500 });
+//#endregion
+//#region src/ui/widgets/checkbox.tsx
+function paintCheckbox(item, paint) {
+	const { width, y, x, focused } = paint;
+	const label = padToWidth(truncate(item.label, width - 2), width - 2);
+	const check = item.checked ? ` ${glyphs.tick}` : "  ";
+	if (focused) return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(SelectableText, {
+		y,
+		col: x,
+		text: label,
+		inverse: true
+	}), /* @__PURE__ */ jsx(SelectableText, {
+		y,
+		col: x + width - 2,
+		text: check,
+		inverse: true
+	})] });
+	return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsx(SelectableText, {
+		y,
+		col: x,
+		text: label
+	}), item.checked && /* @__PURE__ */ jsx(SelectableText, {
+		y,
+		col: x + width - 2,
+		text: ` ${glyphs.tick}`,
+		color: COLORS.success
+	})] });
+}
+registerWidget("checkbox", {
+	selectable: true,
+	height() {
+		return 1;
+	},
+	paintWidth(item) {
+		return textWidth(item.label);
+	},
+	searchTexts(item) {
+		return [item.label];
+	},
+	render(paint) {
+		return paintCheckbox(paint.item, paint);
+	},
+	onEnter(item) {
+		item.onConfirm();
+		return true;
+	},
+	onSpace(item) {
+		item.onToggle();
+	},
+	activate(item) {
+		item.onConfirm();
+	}
+}, { order: 500 });
+//#endregion
+//#region src/ui/widgets/search.tsx
+function searchTextOf(item) {
+	return item.value === "" ? "Search" : item.value;
+}
+registerWidget("search", {
+	selectable: true,
+	editable: true,
+	height() {
+		return 2;
+	},
+	paintWidth(item) {
+		return textWidth(searchTextOf(item));
+	},
+	onLeftRight(item, direction, api) {
+		const next = Math.max(0, Math.min(item.value.length, api.cursor + direction));
+		if (next === api.cursor) return false;
+		api.setCursor(next);
+		return true;
+	},
+	render({ item, cursor, width, y, x, clip }) {
+		const isEmpty = item.value === "";
+		const start = caretScrollStart(item.value, cursor ?? item.value.length, width);
+		const text = isEmpty ? "Search" : truncate(item.value.slice(start), width);
+		if (clip !== 0) return /* @__PURE__ */ jsx(Box, {
+			flexDirection: "column",
+			children: /* @__PURE__ */ jsx(Box, {
+				height: 1,
+				children: /* @__PURE__ */ jsx(Text, { children: " " })
+			})
+		});
+		return /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "column",
+			children: [/* @__PURE__ */ jsx(Box, {
+				width,
+				backgroundColor: COLORS.dialogInputBackground,
+				children: /* @__PURE__ */ jsx(SelectableText, {
+					y,
+					col: x,
+					text: padToWidth(text, width),
+					color: isEmpty ? COLORS.dialogHintText : void 0
+				})
+			}), /* @__PURE__ */ jsx(Box, {
+				height: 1,
+				children: /* @__PURE__ */ jsx(Text, {
+					color: cursor !== void 0 ? caretNonceColor(cursor) : void 0,
+					bold: cursor !== void 0 ? caretNonceBold(cursor) : void 0,
+					children: cursor !== void 0 ? caretNonceText(cursor) : " "
+				})
+			})]
+		});
+	}
+}, { order: 500 });
+//#endregion
+//#region src/ui/widgets/static.tsx
+registerWidget("static", {
+	selectable: false,
+	height(item, width) {
+		return Math.max(1, wrapLines(item.label, Math.max(4, width)).length);
+	},
+	paintWidth(item) {
+		return textWidth(item.label);
+	},
+	render({ item, width, y, x }) {
+		const lines = item.label === "" ? [""] : wrapLines(item.label, Math.max(4, width));
+		if (lines.length === 1) return /* @__PURE__ */ jsx(SelectableText, {
+			y,
+			col: x,
+			text: item.label === "" ? " " : item.label,
+			color: item.label === "" ? void 0 : COLORS.toolBodyText
+		});
+		return /* @__PURE__ */ jsx(Box, {
+			flexDirection: "column",
+			children: lines.map((line, index) => /* @__PURE__ */ jsx(SelectableText, {
+				y: y + index,
+				col: x,
+				text: line === "" ? " " : line,
+				color: line === "" ? void 0 : COLORS.toolBodyText
+			}, index))
+		});
+	}
+}, { order: 500 });
+//#endregion
+//#region src/ui/dialog/dialog-item.tsx
+function renderRow(row, focused, contentWidth, baseY, left, pressed = null, subCol = 0, clip = 0, cursor) {
+	let col = left;
+	return /* @__PURE__ */ jsx(Box, {
+		flexDirection: "row",
+		children: row.items.map((item, index) => {
+			const def = widgetOf(item.type);
+			const next = def.render({
+				item,
+				focused,
+				width: contentWidth,
+				y: baseY,
+				x: col,
+				pressed,
+				subCol,
+				clip,
+				cursor: focused ? cursor : void 0
+			});
+			col += def.paintWidth(item) + 1;
+			return /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "row",
+				children: [index > 0 && /* @__PURE__ */ jsx(Text, { children: " " }), next]
+			}, index);
+		})
+	});
+}
+//#endregion
+//#region src/ui/dialog/use-dialog-input.ts
+function applyNavigation(live, direction, search, setters, centerScroll = false) {
+	const next = moveFocus(live.rows, live.focus, direction);
+	const clamped = clampFocus(live.rows, next, live.focusMinRow, live.focusMaxRow);
+	setters.setFocus(clamped);
+	const contentRow = Math.max(0, clamped.row - (search ? 1 : 0));
+	setters.setScrollTop(centerScroll && (direction === "up" || direction === "down") ? listCenterScroll(live.contentRows, contentRow, live.viewportHeight, live.contentWidth, direction) : adjustScroll(live.contentRows, {
+		row: contentRow,
+		col: clamped.col
+	}, live.scrollTop, live.viewportHeight, live.contentWidth));
+}
+function arrowFromRaw(input) {
+	const match = /^(?:\[|O)(?:1;)?\d*(?::\d+)?([ABCD])$/.exec(input);
+	if (match === null) return null;
+	const letter = match[1];
+	return letter === "A" ? "up" : letter === "B" ? "down" : letter === "C" ? "right" : "left";
+}
+function useDialogInput(options) {
+	const { live, search, closeGuarded, onClose, onCtrlA, onCtrlD, onCtrlE, onActivity, requestSearch, setFocus, setScrollTop, setCursor } = options;
+	const setters = {
+		setFocus,
+		setScrollTop
+	};
+	const centerScroll = options.centerScroll === true;
+	usePaste((text) => {
+		onActivity?.();
+		const state = live.current;
+		const current = focusedItem(state.rows[state.focus.row], state.focus.col);
+		const textItem = current === void 0 ? null : asTextItem(current);
+		if (textItem === null) return;
+		const normalized = text.replace(/\r\n?/g, "\n");
+		if (normalized === "") return;
+		const next = editInsert({
+			value: textItem.value,
+			cursor: state.cursor
+		}, normalized);
+		textItem.onChange(next.value);
+		state.value = next.value;
+		state.cursor = next.cursor;
+		setCursor(next.cursor);
+	});
+	useInput((input, key) => {
+		if (isKeyConsumed()) return;
+		const state = live.current;
+		const liveCurrent = focusedItem(state.rows[state.focus.row], state.focus.col);
+		const rawArrow = arrowFromRaw(input);
+		const isUp = key.upArrow || rawArrow === "up";
+		const isDown = key.downArrow || rawArrow === "down";
+		const isLeft = key.leftArrow || rawArrow === "left";
+		const isRight = key.rightArrow || rawArrow === "right";
+		if (key.ctrl && input === "a" && onCtrlA !== void 0 && onCtrlA(liveCurrent)) return;
+		if (key.ctrl && input === "d" && onCtrlD !== void 0 && onCtrlD(liveCurrent)) return;
+		if (key.ctrl && input === "e" && onCtrlE !== void 0 && onCtrlE(liveCurrent)) return;
+		onActivity?.();
+		if (key.escape || key.ctrl && input === "c") {
+			if (!(key.ctrl && closeGuarded)) onClose();
+			return;
+		}
+		const def = liveCurrent === void 0 ? void 0 : widgetOf(liveCurrent.type);
+		const keyApi = {
+			cursor: state.cursor,
+			subCol: state.focus.col,
+			setCursor(next) {
+				state.cursor = next;
+				setCursor(next);
+			},
+			navigate(direction) {
+				applyNavigation(state, direction, search, setters, centerScroll);
+			}
+		};
+		if ((isLeft || isRight) && liveCurrent !== void 0 && def !== void 0) {
+			if (def.onLeftRight?.(liveCurrent, isRight ? 1 : -1, keyApi) === true) return;
+		}
+		if (isUp || isDown) {
+			applyNavigation(state, isUp ? "up" : "down", search, setters, centerScroll);
+			return;
+		}
+		if (key.return) {
+			if (liveCurrent === void 0 || def === void 0) return;
+			if (!(def.onEnter?.(liveCurrent, keyApi) ?? false)) applyNavigation(state, "down", search, setters, centerScroll);
+			return;
+		}
+		if (input === " " && liveCurrent !== void 0 && def?.onSpace !== void 0) {
+			def.onSpace(liveCurrent);
+			return;
+		}
+		const editingFormInput = liveCurrent !== void 0 && liveCurrent.type !== "search" && widgetOf(liveCurrent.type).editable === true;
+		if (search && !editingFormInput) {
+			const v = state.searchValue;
+			const caret = state.focus.row === 0 ? Math.max(0, Math.min(state.cursor, v.length)) : v.length;
+			if (isLeft || isRight) {
+				const next = Math.max(0, Math.min(v.length, caret + (isRight ? 1 : -1)));
+				if (next !== caret) {
+					state.cursor = next;
+					setCursor(next);
+				}
+				return;
+			}
+			const applyEdit = (next) => {
+				if (next === null) return false;
+				requestSearch(next.value);
+				state.cursor = next.cursor;
+				setCursor(next.cursor);
+				return true;
+			};
+			if (key.backspace) {
+				applyEdit(editBackspace({
+					value: v,
+					cursor: caret
+				}));
+				return;
+			}
+			if (key.delete) {
+				applyEdit(editDelete({
+					value: v,
+					cursor: caret
+				}));
+				return;
+			}
+			if (input && !key.ctrl && !key.meta && !isMouseResidue(input)) {
+				applyEdit(editInsert({
+					value: v,
+					cursor: caret
+				}, input));
+				return;
+			}
+		}
+		if (def?.editable === true && liveCurrent !== void 0) {
+			const textItem = asTextItem(liveCurrent);
+			if (textItem === null) return;
+			const apply = (next, trackCursor) => {
+				if (next === null) return false;
+				state.value = next.value;
+				textItem.onChange(next.value);
+				if (trackCursor) {
+					state.cursor = next.cursor;
+					setCursor(next.cursor);
+				}
+				return true;
+			};
+			if (key.backspace) apply(editBackspace({
+				value: state.value,
+				cursor: state.cursor
+			}), true);
+			else if (key.delete) apply(editDelete({
+				value: state.value,
+				cursor: state.cursor
+			}), false);
+			else if (input && !key.ctrl && !key.meta && !isMouseResidue(input)) apply(editInsert({
+				value: state.value,
+				cursor: state.cursor
+			}, input), true);
+		}
+	});
+}
+//#endregion
+//#region src/ui/dialog/dialog.tsx
+const CloseGuardContext = createContext(false);
+function Dialog({ width, maxHeight, title, rows, footer, errors, onClose, search = false, searchRight = false, centerScroll = false, onCtrlA, onCtrlD, onCtrlE, onActivity, ref }) {
+	const { stdout } = useStdout();
+	const { setCursorPosition } = useCaret();
+	const closeGuarded = useContext(CloseGuardContext);
+	const columns = stdout?.columns ?? 80;
+	const totalRows = stdout?.rows ?? 24;
+	const [scrollTop, setScrollTop] = useState(0);
+	const [cursor, setCursor] = useState(0);
+	const cursorSyncRef = useRef({
+		row: -1,
+		col: -1,
+		type: void 0
+	});
+	const [searchValue, setSearchValue] = useState("");
+	const [carouselPress, setCarouselPress] = useState(null);
+	const carouselPressTimer = useRef(void 0);
+	const [errorScrollTop, setErrorScrollTop] = useState(0);
+	const handleSearch = (value) => {
+		setSearchValue(value);
+		setScrollTop(0);
+	};
+	const searchRow = { items: [{
+		type: "search",
+		value: searchValue,
+		onChange: handleSearch
+	}] };
+	const filteredRows = search ? filterRowsWithHeaders(rows, searchValue, searchRight) : rows;
+	const displayRows = search ? [searchRow, ...filteredRows] : rows;
+	const contentRows = search ? filteredRows : rows;
+	const [focus, setFocus] = useState(() => ({
+		row: snapRow(search ? [searchRow, ...rows] : rows, search ? 1 : 0),
+		col: 0
+	}));
+	const widthCells = width <= 1 ? Math.floor(columns * width) : width;
+	const windowWidth = Math.min(Math.max(1, widthCells), columns);
+	const contentWidth = Math.max(1, windowWidth - 4);
+	const fixedHeight = search ? rowHeight(searchRow, contentWidth) : 0;
+	const focusMinRow = search ? 1 : 0;
+	const focusMaxRow = Math.max(0, displayRows.length - 1);
+	useEffect(() => {
+		setFocus((current) => {
+			const next = clampFocus(displayRows, current, focusMinRow, focusMaxRow);
+			return next.row === current.row && next.col === current.col ? current : next;
+		});
+	}, [
+		displayRows,
+		focusMinRow,
+		focusMaxRow
+	]);
+	const errorKey = (errors ?? []).map((line) => line.text).join("\n");
+	useEffect(() => {
+		setErrorScrollTop(0);
+	}, [errorKey]);
+	const titleLines = title === void 0 ? 0 : 2;
+	const footerRows = wrapFooter(footer, contentWidth);
+	const extraHeight = footerRows.length > 0 ? 1 + footerRows.length : 0;
+	const desired = displayRows.reduce((sum, row) => sum + rowHeight(row, contentWidth), 0) + titleLines + extraHeight + 2;
+	const maxRows = Math.max(1, maxHeight <= 1 ? Math.floor(totalRows * maxHeight) : maxHeight);
+	const windowHeight = Math.min(desired, maxRows, totalRows);
+	const contentHeight = Math.max(1, windowHeight - 2 - titleLines - extraHeight);
+	const viewportHeight = Math.max(1, contentHeight - fixedHeight);
+	const top = Math.max(0, Math.floor((totalRows - windowHeight) / 2));
+	const left = Math.max(0, Math.floor((columns - windowWidth) / 2));
+	const frameLeft = 2;
+	const errorRows = wrapStatusLines(errors, contentWidth);
+	const availableBelow = Math.max(0, totalRows - (top + windowHeight));
+	const errorVisible = Math.max(0, Math.min(3, errorRows.length, availableBelow - 1));
+	const maxErrorScroll = Math.max(0, errorRows.length - errorVisible);
+	const errorScroll = Math.min(errorScrollTop, maxErrorScroll);
+	const headerBottom = 1 + titleLines;
+	const contentTop = headerBottom + fixedHeight;
+	const safeFocus = {
+		row: Math.min(Math.max(focus.row, 0), focusMaxRow),
+		col: Math.min(Math.max(focus.col, 0), selectableSpan(displayRows[focus.row]))
+	};
+	const contentRowsHeight = contentRows.reduce((sum, row) => sum + rowHeight(row, contentWidth), 0);
+	const maxScroll = Math.max(0, contentRowsHeight - viewportHeight);
+	const scroll = adjustScroll(contentRows, {
+		row: Math.max(0, safeFocus.row - (search ? 1 : 0)),
+		col: 0
+	}, Math.min(scrollTop, maxScroll), viewportHeight, contentWidth);
+	const live = useRef({
+		rows: displayRows,
+		contentRows,
+		focus,
+		scrollTop: scroll,
+		cursor,
+		value: "",
+		searchValue,
+		viewportHeight,
+		focusMinRow,
+		focusMaxRow,
+		contentWidth,
+		top,
+		windowHeight
+	});
+	live.current.rows = displayRows;
+	live.current.contentRows = contentRows;
+	live.current.focus = focus;
+	live.current.scrollTop = scroll;
+	live.current.searchValue = searchValue;
+	live.current.viewportHeight = viewportHeight;
+	live.current.focusMinRow = focusMinRow;
+	live.current.focusMaxRow = focusMaxRow;
+	live.current.contentWidth = contentWidth;
+	live.current.top = top;
+	live.current.windowHeight = windowHeight;
+	const errorLive = useRef({
+		top: 0,
+		height: 0,
+		maxScroll: 0
+	});
+	errorLive.current = {
+		top: top + windowHeight,
+		height: errorVisible + 1,
+		maxScroll: maxErrorScroll
+	};
+	const current = focusedItem(displayRows[safeFocus.row], safeFocus.col);
+	const currentText = current === void 0 ? null : asTextItem(current);
+	live.current.value = currentText?.value ?? "";
+	const effectiveCursor = cursorSyncRef.current.row === safeFocus.row && cursorSyncRef.current.col === safeFocus.col && cursorSyncRef.current.type === current?.type || currentText === null || currentText.type === "search" ? cursor : currentText.value.length;
+	live.current.cursor = effectiveCursor;
+	useEffect(() => {
+		cursorSyncRef.current = {
+			row: safeFocus.row,
+			col: safeFocus.col,
+			type: current?.type
+		};
+		if (currentText !== null && currentText.type !== "search") setCursor(currentText.value.length);
+	}, [
+		current?.type,
+		safeFocus.row,
+		safeFocus.col,
+		displayRows.length
+	]);
+	const editingFormInput = current !== void 0 && current.type !== "search" && asTextItem(current) !== null;
+	if (search && !editingFormInput) {
+		const caret = Math.min(Math.max(0, cursor), searchValue.length);
+		const start = caretScrollStart(searchValue, caret, contentWidth);
+		setCursorPosition({
+			x: left + frameLeft + textWidth(searchValue.slice(start, caret)),
+			y: top + headerBottom
+		});
+	} else {
+		const caretOffset = current === void 0 ? void 0 : widgetOf(current.type).caret?.(current, effectiveCursor, contentWidth);
+		if (caretOffset === void 0) setCursorPosition(void 0);
+		else {
+			const rowOffset = rowTopOffset(contentRows, Math.max(0, safeFocus.row - (search ? 1 : 0)), contentWidth);
+			setCursorPosition({
+				x: left + frameLeft + caretOffset.dx,
+				y: top + contentTop + rowOffset + caretOffset.dy - scroll
+			});
+		}
+	}
+	useEffect(() => {
+		if (search && !editingFormInput) {
+			writeCursorShape("beam");
+			return;
+		}
+		writeCursorShape(current !== void 0 && widgetOf(current.type).caret !== void 0 ? "beam" : "block");
+	}, [
+		current?.type,
+		safeFocus.row,
+		safeFocus.col
+	]);
+	useEffect(() => {
+		return () => {
+			writeCursorShape("reset");
+			clearTimeout(carouselPressTimer.current);
+		};
+	}, []);
+	useDialogInput({
+		live,
+		search,
+		closeGuarded,
+		centerScroll,
+		onClose,
+		onCtrlA,
+		onCtrlD,
+		onCtrlE,
+		onActivity,
+		requestSearch: handleSearch,
+		setFocus,
+		setScrollTop,
+		setCursor
+	});
+	const flashCarousel = (row, side) => {
+		setCarouselPress({
+			row,
+			side
+		});
+		clearTimeout(carouselPressTimer.current);
+		carouselPressTimer.current = setTimeout(() => setCarouselPress(null), 120);
+	};
+	useImperativeHandle(ref, () => ({
+		wheelAt(y, dir) {
+			onActivity?.();
+			if (y < live.current.top || y >= live.current.top + live.current.windowHeight) {
+				const error = errorLive.current;
+				if (error.height > 1 && y >= error.top && y < error.top + error.height) {
+					setErrorScrollTop((current) => Math.max(0, Math.min(current + dir, error.maxScroll)));
+					return true;
+				}
+				return false;
+			}
+			applyNavigation(live.current, dir === -1 ? "up" : "down", search, {
+				setFocus,
+				setScrollTop
+			}, centerScroll);
+			return true;
+		},
+		clickAt(y, x) {
+			onActivity?.();
+			if (y < top || y >= top + windowHeight || x < left || x >= left + windowWidth) return;
+			if (search) {
+				const searchTop = top + headerBottom;
+				if (y >= searchTop && y < searchTop + fixedHeight) {
+					const clickCaret = safeFocus.row === 0 ? Math.min(cursor, searchValue.length) : searchValue.length;
+					const start = caretScrollStart(searchValue, clickCaret, contentWidth);
+					const visible = truncate(searchValue.slice(start), contentWidth);
+					const col = Math.max(0, Math.min(x - (left + frameLeft), textWidth(visible)));
+					setFocus({
+						row: 0,
+						col: 0
+					});
+					setCursor(Math.min(searchValue.length, start + colToCharIndex(visible, col)));
+					return;
+				}
+			}
+			const rowIndex = hitRowIndex(y, top + fixedHeight, titleLines, contentRows, scroll, contentWidth);
+			if (rowIndex === null) return;
+			const rowSpec = contentRows[rowIndex];
+			if (!isSelectableRow(rowSpec)) return;
+			const displayRow = Math.min(Math.max(rowIndex + (search ? 1 : 0), focusMinRow), focusMaxRow);
+			const rowOffset = rowTopOffset(contentRows, rowIndex, contentWidth);
+			const hit = {
+				localX: x - (left + frameLeft),
+				localY: y - (top + contentTop + rowOffset - scroll),
+				width: contentWidth
+			};
+			const clickActions = {
+				focus: (col) => setFocus({
+					row: displayRow,
+					col
+				}),
+				flash: (side) => flashCarousel(rowIndex, side)
+			};
+			for (const item of rowSpec?.items ?? []) if (widgetOf(item.type).onClick?.(item, hit, clickActions) === true) return;
+			if (safeFocus.row === displayRow && rowSpec !== void 0) {
+				const first = rowSpec.items[0];
+				if (first !== void 0) {
+					const activate = widgetOf(first.type).activate;
+					if (activate !== void 0) {
+						activate(first);
+						return;
+					}
+				}
+			}
+			setFocus({
+				row: displayRow,
+				col: 0
+			});
+			const contentRow = Math.max(0, Math.min(rowIndex, contentRows.length - 1));
+			setScrollTop(adjustScroll(contentRows, {
+				row: contentRow,
+				col: 0
+			}, scroll, viewportHeight, contentWidth));
+		}
+	}));
+	const visibleRows = [];
+	let offset = 0;
+	for (let i = 0; i < contentRows.length; i++) {
+		const height = rowHeight(contentRows[i], contentWidth);
+		if (offset + height <= scroll) {
+			offset += height;
+			continue;
+		}
+		if (offset >= scroll + viewportHeight) break;
+		const clip = Math.max(0, scroll - offset);
+		const rel = Math.max(0, offset - scroll);
+		const baseY = contentTop + rel;
+		const focused = safeFocus.row === i + (search ? 1 : 0);
+		visibleRows.push(/* @__PURE__ */ jsx(Box, {
+			position: "absolute",
+			top: rel,
+			left: 0,
+			width: contentWidth,
+			children: renderRow(contentRows[i], focused, contentWidth, baseY, frameLeft, carouselPress?.row === i ? carouselPress.side : null, focused ? safeFocus.col : 0, clip, focused ? effectiveCursor : void 0)
+		}, `row-${i}`));
+		offset += height;
+	}
+	return /* @__PURE__ */ jsxs(Region, {
+		x: left,
+		y: top,
+		children: [/* @__PURE__ */ jsxs(Box, {
+			position: "absolute",
+			top,
+			left,
+			width: windowWidth,
+			height: windowHeight,
+			flexDirection: "column",
+			backgroundColor: COLORS.dialogBackground,
+			paddingLeft: 2,
+			paddingRight: 2,
+			paddingTop: 1,
+			paddingBottom: 1,
+			children: [
+				title !== void 0 && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Box, {
+					justifyContent: "center",
+					children: /* @__PURE__ */ jsx(SelectableText, {
+						y: 1,
+						col: frameLeft + Math.max(0, Math.floor((contentWidth - textWidth(title)) / 2)),
+						text: title
+					})
+				}), /* @__PURE__ */ jsx(Box, {
+					height: 1,
+					children: /* @__PURE__ */ jsx(Text, { children: " " })
+				})] }),
+				/* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					children: [search && /* @__PURE__ */ jsx(Box, {
+						flexDirection: "column",
+						children: renderRow(searchRow, safeFocus.row === 0, contentWidth, headerBottom, frameLeft, null, 0, 0, cursor)
+					}), /* @__PURE__ */ jsx(Box, {
+						flexDirection: "column",
+						height: viewportHeight,
+						overflow: "hidden",
+						children: visibleRows
+					})]
+				}),
+				footerRows.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Box, {
+					height: 1,
+					children: /* @__PURE__ */ jsx(Text, { children: " " })
+				}), footerRows.map((line, index) => /* @__PURE__ */ jsx(SelectableText, {
+					y: windowHeight - footerRows.length + index - 1,
+					col: frameLeft,
+					text: line.text,
+					color: line.color
+				}, index))] })
+			]
+		}), errorVisible > 0 && /* @__PURE__ */ jsx(Box, {
+			position: "absolute",
+			top: top + windowHeight,
+			left,
+			width: windowWidth,
+			height: errorVisible + 1,
+			flexDirection: "column",
+			backgroundColor: COLORS.dialogBackground,
+			paddingLeft: 2,
+			paddingRight: 2,
+			paddingBottom: 1,
+			children: errorRows.slice(errorScroll, errorScroll + errorVisible).map((line, index) => /* @__PURE__ */ jsx(SelectableText, {
+				y: windowHeight + index,
+				col: frameLeft,
+				text: line.text,
+				color: line.color
+			}, errorScroll + index))
+		})]
+	});
+}
+//#endregion
+//#region src/ui/panels/surface.tsx
+/**
+* Build a key-hint row: keys in the panel key color, action words in the
+* muted description color ("enter select  esc close").
+*/
+function panelLegend(hints, options = {}) {
+	const keyStyle = { color: options.keyColor ?? COLORS.panelKeyText };
+	const descriptionStyle = { color: options.descriptionColor ?? COLORS.toolBodyText };
+	const parts = [];
+	if (options.prefix !== void 0 && options.prefix !== "") parts.push({
+		text: options.prefix,
+		style: descriptionStyle
+	});
+	for (const [index, hint] of hints.entries()) {
+		if (index > 0 || parts.length > 0) parts.push({
+			text: "  ",
+			style: descriptionStyle
+		});
+		parts.push({
+			text: hint.key,
+			style: keyStyle
+		});
+		parts.push({
+			text: " ",
+			style: descriptionStyle
+		});
+		parts.push({
+			text: hint.description,
+			style: descriptionStyle
+		});
+	}
+	return mergeRuns(parts);
+}
+/**
+* Shared panel chrome: a floating block anchored above the status line with
+* half-block caps, the panel background, and per-row text or interactive
+* content. Builtin panels and plugin panels built through dshtui/dialog
+* share this shell so every interaction panel looks the same.
+*
+* Selection pieces span the row text only, never the pill padding, so
+* dragging over blank panel area selects nothing (same rule as messages).
+*/
+function PanelSurface({ columns, rows, body, bodyStart, background, blockWidth }) {
+	return /* @__PURE__ */ jsx(Region, { children: /* @__PURE__ */ jsxs(Box, {
+		position: "absolute",
+		top: 0,
+		left: 0,
+		width: columns,
+		height: rows,
+		children: [
+			/* @__PURE__ */ jsx(Box, {
+				position: "absolute",
+				top: bodyStart - 1,
+				left: 2,
+				width: blockWidth,
+				children: /* @__PURE__ */ jsx(CapText, {
+					background,
+					top: true,
+					width: blockWidth
+				})
+			}),
+			body.map((row, index) => {
+				const isEmpty = row.segments.every((segment) => segment.text.trim() === "");
+				return /* @__PURE__ */ jsx(Box, {
+					position: "absolute",
+					top: bodyStart + index,
+					left: 2,
+					width: blockWidth,
+					paddingLeft: 2,
+					paddingRight: 2,
+					backgroundColor: background,
+					children: row.content !== void 0 ? row.content : isEmpty ? /* @__PURE__ */ jsx(Text, { children: " " }) : /* @__PURE__ */ jsx(SelectableText, {
+						y: bodyStart + index,
+						col: 4,
+						segments: row.segments
+					})
+				}, `panel-row-${index}`);
+			}),
+			/* @__PURE__ */ jsx(Box, {
+				position: "absolute",
+				top: bodyStart + body.length,
+				left: 2,
+				width: blockWidth,
+				children: /* @__PURE__ */ jsx(CapText, {
+					background,
+					top: false,
+					width: blockWidth
+				})
+			})
+		]
+	}) });
+}
+//#endregion
+export { errorText as $, SelectableText as A, setColorLevel as At, inputFrameTop as B, caretNonceText as C, registerPalette as Ct, markKeymapConsumed as D, themeMode as Dt, isKeyConsumed as E, subscribePalettes as Et, messageBackgroundWidth as F, warn as Ft, wrapSegments as G, glyphs as H, panelAnchorRow as I, clampFocusRow as J, chromeSelectionText as K, panelContains as L, Region as M, configureLogs as Mt, hintSpan as N, error as Nt, createMouseController as O, keyedRegistry as Ot, inputContentContains as P, installCrashHandlers as Pt, colToCharIndex as Q, scrollbarColumn as R, caretNonceColor as S, permissionModeInfo as St, beginKeyEvent as T, setThemeMode as Tt, mergeRuns as U, inputStatusRow as V, segmentsKey as W, toScreenSelection as X, selectedRange as Y, charWidth as Z, editDeleteWordRight as _, releaseFields as _t, DIALOG_MAX_HEIGHT as a, wrapLines as at, writeCursorShape as b, COLORS as bt, asTextItem as c, fieldExpandOf as ct, editCursorLeft as d, hasFieldChar as dt, lineBreaks as et, editCursorRight as f, hasFieldSlots as ft, editDeleteWordLeft as g, registerFieldKind as gt, editDelete as h, linesChipLabel as ht, Dialog as i, truncate as it, SelectionContext as j, env as jt, isMouseResidue as k, colorLevel as kt, registerWidget as l, fieldSlotOf as lt, editCursorWordRight as m, isFieldChar as mt, panelLegend as n, segmentGraphemes as nt, rowHeight as o, allocateField as ot, editCursorWordLeft as p, imageChipLabel as pt, sliceByColumns as q, CloseGuardContext as r, textWidth as rt, wrapStatusLines as s, charactersChipLabel as st, PanelSurface as t, locToPoint as tt, editBackspace as u, fieldStyleOf as ut, editInsert as v, releaseUnreferenced as vt, useCaret as w, replacePalettes as wt, caretNonceBold as x, paletteColor as xt, CapText as y, specialFieldFactory as yt, hintBlockTop as z };