@mnmal-ai/surface-core 0.0.0 → 0.14.6

package/dist/index.js

@@ -0,0 +1,1103 @@
+import { $ as wordRight, A as moveSelection, B as remember, C as unavailableReason, D as completeDraft, E as commandUsage, F as keySpecOf, G as EMPTY_DRAFT, H as walk, I as resolveKey, J as graphemeAt, K as atEnd, L as EMPTY_HISTORY, M as paletteQuery, N as paletteRows, O as enterRuns, P as parseCommandLine, Q as wordLeft, R as HISTORY_MAX, S as routeInput, T as clampSelection, U as CTRL_C_WINDOW_MS, V as settle, W as ctrlC, X as maskDraft, Y as insertChunk, Z as pasteToLine, _ as liveShrink, a as answerEntry, at as normaliseKeySpec, b as reflowSequence, c as emptyTranscript, d as sendTurn, et as applyInput, f as CLEAR_PANE, g as groundSequence, h as anchorPadding, i as addGap, it as composeModules, j as paletteMatches, k as menuWindow, l as heldAsks, m as RESET_GROUND, n as setPanel, nt as RESERVED_GLOBAL_KEYS, o as arriveTurn, ot as applySuggestion, p as DEFAULT_GROUND, q as editKey, r as defineModule, rt as assertComposes, s as commitEntry, st as mergeCompletions, t as panelOf, tt as CompositionError, u as markedFlights, v as prepareSequence, w as MENU_NAME_WIDTH, x as sanitise, y as prepareTerminal, z as mayWalk } from "./overlay-DQUbfIKu.js";
+import { spinnerFrame } from "@mnmal-ai/surface-kit";
+import { Box, Static, Text, measureElement, render, useApp, useInput, usePaste, useStdout } from "ink";
+import { Component, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/app.tsx
+/** Calls a module's view as a component, so a throw lands in the boundary and not in the shell. */
+function Run({ render }) {
+	const out = render();
+	return typeof out === "string" || typeof out === "number" ? /* @__PURE__ */ jsx(Text, { children: sanitise(String(out)) }) : out;
+}
+var Boundary = class extends Component {
+	state = { error: null };
+	static getDerivedStateFromError(err) {
+		return { error: err instanceof Error ? err.message : String(err) };
+	}
+	render() {
+		if (this.state.error === null) return this.props.children;
+		const reason = sanitise(this.state.error).split("\n")[0];
+		return /* @__PURE__ */ jsxs(Text, {
+			color: this.props.theme.color.error,
+			children: [
+				this.props.theme.glyph.fail,
+				" ",
+				sanitise(this.props.module),
+				" view failed: ",
+				reason
+			]
+		});
+	}
+};
+function Safe(props) {
+	return /* @__PURE__ */ jsx(Boundary, {
+		module: props.module,
+		theme: props.theme,
+		children: /* @__PURE__ */ jsx(Run, { render: props.render })
+	});
+}
+const ERROR_KIND = "core.error";
+const CANCELLED_KIND = "core.cancelled";
+const TOAST_MS = 3e3;
+/** A window drag resizes per step; the pane is re-laid once, when it settles. */
+const REFLOW_SETTLE_MS = 150;
+/** Columns the rail takes when it shows: its width and the margin before it. */
+const RAIL_COLUMNS = 33;
+/** Rows the shell keeps for itself: the input, the toast and the status row, and a little
+*  conversation above the panel. */
+const SHELL_ROWS = 6;
+/** What the band adds: its top and bottom padding, the presence row with a blank row above it,
+*  and the blank row between the band and the status row. */
+const BAND_ROWS = 5;
+/** Insets on raised menus (the / palette, completions): two columns each side and a row top and
+*  bottom (operator, 2026-10-09). The rows come out of the menu's row budget, so it never grows. */
+const OVERLAY_PAD_X = 2;
+const OVERLAY_PAD_Y = 1;
+/** A panel's insets. Wider than a menu's and with a row top and bottom, because a panel is read,
+*  not scanned; both come out of the size the panel view is handed (operator, 2026-10-09). */
+const PANEL_PAD_X = 4;
+const PANEL_PAD_Y = 1;
+/**
+* The `/` palette and the completion menu, directly above the input on the band's ground: a fixed name column, the detail dimmed, the selection on the `selection` tone, a window
+* that follows the selection, and a hint line.
+*/
+function MenuList({ theme, rows, selected, height, empty, hint }) {
+	const { start, end, position } = menuWindow(rows.length, selected, height);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		paddingX: OVERLAY_PAD_X,
+		paddingY: OVERLAY_PAD_Y,
+		backgroundColor: theme.color.raised,
+		children: [rows.length === 0 ? /* @__PURE__ */ jsx(Text, {
+			color: theme.color.dim,
+			wrap: "truncate",
+			children: sanitise(empty)
+		}) : rows.slice(start, end).map((r, i) => {
+			const on = start + i === selected;
+			return /* @__PURE__ */ jsxs(Box, {
+				...on ? { backgroundColor: theme.color.selection } : {},
+				children: [/* @__PURE__ */ jsx(Box, {
+					width: 22,
+					flexShrink: 0,
+					children: /* @__PURE__ */ jsx(Text, {
+						bold: on,
+						wrap: "truncate",
+						...on ? { color: theme.color.surface } : {},
+						children: sanitise(r.name)
+					})
+				}), /* @__PURE__ */ jsx(Text, {
+					color: on ? theme.color.surface : theme.color.dim,
+					wrap: "truncate",
+					children: sanitise(r.detail)
+				})]
+			}, r.key);
+		}), /* @__PURE__ */ jsx(Text, {
+			color: theme.color.dim,
+			wrap: "truncate",
+			children: `↑↓ select${position} · ${hint}`
+		})]
+	});
+}
+/** A panel's rows by default: the terminal less the shell's own, and never under three. */
+function defaultPanelRows(terminalRows, opts) {
+	return Math.max(3, terminalRows - SHELL_ROWS - (opts?.band === true ? BAND_ROWS : 0));
+}
+/** What `run()` prepares the terminal with, or `null` when the host has prepared it already. */
+function runTerminalOptions(opts) {
+	if (opts.terminal === false) return null;
+	return {
+		anchor: opts.anchored === true,
+		...opts.terminal
+	};
+}
+function createApp(opts) {
+	const registry = composeModules(opts.modules);
+	const theme = opts.theme;
+	const railMin = opts.railMinColumns ?? 80;
+	const askView = opts.entries?.ask;
+	const answerView = opts.entries?.answer;
+	const waitingView = opts.entries?.waiting;
+	const noteView = opts.entries?.note;
+	const exitHint = sanitise(opts.exitHint ?? "press ctrl+c again to exit");
+	const g = opts.gutter ?? 0;
+	const gutter = Number.isInteger(g) && g >= 0 && g <= 8 ? g : 0;
+	const band = opts.band === true;
+	const presence = registry.presence?.spec;
+	const presenceModule = registry.presence?.module ?? "";
+	const panelRows = opts.panelRows ?? ((r) => defaultPanelRows(r, { band }));
+	const anchored = opts.anchored === true;
+	function App({ columns, rows }) {
+		const { exit } = useApp();
+		const { stdout } = useStdout();
+		const [term, setTerm] = useState(() => ({
+			columns: stdout.columns ?? 120,
+			rows: stdout.rows ?? 30
+		}));
+		const [epoch, setEpoch] = useState(0);
+		const relayout = useCallback(() => {
+			if (stdout.isTTY) stdout.write(reflowSequence(stdout.rows));
+			setEpoch((e) => e + 1);
+		}, [stdout]);
+		useEffect(() => {
+			const laidOut = {
+				columns: stdout.columns ?? 120,
+				rows: stdout.rows ?? 30
+			};
+			let timer;
+			const onResize = () => {
+				setTerm({
+					columns: stdout.columns ?? 120,
+					rows: stdout.rows ?? 30
+				});
+				if (!anchored) return;
+				clearTimeout(timer);
+				timer = setTimeout(() => {
+					const now = {
+						columns: stdout.columns ?? 120,
+						rows: stdout.rows ?? 30
+					};
+					const grew = now.rows > laidOut.rows;
+					laidOut.rows = now.rows;
+					if (now.columns === laidOut.columns && !grew) return;
+					laidOut.columns = now.columns;
+					relayout();
+				}, REFLOW_SETTLE_MS);
+			};
+			stdout.on("resize", onResize);
+			return () => {
+				clearTimeout(timer);
+				stdout.off("resize", onResize);
+			};
+		}, [stdout, relayout]);
+		const width = Math.max(1, (columns ?? term.columns) - 2 * gutter);
+		const height = rows ?? term.rows;
+		const showRail = registry.rail.length > 0 && width >= railMin;
+		const panelOuter = {
+			columns: Math.max(1, width - (showRail ? RAIL_COLUMNS : 0)),
+			rows: Math.max(1, panelRows(height))
+		};
+		const panelSize = {
+			columns: Math.max(1, panelOuter.columns - 8),
+			rows: Math.max(1, panelOuter.rows - 2)
+		};
+		const sizeRef = useRef(panelSize);
+		sizeRef.current = panelSize;
+		const [transcript, setTranscript] = useState(() => emptyTranscript());
+		const transcriptRef = useRef(transcript);
+		const putTranscript = useCallback((fn) => {
+			transcriptRef.current = fn(transcriptRef.current);
+			setTranscript(transcriptRef.current);
+		}, []);
+		const [live, setLive] = useState(/* @__PURE__ */ new Map());
+		const [draft, setDraft] = useState(EMPTY_DRAFT);
+		const [, setHistory] = useState(EMPTY_HISTORY);
+		const [overlay, setOverlay] = useState(null);
+		const [menu, setMenu] = useState(null);
+		const [status, setStatus] = useState(/* @__PURE__ */ new Map());
+		const [toast, setToast] = useState(null);
+		const draftRef = useRef(EMPTY_DRAFT);
+		const requests = useRef(0);
+		const nextId = useRef(1);
+		const notes = useRef(0);
+		const armedAt = useRef(null);
+		const flights = useRef(/* @__PURE__ */ new Map());
+		const disposed = useRef(false);
+		const toastTimer = useRef(null);
+		const [notice, setNotice] = useState(null);
+		const noticeTimer = useRef(null);
+		const menuRef = useRef(null);
+		const overlayRef = useRef(null);
+		const historyRef = useRef(EMPTY_HISTORY);
+		const putMenu = useCallback((m) => {
+			menuRef.current = m;
+			setMenu(m);
+		}, []);
+		const [armed, setArmed] = useState(null);
+		const armedRef = useRef(null);
+		const putArmed = useCallback((a) => {
+			if (armedRef.current === a) return;
+			armedRef.current = a;
+			setArmed(a);
+		}, []);
+		const defOf = useCallback((o) => o ? registry.panels.get(`${o.module}/${o.panel}`)?.def : void 0, []);
+		const putHistory = useCallback((h) => {
+			historyRef.current = h;
+			setHistory(h);
+		}, []);
+		const putOverlay = useCallback((o) => {
+			const was = overlayRef.current;
+			if ((o === null || was === null || o.module !== was.module || o.panel !== was.panel) && (defOf(was)?.mask === true || defOf(o)?.mask === true)) {
+				draftRef.current = EMPTY_DRAFT;
+				requests.current += 1;
+				setDraft(EMPTY_DRAFT);
+				if (defOf(o)?.mask === true) {
+					if (menuRef.current !== null) putMenu(null);
+					putHistory(settle(historyRef.current));
+					putArmed(null);
+				}
+			}
+			overlayRef.current = o;
+			setOverlay(o);
+			const a = armedRef.current;
+			if (a !== null && (o === null || o.module !== a.module || o.panel !== a.panel || o.state !== a.state)) putArmed(null);
+		}, [
+			putArmed,
+			defOf,
+			putMenu,
+			putHistory
+		]);
+		const showToast = useCallback((text, tone, ms) => {
+			if (disposed.current) return;
+			if (toastTimer.current !== null) clearTimeout(toastTimer.current);
+			setToast({
+				text: sanitise(text),
+				tone
+			});
+			toastTimer.current = setTimeout(() => {
+				toastTimer.current = null;
+				setToast(null);
+			}, ms);
+		}, []);
+		const showNotice = useCallback((text, ms) => {
+			if (disposed.current) return;
+			if (noticeTimer.current !== null) clearTimeout(noticeTimer.current);
+			setNotice(sanitise(text));
+			noticeTimer.current = setTimeout(() => {
+				noticeTimer.current = null;
+				setNotice(null);
+			}, ms);
+		}, []);
+		const bus = useRef(/* @__PURE__ */ new Map());
+		const appAbort = useRef(new AbortController());
+		const handleLineRef = useRef(() => {});
+		const setDraftRef = useRef(() => {});
+		const print = useCallback((text, tone) => {
+			if (disposed.current) return;
+			notes.current += 1;
+			const entry = {
+				key: `note:${notes.current}`,
+				kind: "note",
+				text: sanitise(text),
+				...tone ? { tone } : {}
+			};
+			putTranscript((t) => commitEntry(t, entry));
+		}, [putTranscript]);
+		const say = useCallback((reply) => {
+			if (disposed.current) return;
+			notes.current += 1;
+			const entry = {
+				key: `said:${notes.current}`,
+				kind: "answer",
+				question: "",
+				reply,
+				mark: null,
+				unprompted: true,
+				at: Date.now()
+			};
+			putTranscript((t) => commitEntry(t, entry));
+		}, [putTranscript]);
+		const guard = useCallback((moduleId, fn) => {
+			const fail = (err) => print(`${moduleId}: ${err instanceof Error ? err.message : String(err)}`, "error");
+			try {
+				const r = fn();
+				if (r instanceof Promise) r.catch(fail);
+			} catch (err) {
+				fail(err);
+			}
+		}, [print]);
+		const ctxFor = useCallback((moduleId) => ({
+			theme,
+			signal: appAbort.current.signal,
+			size: () => sizeRef.current,
+			open: (panel, state, opts) => {
+				if (disposed.current) return;
+				if (!registry.panels.has(`${moduleId}/${panel}`)) throw new Error(`module '${moduleId}' has no panel '${panel}'`);
+				if (opts?.ifNoneOpen === true && overlayRef.current !== null) return;
+				putOverlay({
+					module: moduleId,
+					panel,
+					state
+				});
+			},
+			update: (panel, fn) => {
+				if (disposed.current) return;
+				const o = overlayRef.current;
+				if (o && o.module === moduleId && o.panel === panel) putOverlay({
+					...o,
+					state: fn(o.state)
+				});
+			},
+			close: () => {
+				if (!disposed.current && overlayRef.current?.module === moduleId) putOverlay(null);
+			},
+			print,
+			say,
+			transcript: () => transcriptRef.current,
+			submit: (text, opts) => {
+				if (!disposed.current) handleLineRef.current(text, opts ?? {});
+			},
+			setDraft: (text) => {
+				if (!disposed.current) setDraftRef.current(text);
+			},
+			status: (id, text, tone) => {
+				if (disposed.current) return;
+				setStatus((s) => {
+					const next = new Map(s);
+					if (text === null) next.delete(`${moduleId}:${id}`);
+					else next.set(`${moduleId}:${id}`, {
+						text: sanitise(text),
+						tone: tone ?? "dim"
+					});
+					return next;
+				});
+			},
+			toast: (text, tone) => showToast(text, tone ?? "info", TOAST_MS),
+			emit: (event, payload) => {
+				for (const fn of [...bus.current.get(event) ?? []]) fn(payload);
+			},
+			on: (event, fn) => {
+				const set = bus.current.get(event) ?? /* @__PURE__ */ new Set();
+				const safe = (p) => guard(moduleId, () => fn(p));
+				set.add(safe);
+				bus.current.set(event, set);
+				return () => set.delete(safe);
+			}
+		}), [
+			print,
+			say,
+			guard,
+			putOverlay,
+			showToast
+		]);
+		const runTurn = useCallback(async (line, module, handler, sent) => {
+			const id = nextId.current++;
+			const turn = {
+				id,
+				shown: sent?.shown ?? line,
+				...sent?.emphasis === void 0 ? {} : { emphasis: sent.emphasis },
+				...sent?.context === void 0 ? {} : { context: sent.context }
+			};
+			const ac = new AbortController();
+			let landed = false;
+			const land = (reply) => {
+				if (landed) return false;
+				landed = true;
+				flights.current.delete(id);
+				if (disposed.current) return true;
+				setLive((m) => {
+					const next = new Map(m);
+					next.delete(id);
+					return next;
+				});
+				putTranscript((t) => arriveTurn(t, id, reply));
+				return true;
+			};
+			flights.current.set(id, {
+				ac,
+				land
+			});
+			putTranscript((t) => sendTurn(t, id, turn.shown, turn.emphasis));
+			try {
+				for await (const u of handler.answer(line, ctxFor(module), ac.signal, turn)) {
+					if (landed) return;
+					if (u.phase === "final" || u.phase === "failed") {
+						land(u.reply);
+						return;
+					}
+					if (disposed.current) return;
+					setLive((m) => new Map(m).set(id, u.reply));
+				}
+				land({
+					kind: ERROR_KIND,
+					data: "no answer"
+				});
+			} catch (err) {
+				land({
+					kind: ERROR_KIND,
+					data: err instanceof Error ? err.message : String(err)
+				});
+			}
+		}, [ctxFor, putTranscript]);
+		const handleLine = useCallback((line, sent) => {
+			const text = line.trim();
+			const open = overlayRef.current;
+			const owner = open ? registry.panels.get(`${open.module}/${open.panel}`)?.def : void 0;
+			if (open && owner?.submit && (owner.mask === true && sent === void 0 || parseCommandLine(text) === null)) {
+				let next;
+				try {
+					next = owner.submit(open.state, line, ctxFor(open.module));
+				} catch (err) {
+					guard(open.module, () => {
+						throw err;
+					});
+					return;
+				}
+				const cur = overlayRef.current;
+				if (next !== void 0 && cur?.module === open.module && cur.panel === open.panel) putOverlay({
+					...cur,
+					state: next
+				});
+				return;
+			}
+			if (text === "") return;
+			if (sent === void 0) putHistory(remember(historyRef.current, text));
+			const route = routeInput(text, registry, opts.defaultTurn);
+			if (route.kind === "command") Promise.resolve().then(() => route.spec.run(route.args, ctxFor(route.module))).catch((err) => print(`/${route.spec.name} failed: ${err instanceof Error ? err.message : String(err)}`, "error"));
+			else if (route.kind === "unknown-command") print(`unknown command /${route.name}`, "warn");
+			else if (route.kind === "unavailable-command") print(`/${route.name}: ${route.reason}`, "warn");
+			else if (route.kind === "turn") runTurn(text, route.module, route.handler, sent);
+			else print("nothing here answers that", "warn");
+		}, [
+			ctxFor,
+			print,
+			putHistory,
+			runTurn,
+			guard,
+			putOverlay
+		]);
+		handleLineRef.current = handleLine;
+		const liveRef = useRef(null);
+		const lastLive = useRef(null);
+		useEffect(() => {
+			if (!anchored || liveRef.current === null) return;
+			const now = {
+				height: measureElement(liveRef.current).height,
+				committed: transcript.committed.filter((e) => e.kind !== "gap").length,
+				epoch
+			};
+			const shrink = liveShrink(lastLive.current, now);
+			lastLive.current = now;
+			if (shrink > 0) putTranscript((t) => addGap(t, shrink, epoch));
+		});
+		const panelOpen = overlay !== null || menu !== null;
+		const wasPanelOpen = useRef(panelOpen);
+		useEffect(() => {
+			if (anchored && wasPanelOpen.current && !panelOpen) relayout();
+			wasPanelOpen.current = panelOpen;
+		}, [panelOpen, relayout]);
+		const [pendingLine, setPendingLine] = useState(null);
+		useEffect(() => {
+			if (pendingLine === null) return;
+			setPendingLine(null);
+			handleLine(pendingLine);
+		}, [pendingLine, handleLine]);
+		const sendAfterClose = (line) => {
+			if (anchored) setPendingLine(line);
+			else handleLine(line);
+		};
+		const putDraft = useCallback((d) => {
+			draftRef.current = d;
+			requests.current += 1;
+			setDraft(d);
+		}, []);
+		const setDraftAndMenu = useCallback((d) => {
+			if (defOf(overlayRef.current)?.mask === true) {
+				putDraft(d);
+				if (menuRef.current !== null) putMenu(null);
+				return;
+			}
+			const before = paletteQuery(draftRef.current.text);
+			putDraft(d);
+			putHistory(settle(historyRef.current));
+			const q = paletteQuery(d.text);
+			const m = menuRef.current;
+			if (q !== null) {
+				const same = m?.kind === "palette" && before === q;
+				putMenu(same ? m : {
+					kind: "palette",
+					selected: 0,
+					moved: false
+				});
+			} else if (m !== null) putMenu(null);
+		}, [
+			putDraft,
+			putHistory,
+			putMenu,
+			defOf
+		]);
+		setDraftRef.current = (text) => {
+			putArmed(null);
+			setDraftAndMenu(atEnd(text));
+		};
+		useEffect(() => {
+			disposed.current = false;
+			appAbort.current = new AbortController();
+			const disposers = [];
+			for (const m of registry.modules) guard(m.id, () => {
+				const dispose = m.init?.(ctxFor(m.id));
+				if (dispose) disposers.push({
+					module: m.id,
+					fn: dispose
+				});
+			});
+			return () => {
+				disposed.current = true;
+				if (toastTimer.current !== null) clearTimeout(toastTimer.current);
+				if (noticeTimer.current !== null) clearTimeout(noticeTimer.current);
+				appAbort.current.abort();
+				for (const f of flights.current.values()) f.ac.abort();
+				for (const d of disposers) guard(d.module, d.fn);
+			};
+		}, [ctxFor, guard]);
+		const commands = useMemo(() => [...registry.commands.values()].map((c) => c.spec), []);
+		const rowsFor = (text) => paletteRows(commands.filter((c) => unavailableReason(c) === null), paletteQuery(text) ?? "");
+		const paletteFor = (text) => rowsFor(text).map((r) => r.cmd);
+		const paletteItems = menu?.kind === "palette" ? paletteFor(draft.text) : [];
+		const menuRows = Math.max(1, panelOuter.rows - 1 - 2);
+		useInput((input, inkKey) => {
+			const key = {
+				...inkKey,
+				input
+			};
+			const draft = draftRef.current;
+			const menu = menuRef.current;
+			const overlay = overlayRef.current;
+			const history = historyRef.current;
+			const armedOn = armedRef.current;
+			const state = {
+				overlay: overlay ? {
+					module: overlay.module,
+					panel: overlay.panel
+				} : null,
+				menu: menu?.kind ?? null,
+				draftEmpty: draft.text === "",
+				armed: armedOn !== null && overlay?.module === armedOn.module && overlay.panel === armedOn.panel && draft.text === armedOn.key ? armedOn.key : null
+			};
+			const route = resolveKey(state, key, registry);
+			switch (route.kind) {
+				case "exit-chord":
+					if (ctrlC(armedAt.current, Date.now()) === "exit") {
+						appAbort.current.abort();
+						exit();
+					} else {
+						armedAt.current = Date.now();
+						putArmed(null);
+						if (band) showNotice(exitHint, CTRL_C_WINDOW_MS);
+						else showToast(exitHint, "dim", CTRL_C_WINDOW_MS);
+					}
+					return;
+				case "menu": {
+					if (menu === null) return;
+					const count = (menu.kind === "palette" ? paletteFor(draft.text) : menu.items).length;
+					if (count === 0 && route.act !== "move") {
+						putMenu(null);
+						if (route.act === "run") {
+							putDraft(EMPTY_DRAFT);
+							sendAfterClose(draft.text);
+						}
+						return;
+					}
+					if (route.act === "move") putMenu({
+						...menu,
+						selected: moveSelection(menu.selected, route.delta, count),
+						...menu.kind === "palette" ? { moved: true } : {}
+					});
+					else if (route.act === "close") putMenu(null);
+					else if (menu.kind === "palette") {
+						const rows = rowsFor(draft.text);
+						const c = route.act === "run" ? enterRuns(rows, menu.selected, menu.moved) : rows[clampSelection(menu.selected, count)]?.cmd;
+						if (c === void 0) return;
+						if (c === null) {
+							putMenu(null);
+							putDraft(EMPTY_DRAFT);
+							sendAfterClose(draft.text);
+						} else if (route.act === "run" && c.args.every((a) => a.optional === true)) {
+							putMenu(null);
+							putDraft(EMPTY_DRAFT);
+							sendAfterClose(`/${c.name}`);
+						} else {
+							putMenu(null);
+							putDraft(atEnd(completeDraft(c)));
+						}
+					} else {
+						const s = menu.items[clampSelection(menu.selected, count)];
+						if (s === void 0) return;
+						const next = applySuggestion(draft.text, draft.cursor, s);
+						putMenu(null);
+						putDraft({
+							text: next.text,
+							cursor: next.cursor
+						});
+					}
+					return;
+				}
+				case "panel": {
+					const handler = (registry.panels.get(`${route.module}/${route.panel}`)?.def)?.on?.[route.act];
+					if (!handler || !overlay) return;
+					let next;
+					try {
+						next = handler(overlay.state, ctxFor(route.module));
+					} catch (err) {
+						guard(route.module, () => {
+							throw err;
+						});
+						return;
+					}
+					const cur = overlayRef.current;
+					if (next !== void 0 && cur?.module === overlay.module && cur.panel === overlay.panel) putOverlay({
+						...cur,
+						state: next
+					});
+					return;
+				}
+				case "panel-close": {
+					putArmed(null);
+					const def = overlay ? registry.panels.get(`${overlay.module}/${overlay.panel}`)?.def : void 0;
+					if (overlay && def?.escape) {
+						let next;
+						try {
+							next = def.escape(overlay.state, ctxFor(overlay.module));
+						} catch (err) {
+							guard(overlay.module, () => {
+								throw err;
+							});
+							return;
+						}
+						const cur = overlayRef.current;
+						const same = cur?.module === overlay.module && cur.panel === overlay.panel;
+						if (next !== void 0 && same) {
+							putOverlay({
+								...cur,
+								state: next
+							});
+							return;
+						}
+						if (!same) return;
+					}
+					putOverlay(null);
+					return;
+				}
+				case "confirm": {
+					const handler = (registry.panels.get(`${route.module}/${route.panel}`)?.def)?.on?.[route.act];
+					if (!handler || !overlay) return;
+					let next;
+					try {
+						next = handler(overlay.state, ctxFor(route.module));
+					} catch (err) {
+						guard(route.module, () => {
+							throw err;
+						});
+						return;
+					}
+					putArmed(null);
+					putDraft(EMPTY_DRAFT);
+					const cur = overlayRef.current;
+					if (next !== void 0 && cur?.module === overlay.module && cur.panel === overlay.panel) putOverlay({
+						...cur,
+						state: next
+					});
+					return;
+				}
+				case "global":
+					guard(route.module, () => registry.globals.get(route.key)?.binding.run(ctxFor(route.module)));
+					return;
+				case "cancel-turn": {
+					const newest = [...flights.current.keys()].pop();
+					const f = newest === void 0 ? void 0 : flights.current.get(newest);
+					if (f) {
+						f.ac.abort();
+						f.land({
+							kind: CANCELLED_KIND,
+							data: "cancelled"
+						});
+					}
+					return;
+				}
+				case "history": {
+					if (defOf(overlay)?.mask === true) return;
+					putArmed(null);
+					const step = walk(history, route.dir, draft.text);
+					if (step === null) return;
+					putHistory(step.state);
+					putDraft(atEnd(step.text));
+					return;
+				}
+				case "submit": {
+					putArmed(null);
+					const line = draft.text;
+					putDraft(EMPTY_DRAFT);
+					putMenu(null);
+					handleLine(line);
+					return;
+				}
+				case "complete": {
+					if (defOf(overlay)?.mask === true) return;
+					const completers = registry.completers.map((c) => c.completer);
+					requests.current += 1;
+					const ticket = requests.current;
+					mergeCompletions(completers, draft.text, draft.cursor).then((items) => {
+						if (requests.current !== ticket) return;
+						if (items.length === 1 && items[0]) {
+							const next = applySuggestion(draft.text, draft.cursor, items[0]);
+							putDraft({
+								text: next.text,
+								cursor: next.cursor
+							});
+						} else if (items.length > 1) putMenu({
+							kind: "completion",
+							items,
+							selected: 0
+						});
+					});
+					return;
+				}
+				case "edit": {
+					const focused = overlay ? registry.panels.get(`${overlay.module}/${overlay.panel}`)?.def : void 0;
+					const hit = overlay && draft.text === "" && !key.ctrl && !key.meta ? focused?.confirm?.find((c) => c.key === input) : void 0;
+					putArmed(overlay && hit ? {
+						module: overlay.module,
+						panel: overlay.panel,
+						key: hit.key,
+						act: hit.act,
+						label: hit.label,
+						state: overlay.state
+					} : null);
+					if ([...input].length <= 1) {
+						const edited = editKey(draft, input, key);
+						if (edited !== null) {
+							setDraftAndMenu(edited);
+							return;
+						}
+					}
+					if (input === "") return;
+					const r = insertChunk(draft, input);
+					setDraftAndMenu(r.draft);
+					const masked = defOf(overlay)?.mask === true ? overlay : null;
+					for (const line of r.submit) {
+						const cur = overlayRef.current;
+						if (masked !== null && (cur === null || cur.module !== masked.module || cur.panel !== masked.panel)) break;
+						handleLine(line);
+					}
+					return;
+				}
+				case "ignore": return;
+			}
+		});
+		usePaste((text) => {
+			putArmed(null);
+			const open = overlayRef.current;
+			const def = open === null ? void 0 : registry.panels.get(`${open.module}/${open.panel}`)?.def;
+			if (open !== null && !((def?.confirm?.length ?? 0) > 0 || def?.submit !== void 0)) return;
+			const line = pasteToLine(text);
+			if (line === "") return;
+			setDraftAndMenu(insertChunk(draftRef.current, line).draft);
+		});
+		const renderReply = (reply) => {
+			if (reply.kind === ERROR_KIND) return /* @__PURE__ */ jsxs(Text, {
+				color: theme.color.error,
+				children: [
+					theme.glyph.fail,
+					" ",
+					sanitise(String(reply.data))
+				]
+			});
+			if (reply.kind === CANCELLED_KIND) return /* @__PURE__ */ jsx(Text, {
+				color: theme.color.dim,
+				children: "cancelled"
+			});
+			const r = registry.renderers.get(reply.kind);
+			return r ? /* @__PURE__ */ jsx(Safe, {
+				module: r.module,
+				theme,
+				render: () => r.render({
+					data: reply.data,
+					theme,
+					size: { columns: width }
+				})
+			}) : /* @__PURE__ */ jsx(Text, { children: sanitise(String(reply.data)) });
+		};
+		const chips = (reply) => {
+			if (!reply.chips || reply.chips.length === 0) return null;
+			const seen = /* @__PURE__ */ new Map();
+			const kids = [];
+			for (const c of reply.chips) {
+				const tone = c.tone ?? "dim";
+				const n = (seen.get(`${tone}:${c.label}`) ?? 0) + 1;
+				seen.set(`${tone}:${c.label}`, n);
+				if (kids.length > 0) kids.push(" · ");
+				kids.push(/* @__PURE__ */ jsx(Text, {
+					color: theme.color[tone],
+					children: sanitise(c.label)
+				}, `${tone}:${c.label}#${n}`));
+			}
+			return /* @__PURE__ */ jsx(Text, { children: kids });
+		};
+		const panel = overlay ? registry.panels.get(`${overlay.module}/${overlay.panel}`)?.def : void 0;
+		const shownDraft = panel?.mask === true ? maskDraft(draft) : draft;
+		const under = graphemeAt(shownDraft.text, shownDraft.cursor);
+		const waiting = (f, held) => {
+			const reply = live.get(f.id);
+			const body = reply ? renderReply(reply) : /* @__PURE__ */ jsxs(Text, {
+				color: theme.color.dim,
+				children: [spinnerFrame(Math.floor(Date.now() / 120)), " Thinking"]
+			});
+			if (waitingView) return /* @__PURE__ */ jsx(Safe, {
+				module: "app",
+				theme,
+				render: () => waitingView({
+					flight: f,
+					held,
+					...reply === void 0 ? {} : { reply },
+					body,
+					theme,
+					size: { columns: width }
+				})
+			});
+			if (held) return body;
+			return /* @__PURE__ */ jsxs(Box, { children: [/* @__PURE__ */ jsxs(Text, {
+				color: theme.color.accent,
+				children: [
+					"⟨",
+					f.mark,
+					"⟩ "
+				]
+			}), body] });
+		};
+		const committed = (e) => {
+			if (e.kind === "ask") {
+				if (askView) return /* @__PURE__ */ jsx(Safe, {
+					module: "app",
+					theme,
+					render: () => askView({
+						entry: e,
+						held: false,
+						theme,
+						size: { columns: width }
+					})
+				}, e.key);
+				return /* @__PURE__ */ jsxs(Text, {
+					color: theme.color.accent,
+					children: [
+						e.mark !== null ? `⟨${e.mark}⟩ ` : "",
+						theme.glyph.prompt,
+						" ",
+						sanitise(e.question)
+					]
+				}, e.key);
+			}
+			if (e.kind === "answer") {
+				const body = /* @__PURE__ */ jsxs(Fragment, { children: [renderReply(e.reply), chips(e.reply)] });
+				if (answerView) return /* @__PURE__ */ jsx(Safe, {
+					module: "app",
+					theme,
+					render: () => answerView({
+						entry: e,
+						body,
+						theme,
+						size: { columns: width }
+					})
+				}, e.key);
+				return /* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					children: [e.mark !== null ? /* @__PURE__ */ jsxs(Text, {
+						color: theme.color.accent,
+						children: [
+							"↩ ⟨",
+							e.mark,
+							"⟩"
+						]
+					}) : null, body]
+				}, e.key);
+			}
+			if (e.kind === "note") {
+				if (noteView) return /* @__PURE__ */ jsx(Safe, {
+					module: "app",
+					theme,
+					render: () => noteView({
+						entry: e,
+						theme,
+						size: { columns: width }
+					})
+				}, e.key);
+				return /* @__PURE__ */ jsx(Text, {
+					color: theme.color[e.tone ?? "dim"],
+					children: sanitise(e.text)
+				}, e.key);
+			}
+			return /* @__PURE__ */ jsx(Text, { children: "\n".repeat(Math.max(0, e.lines - 1)) }, e.key);
+		};
+		return /* @__PURE__ */ jsxs(Box, {
+			flexDirection: "column",
+			children: [/* @__PURE__ */ jsx(Static, {
+				items: transcript.committed.filter((e) => e.kind !== "gap" || e.epoch === epoch),
+				children: (e) => /* @__PURE__ */ jsx(Box, {
+					paddingX: gutter,
+					flexDirection: "column",
+					children: committed(e)
+				}, e.key)
+			}, `static:${epoch}`), /* @__PURE__ */ jsxs(Box, {
+				ref: liveRef,
+				flexDirection: "row",
+				paddingX: gutter,
+				children: [/* @__PURE__ */ jsxs(Box, {
+					flexDirection: "column",
+					flexGrow: 1,
+					children: [
+						markedFlights(transcript).map((f) => /* @__PURE__ */ jsx(Box, { children: waiting(f, false) }, `marked:${f.id}`)),
+						heldAsks(transcript).map((f) => /* @__PURE__ */ jsxs(Box, {
+							flexDirection: "column",
+							children: [askView ? /* @__PURE__ */ jsx(Safe, {
+								module: "app",
+								theme,
+								render: () => askView({
+									entry: f,
+									held: true,
+									theme,
+									size: { columns: width }
+								})
+							}) : /* @__PURE__ */ jsxs(Text, {
+								color: theme.color.accent,
+								children: [
+									theme.glyph.prompt,
+									" ",
+									sanitise(f.question)
+								]
+							}), waiting(f, true)]
+						}, f.id)),
+						panel && overlay ? /* @__PURE__ */ jsx(Box, {
+							backgroundColor: theme.color.raised,
+							paddingX: PANEL_PAD_X,
+							paddingY: PANEL_PAD_Y,
+							flexDirection: "column",
+							children: /* @__PURE__ */ jsx(Safe, {
+								module: overlay.module,
+								theme,
+								render: () => panel.view({
+									state: overlay.state,
+									theme,
+									size: panelSize,
+									...armed !== null && armed.module === overlay.module && armed.panel === overlay.panel && draft.text === armed.key ? { armed: {
+										key: armed.key,
+										label: armed.label
+									} } : {}
+								})
+							}, `${overlay.module}/${overlay.panel}`)
+						}) : null,
+						menu?.kind === "palette" ? /* @__PURE__ */ jsx(MenuList, {
+							theme,
+							rows: paletteItems.map((c) => ({
+								key: c.name,
+								name: commandUsage(c),
+								detail: c.summary
+							})),
+							selected: menu.selected,
+							height: menuRows,
+							empty: `no command matches ${draft.text}`,
+							hint: "tab complete · enter run · esc close"
+						}) : null,
+						menu?.kind === "completion" ? /* @__PURE__ */ jsx(MenuList, {
+							theme,
+							rows: menu.items.map((s) => ({
+								key: s.insert,
+								name: s.label,
+								detail: s.detail ?? ""
+							})),
+							selected: menu.selected,
+							height: menuRows,
+							empty: "no completions",
+							hint: "tab complete · esc close"
+						}) : null,
+						band ? /* @__PURE__ */ jsxs(Box, {
+							borderStyle: "bold",
+							borderTop: false,
+							borderRight: false,
+							borderBottom: false,
+							borderColor: theme.color.edge,
+							backgroundColor: theme.color.surfaceAlt,
+							paddingX: 1,
+							paddingY: 1,
+							flexDirection: "column",
+							children: [/* @__PURE__ */ jsxs(Text, { children: [
+								shownDraft.text.slice(0, shownDraft.cursor),
+								under === "" ? /* @__PURE__ */ jsx(Text, {
+									color: theme.color.cursor,
+									children: "█"
+								}) : /* @__PURE__ */ jsx(Text, {
+									inverse: true,
+									children: under
+								}),
+								under === "" ? "" : shownDraft.text.slice(shownDraft.cursor + under.length)
+							] }), /* @__PURE__ */ jsxs(Box, {
+								marginTop: 1,
+								children: [
+									presence ? /* @__PURE__ */ jsx(Box, {
+										flexShrink: 0,
+										children: /* @__PURE__ */ jsxs(Text, {
+											bold: true,
+											children: [sanitise(presence.name), " "]
+										})
+									}) : null,
+									/* @__PURE__ */ jsx(Box, {
+										flexGrow: 1,
+										minWidth: 0,
+										children: /* @__PURE__ */ jsx(Text, {
+											color: theme.color.dim,
+											wrap: "truncate",
+											children: presence?.view ? /* @__PURE__ */ jsx(Safe, {
+												module: presenceModule,
+												theme,
+												render: () => presence.view?.({ theme })
+											}) : null
+										})
+									}),
+									/* @__PURE__ */ jsx(Box, {
+										flexShrink: 0,
+										paddingLeft: notice === null ? 0 : 2,
+										children: /* @__PURE__ */ jsx(Text, {
+											color: theme.color.warn,
+											children: notice ?? " "
+										})
+									})
+								]
+							})]
+						}) : /* @__PURE__ */ jsxs(Text, { children: [/* @__PURE__ */ jsxs(Text, {
+							color: theme.color.accent,
+							children: [theme.glyph.prompt, " "]
+						}), shownDraft.text] }),
+						toast ? /* @__PURE__ */ jsx(Text, {
+							color: theme.color[toast.tone],
+							children: toast.text
+						}) : null,
+						/* @__PURE__ */ jsxs(Box, {
+							...band ? { marginTop: 1 } : {},
+							children: [registry.status.map((s) => /* @__PURE__ */ jsx(Box, {
+								marginRight: 2,
+								children: /* @__PURE__ */ jsx(Safe, {
+									module: s.module,
+									theme,
+									render: () => s.item.view({ theme })
+								})
+							}, `${s.module}:${s.item.id}`)), [...status.entries()].map(([k, v]) => /* @__PURE__ */ jsxs(Text, {
+								color: theme.color[v.tone],
+								children: [v.text, " "]
+							}, k))]
+						})
+					]
+				}), showRail ? /* @__PURE__ */ jsx(Box, {
+					flexDirection: "column",
+					width: 32,
+					marginLeft: 1,
+					children: registry.rail.map((r) => /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Safe, {
+						module: r.module,
+						theme,
+						render: () => r.item.view({ theme })
+					}) }, `${r.module}:${r.item.id}`))
+				}) : null]
+			})]
+		});
+	}
+	return {
+		registry,
+		App,
+		async run() {
+			const prepare = runTerminalOptions(opts);
+			const restore = prepare === null ? () => {} : prepareTerminal(process.stdout, prepare);
+			await render(/* @__PURE__ */ jsx(App, {}), { exitOnCtrlC: false }).waitUntilExit();
+			restore();
+		}
+	};
+}
+
+//#endregion
+export { CLEAR_PANE, CTRL_C_WINDOW_MS, CompositionError, DEFAULT_GROUND, EMPTY_DRAFT, EMPTY_HISTORY, HISTORY_MAX, MENU_NAME_WIDTH, RESERVED_GLOBAL_KEYS, RESET_GROUND, addGap, anchorPadding, answerEntry, applyInput, applySuggestion, arriveTurn, assertComposes, atEnd, clampSelection, commandUsage, commitEntry, completeDraft, composeModules, createApp, ctrlC, defaultPanelRows, defineModule, editKey, emptyTranscript, enterRuns, groundSequence, heldAsks, insertChunk, keySpecOf, liveShrink, markedFlights, maskDraft, mayWalk, menuWindow, mergeCompletions, moveSelection, normaliseKeySpec, paletteMatches, paletteQuery, paletteRows, panelOf, parseCommandLine, pasteToLine, prepareSequence, prepareTerminal, reflowSequence, remember, resolveKey, routeInput, sanitise, sendTurn, setPanel, settle, walk, wordLeft, wordRight };