@mnmal-ai/surface-core 0.0.0 → 0.14.6

package/dist/overlay-DQUbfIKu.js

@@ -0,0 +1,1011 @@
+import { DEFAULT_GROUND } from "@mnmal-ai/surface-theme";
+
+//#region src/complete.ts
+const TIMEOUT_MS = 150;
+const LIMIT = 8;
+async function within(work, ms) {
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => resolve(null), ms);
+	});
+	try {
+		return await Promise.race([work, timeout]);
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** Every completer at once; a slow or failing one is dropped, never waited on. */
+async function mergeCompletions(completers, draft, cursor, opts = {}) {
+	const ms = opts.timeoutMs ?? TIMEOUT_MS;
+	const results = await Promise.all(completers.map((c) => within(Promise.resolve().then(() => c.complete(draft, cursor)), ms)));
+	const byInsert = /* @__PURE__ */ new Map();
+	for (const list of results) for (const s of list ?? []) {
+		const key = s.replace ? `${s.insert}\0${s.replace[0]},${s.replace[1]}` : s.insert;
+		const prior = byInsert.get(key);
+		if (prior === void 0 || (s.score ?? 0) > (prior.score ?? 0)) byInsert.set(key, s);
+	}
+	const merged = [...byInsert.values()];
+	merged.sort((a, b) => (b.score ?? 0) - (a.score ?? 0) || a.label.localeCompare(b.label));
+	return merged.slice(0, opts.limit ?? LIMIT);
+}
+function validSpan(span, length) {
+	if (span === void 0) return false;
+	const [start, end] = span;
+	return Number.isInteger(start) && Number.isInteger(end) && 0 <= start && start <= end && end <= length;
+}
+/**
+* Replace the suggestion's `replace` span with its insert, or, without a valid one, the
+* whitespace-delimited token ending at `cursor`. The cursor lands after the insert.
+*/
+function applySuggestion(draft, cursor, s) {
+	if (validSpan(s.replace, draft.length)) {
+		const [start, end] = s.replace;
+		return {
+			text: draft.slice(0, start) + s.insert + draft.slice(end),
+			cursor: start + s.insert.length
+		};
+	}
+	const start = draft.slice(0, cursor).search(/\S+$/);
+	const from = start < 0 ? cursor : start;
+	return {
+		text: draft.slice(0, from) + s.insert + draft.slice(cursor),
+		cursor: from + s.insert.length
+	};
+}
+
+//#endregion
+//#region src/key-spec.ts
+const NAMED = /* @__PURE__ */ new Set([
+	"escape",
+	"enter",
+	"tab",
+	"up",
+	"down",
+	"left",
+	"right",
+	"pageup",
+	"pagedown",
+	"home",
+	"end",
+	"backspace",
+	"delete"
+]);
+const ALIASES = {
+	esc: "escape",
+	return: "enter",
+	pgup: "pageup",
+	pgdn: "pagedown",
+	space: " "
+};
+const single = (s) => [...s].length === 1;
+/** Maps a binding string to the canonical form a key event is resolved to. Throws if no event can produce it. */
+function normaliseKeySpec(spec) {
+	if (spec === " ") return " ";
+	const s = spec.trim();
+	const lower = s.toLowerCase();
+	const named = ALIASES[lower] ?? lower;
+	if (NAMED.has(named) || named === " ") return named;
+	const mod = /^(ctrl|meta)\+(.+)$/i.exec(s);
+	if (mod?.[1] && mod[2] !== void 0 && single(mod[2])) return `${mod[1].toLowerCase()}+${mod[2].toLowerCase()}`;
+	if (single(s)) return s;
+	throw new Error(`key spec '${spec}' can never be produced by a key event`);
+}
+
+//#endregion
+//#region src/compose.ts
+/** Keys a module may not bind globally: the exit chord, submit, cancel, complete. */
+const RESERVED_GLOBAL_KEYS = [
+	"ctrl+c",
+	"enter",
+	"escape",
+	"tab"
+];
+/** Keys a panel may not bind: only these are taken before a focused panel's keymap (keys.ts). */
+const RESERVED_PANEL_KEYS = ["ctrl+c", "escape"];
+/** One printable character: what a confirm key must be, since it is typed into the draft. */
+const PRINTABLE = /^[^\p{C}\s]$/u;
+var CompositionError = class extends Error {
+	problems;
+	constructor(problems) {
+		super(`modules do not compose:\n  ${problems.join("\n  ")}`);
+		this.problems = problems;
+		this.name = "CompositionError";
+	}
+};
+function composeModules(modules) {
+	const problems = [];
+	const ids = /* @__PURE__ */ new Set();
+	const turnIds = /* @__PURE__ */ new Map();
+	const commands = /* @__PURE__ */ new Map();
+	const panels = /* @__PURE__ */ new Map();
+	const globals = /* @__PURE__ */ new Map();
+	const renderers = /* @__PURE__ */ new Map();
+	const completers = [];
+	const turns = [];
+	const rail = [];
+	const status = [];
+	let presence;
+	for (const m of modules) {
+		if (ids.has(m.id)) {
+			problems.push(`module id '${m.id}' is used twice`);
+			continue;
+		}
+		ids.add(m.id);
+		for (const c of m.commands ?? []) {
+			const prior = commands.get(c.name);
+			if (prior) problems.push(`command '/${c.name}' is registered by ${prior.module} and ${m.id}`);
+			else commands.set(c.name, {
+				module: m.id,
+				spec: c
+			});
+		}
+		const canon = (spec) => {
+			try {
+				return normaliseKeySpec(spec);
+			} catch (e) {
+				problems.push(`${m.id}: ${e.message}`);
+				return;
+			}
+		};
+		for (const [panel, rawDef] of Object.entries(m.panels ?? {})) {
+			const key = `${m.id}/${panel}`;
+			const def = rawDef;
+			const seen = /* @__PURE__ */ new Set();
+			const keymap = def.keymap?.flatMap((k) => {
+				const c = canon(k.key);
+				if (c === void 0) return [];
+				if (RESERVED_PANEL_KEYS.includes(c)) {
+					problems.push(`${key} binds '${k.key}', but '${c}' is reserved by the core`);
+					return [];
+				}
+				if (seen.has(c)) {
+					problems.push(`${key} binds '${c}' twice`);
+					return [];
+				}
+				seen.add(c);
+				return [{
+					...k,
+					key: c
+				}];
+			});
+			const bound = new Set((keymap ?? []).map((k) => k.key));
+			const confirmed = /* @__PURE__ */ new Set();
+			for (const c of def.confirm ?? []) {
+				if (!PRINTABLE.test(c.key)) problems.push(`${key} confirms '${c.key}', which is not one printable character`);
+				else if (bound.has(c.key)) problems.push(`${key} binds '${c.key}' in both its keymap and confirm`);
+				else if (confirmed.has(c.key)) problems.push(`${key} confirms '${c.key}' twice`);
+				confirmed.add(c.key);
+				if (def.on?.[c.act] === void 0) problems.push(`${key} confirms '${c.key}' with act '${c.act}', which it has no handler for`);
+			}
+			if (def.escape !== void 0 && def.submit === void 0) problems.push(`${key} handles escape without submit, which only an input panel may`);
+			if (def.mask === true && def.submit === void 0) problems.push(`${key} masks its input without submit, which only an input panel may`);
+			if (def.mask === true && (def.confirm?.length ?? 0) > 0) problems.push(`${key} masks its input but declares confirm keys, which would arm on a secret's characters`);
+			if (def.mask === true) {
+				for (const k of keymap ?? []) if ([...k.key].length === 1) problems.push(`${key} masks its input but binds '${k.key}', which would make that character untypeable in the secret`);
+			}
+			if (panels.has(key)) problems.push(`panel '${key}' is registered twice`);
+			else panels.set(key, {
+				module: m.id,
+				panel,
+				def: keymap ? {
+					...def,
+					keymap
+				} : def
+			});
+		}
+		for (const b of m.keymap ?? []) {
+			const key = canon(b.key);
+			if (key === void 0) continue;
+			if (RESERVED_GLOBAL_KEYS.includes(key)) {
+				problems.push(`${m.id} binds '${b.key}', but '${key}' is reserved by the core`);
+				continue;
+			}
+			if ([...key].length === 1) {
+				problems.push(`${m.id} binds '${b.key}' globally, which would make that character untypeable`);
+				continue;
+			}
+			const prior = globals.get(key);
+			if (prior) problems.push(`global key '${key}' is bound by ${prior.module} and ${m.id}`);
+			else globals.set(key, {
+				module: m.id,
+				binding: {
+					...b,
+					key
+				}
+			});
+		}
+		for (const [kind, render] of Object.entries(m.renderers ?? {})) {
+			const prior = renderers.get(kind);
+			if (prior) problems.push(`renderer '${kind}' is registered by ${prior.module} and ${m.id}`);
+			else renderers.set(kind, {
+				module: m.id,
+				render
+			});
+		}
+		if (m.presence !== void 0) {
+			if (presence) problems.push(`presence is declared by ${presence.module} and ${m.id}; only one may`);
+			else presence = {
+				module: m.id,
+				spec: m.presence
+			};
+		}
+		for (const c of m.completers ?? []) completers.push({
+			module: m.id,
+			completer: c
+		});
+		for (const h of m.turns ?? []) {
+			const prior = turnIds.get(h.id);
+			if (prior) problems.push(`turn handler '${h.id}' is registered by ${prior} and ${m.id}`);
+			else turnIds.set(h.id, m.id);
+			turns.push({
+				module: m.id,
+				handler: h
+			});
+		}
+		for (const item of m.rail ?? []) rail.push({
+			module: m.id,
+			item
+		});
+		for (const item of m.status ?? []) status.push({
+			module: m.id,
+			item
+		});
+	}
+	if (problems.length > 0) throw new CompositionError(problems);
+	return {
+		modules,
+		commands,
+		panels,
+		globals,
+		completers,
+		turns,
+		renderers,
+		rail,
+		status,
+		...presence ? { presence } : {}
+	};
+}
+/** One line in an app's tests: a composition conflict becomes a CI failure. */
+function assertComposes(modules) {
+	composeModules(modules);
+}
+
+//#endregion
+//#region src/apply-input.ts
+/** A typed or pasted chunk applied to the draft: complete lines are submitted, the rest kept. */
+function applyInput(draft, chunk) {
+	if (!/[\r\n]/.test(chunk)) return {
+		draft: draft + chunk,
+		submit: []
+	};
+	const parts = (draft + chunk).split(/\r\n|\r|\n/);
+	return {
+		draft: parts.pop() ?? "",
+		submit: parts.map((p) => p.trim()).filter((p) => p !== "")
+	};
+}
+
+//#endregion
+//#region src/editor.ts
+const EMPTY_DRAFT = {
+	text: "",
+	cursor: 0
+};
+/** A whole new line with the cursor at its end — a completion, or a cleared input. */
+function atEnd(text) {
+	return {
+		text,
+		cursor: text.length
+	};
+}
+const isWord = (ch) => ch !== void 0 && /[\p{L}\p{N}_'-]/u.test(ch);
+const SEGMENTER = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+/** The text as grapheme clusters with their code-unit bounds. The cursor is always one of these,
+* so a step or a delete never leaves half an emoji or a bare combining mark behind. */
+const clusters = (text) => {
+	const out = [];
+	for (const s of SEGMENTER.segment(text)) out.push({
+		input: s.segment,
+		index: s.index,
+		end: s.index + s.segment.length
+	});
+	return out;
+};
+/** Start of the word before the cursor, skipping the spaces in between. */
+function wordLeft(text, from) {
+	const cs = clusters(text);
+	let j = 0;
+	while (j < cs.length && (cs[j]?.end ?? text.length) <= from) j++;
+	while (j > 0 && !isWord(cs[j - 1]?.input)) j--;
+	while (j > 0 && isWord(cs[j - 1]?.input)) j--;
+	return j < cs.length ? cs[j]?.index ?? 0 : text.length;
+}
+/** End of the word after the cursor, skipping the spaces in between. */
+function wordRight(text, from) {
+	const cs = clusters(text);
+	let j = 0;
+	while (j < cs.length && (cs[j]?.end ?? text.length) <= from) j++;
+	while (j < cs.length && !isWord(cs[j]?.input)) j++;
+	while (j < cs.length && isWord(cs[j]?.input)) j++;
+	return j < cs.length ? cs[j]?.index ?? text.length : text.length;
+}
+/**
+* A key that moves or deletes, applied — or null when the key is not an editing key, so the
+* caller carries on to typing and submitting.
+*
+* Backspace and Delete both delete before the cursor. Terminals disagree about which byte the
+* Backspace key sends, and Ink reports the common one (0x7f) as `delete`; treating it as a
+* forward delete would make the key nearly everyone presses delete the wrong character. Deleting
+* under the cursor is Ctrl-D, which no terminal sends by accident.
+*/
+function editKey(d, input, key) {
+	const { text, cursor } = d;
+	const to = (c) => ({
+		text,
+		cursor: Math.max(0, Math.min(text.length, c))
+	});
+	const cut = (from, until) => ({
+		text: text.slice(0, from) + text.slice(until),
+		cursor: from
+	});
+	const byWord = key.ctrl === true || key.meta === true;
+	const cs = clusters(text);
+	/** The boundary before this one: the start of the cluster the cursor sits behind. */
+	const before = (c) => {
+		let i = 0;
+		while (i < cs.length && (cs[i]?.end ?? text.length) <= c) i++;
+		return i > 0 ? cs[i - 1]?.index ?? 0 : 0;
+	};
+	/** The boundary after this one: the end of the cluster under the cursor. */
+	const after = (c) => {
+		let i = 0;
+		while (i < cs.length && (cs[i]?.end ?? text.length) <= c) i++;
+		return i < cs.length ? cs[i]?.end ?? text.length : text.length;
+	};
+	if (key.leftArrow) return to(byWord ? wordLeft(text, cursor) : before(cursor));
+	if (key.rightArrow) return to(byWord ? wordRight(text, cursor) : after(cursor));
+	if (key.home || key.ctrl && input === "a") return to(0);
+	if (key.end || key.ctrl && input === "e") return to(text.length);
+	if (key.meta && input === "b") return to(wordLeft(text, cursor));
+	if (key.meta && input === "f") return to(wordRight(text, cursor));
+	if (key.backspace || key.delete) return cursor === 0 ? d : cut(before(cursor), cursor);
+	if (key.ctrl && input === "d") return cursor === text.length ? d : cut(cursor, after(cursor));
+	if (key.ctrl && input === "u") return cut(0, cursor);
+	if (key.ctrl && input === "k") return cut(cursor, text.length);
+	if (key.ctrl && input === "w") return cut(wordLeft(text, cursor), cursor);
+	return null;
+}
+/**
+* Typed or piped text, inserted at the cursor. Whole lines are submitted, as `applyInput` does.
+*
+* Enter sends the whole line wherever the cursor is: correcting a typo mid-line does not mean
+* splitting the question. A chunk containing newlines is inserted at the cursor and then cut into
+* lines, and the text that followed the cursor stays after it on the unsent line.
+*/
+function insertChunk(d, chunk) {
+	if (chunk === "\n" || chunk === "\r") {
+		const next = applyInput(d.text, "\n");
+		return {
+			draft: atEnd(next.draft),
+			submit: next.submit
+		};
+	}
+	const before = d.text.slice(0, d.cursor);
+	const after = d.text.slice(d.cursor);
+	if (!/[\r\n]/.test(chunk)) return {
+		draft: {
+			text: before + chunk + after,
+			cursor: d.cursor + chunk.length
+		},
+		submit: []
+	};
+	const next = applyInput("", before + chunk + after);
+	return {
+		draft: {
+			text: next.draft,
+			cursor: Math.max(0, next.draft.length - after.length)
+		},
+		submit: next.submit
+	};
+}
+/**
+* A paste becomes one line of draft, and is never sent.
+*
+* `insertChunk` submits every complete line — right for a driver script piping `question\n`,
+* wrong for a human's multi-line paste. Bracketed paste (Ink's `usePaste`) routes a terminal
+* paste here instead. Line breaks fold to a single space because the draft is one line; the
+* operator edits and presses Enter. Nothing about a paste may be the Enter.
+*/
+function pasteToLine(text) {
+	return text.replace(/[\t\f\v]+/g, " ").replace(/\s+/g, (run) => /[\r\n]/.test(run) ? " " : run).trim();
+}
+/** The grapheme cluster at a cursor boundary, or '' at the end of the line. */
+function graphemeAt(text, at) {
+	for (const s of SEGMENTER.segment(text)) if (s.index >= at) return s.segment;
+	return "";
+}
+/** The draft as a masked panel draws it: one `•` per grapheme, the cursor on the same one. */
+function maskDraft(d) {
+	const cs = clusters(d.text);
+	let before = 0;
+	for (const c of cs) {
+		if (c.end > d.cursor) break;
+		before += 1;
+	}
+	return {
+		text: "•".repeat(cs.length),
+		cursor: before
+	};
+}
+
+//#endregion
+//#region src/exit-chord.ts
+const CTRL_C_WINDOW_MS = 1500;
+/** What a ctrl-c press does, given when (if ever) the previous one armed the exit. */
+function ctrlC(armedAt, now, windowMs = CTRL_C_WINDOW_MS) {
+	return armedAt !== null && now - armedAt <= windowMs ? "exit" : "arm";
+}
+
+//#endregion
+//#region src/history.ts
+/**
+* ↑/↓ walk the operator's previous turns, like a shell.
+*
+* - a bounded ring (HISTORY_MAX), for this session only;
+* - only conversation turns are kept, not slash commands, which would stand between the
+*   operator and the turn they want to redo;
+* - a recalled turn lands in the line editable, and sending it sends a new turn;
+* - the draft being typed is kept at the bottom, so walking up and back loses nothing;
+* - in a multi-line draft, ↑ walks only from the first line and ↓ only from the last, so the
+*   arrows still move the cursor inside a long paste.
+*
+* Pure: the component holds a `HistoryState` and asks these functions what to do.
+*/
+const HISTORY_MAX = 100;
+const EMPTY_HISTORY = {
+	entries: [],
+	at: null,
+	stash: ""
+};
+/**
+* Remember a sent line. Blank lines, slash commands and a straight repeat of the last one are not
+* kept — but sending any of them still ends a walk, so the next ↑ starts from the newest turn.
+*/
+function remember(h, line) {
+	const text = line.trim();
+	return {
+		entries: text === "" || text.startsWith("/") || h.entries[h.entries.length - 1] === text ? h.entries : [...h.entries, text].slice(-100),
+		at: null,
+		stash: ""
+	};
+}
+/** Whether an arrow may walk history from here, rather than move the cursor in a long draft. */
+function mayWalk(draft, cursor, dir) {
+	if (!draft.includes("\n")) return true;
+	return dir === "up" ? !draft.slice(0, cursor).includes("\n") : !draft.slice(cursor).includes("\n");
+}
+/**
+* One step. Returns the new state and the text the line should now hold, or null when there is
+* nowhere to go (↓ from the draft, ↑ past the oldest entry, or no history at all).
+*/
+function walk(h, dir, draft) {
+	if (h.entries.length === 0) return null;
+	if (dir === "up") {
+		if (h.at === null) {
+			const at = h.entries.length - 1;
+			return {
+				state: {
+					...h,
+					at,
+					stash: draft
+				},
+				text: h.entries[at] ?? ""
+			};
+		}
+		if (h.at === 0) return null;
+		const at = h.at - 1;
+		return {
+			state: {
+				...h,
+				at
+			},
+			text: h.entries[at] ?? ""
+		};
+	}
+	if (h.at === null) return null;
+	if (h.at >= h.entries.length - 1) return {
+		state: {
+			...h,
+			at: null,
+			stash: ""
+		},
+		text: h.stash
+	};
+	const at = h.at + 1;
+	return {
+		state: {
+			...h,
+			at
+		},
+		text: h.entries[at] ?? ""
+	};
+}
+/** The recalled line was edited: it is a draft now, no longer a position in the history. */
+const settle = (h) => h.at === null ? h : {
+	...h,
+	at: null,
+	stash: ""
+};
+
+//#endregion
+//#region src/keys.ts
+function keySpecOf(k) {
+	if (k.escape) return "escape";
+	if (k.return) return "enter";
+	if (k.tab) return "tab";
+	if (k.upArrow) return "up";
+	if (k.downArrow) return "down";
+	if (k.leftArrow) return "left";
+	if (k.rightArrow) return "right";
+	if (k.pageUp) return "pageup";
+	if (k.pageDown) return "pagedown";
+	if (k.home) return "home";
+	if (k.end) return "end";
+	if (k.backspace) return "backspace";
+	if (k.delete) return "delete";
+	if (k.ctrl) return `ctrl+${k.input.toLowerCase()}`;
+	if (k.meta) return `meta+${k.input.toLowerCase()}`;
+	return [...k.input].length === 1 ? k.input : null;
+}
+/** Pure: a key resolves to data, and only then does a handler run. Precedence per spec §3. */
+function resolveKey(state, key, registry) {
+	const spec = keySpecOf(key);
+	const focused = state.overlay === null ? void 0 : registry.panels.get(`${state.overlay.module}/${state.overlay.panel}`);
+	const live = (focused?.def.confirm?.length ?? 0) > 0 || focused?.def.submit !== void 0;
+	if (spec === null) return state.menu === null && state.overlay !== null && !live ? { kind: "ignore" } : { kind: "edit" };
+	if (spec === "ctrl+c") return { kind: "exit-chord" };
+	if (state.menu !== null) {
+		if (spec === "up") return {
+			kind: "menu",
+			act: "move",
+			delta: -1
+		};
+		if (spec === "down") return {
+			kind: "menu",
+			act: "move",
+			delta: 1
+		};
+		if (spec === "tab") return {
+			kind: "menu",
+			act: "accept"
+		};
+		if (spec === "enter") return {
+			kind: "menu",
+			act: state.menu === "palette" ? "run" : "accept"
+		};
+		if (spec === "escape") return {
+			kind: "menu",
+			act: "close"
+		};
+		return { kind: "edit" };
+	}
+	if (state.overlay !== null) {
+		if (spec === "escape") return { kind: "panel-close" };
+		const hit = focused?.def.keymap?.find((b) => b.key === spec);
+		if (hit) return {
+			kind: "panel",
+			module: state.overlay.module,
+			panel: state.overlay.panel,
+			act: hit.act
+		};
+		const g = registry.globals.get(spec);
+		if (g) return {
+			kind: "global",
+			module: g.module,
+			key: spec
+		};
+		if (!live) return { kind: "ignore" };
+		if (spec === "enter") {
+			const armed = focused?.def.confirm?.find((c) => c.key === state.armed);
+			return armed === void 0 ? { kind: "submit" } : {
+				kind: "confirm",
+				module: state.overlay.module,
+				panel: state.overlay.panel,
+				act: armed.act
+			};
+		}
+	}
+	const global = registry.globals.get(spec);
+	if (global) return {
+		kind: "global",
+		module: global.module,
+		key: spec
+	};
+	if (spec === "escape") return state.draftEmpty ? { kind: "cancel-turn" } : { kind: "ignore" };
+	if (spec === "up") return {
+		kind: "history",
+		dir: "up"
+	};
+	if (spec === "down") return {
+		kind: "history",
+		dir: "down"
+	};
+	if (spec === "enter") return { kind: "submit" };
+	if (spec === "tab") return { kind: "complete" };
+	return { kind: "edit" };
+}
+
+//#endregion
+//#region src/palette.ts
+/** The palette's filter text: the draft after a leading '/', until the name ends. */
+function paletteQuery(draft) {
+	return /^\/[a-z0-9-]*$/i.test(draft) ? draft.slice(1) : null;
+}
+/** Prefix matches first, then substring-only, each group alphabetical. Case-insensitive. */
+function paletteRows(commands, query) {
+	const q = query.toLowerCase();
+	const byName = (a, b) => a.cmd.name.localeCompare(b.cmd.name);
+	const rows = [];
+	for (const cmd of commands) {
+		const name = cmd.name.toLowerCase();
+		if (name.startsWith(q)) rows.push({
+			cmd,
+			prefix: true
+		});
+		else if (name.includes(q)) rows.push({
+			cmd,
+			prefix: false
+		});
+	}
+	return [...rows.filter((r) => r.prefix).sort(byName), ...rows.filter((r) => !r.prefix).sort(byName)];
+}
+function paletteMatches(commands, query) {
+	return paletteRows(commands, query).map((r) => r.cmd);
+}
+/**
+* The command Enter runs, or null when the line should be sent as typed. A substring-only row
+* runs only after the user moved onto it: Enter on a typo must never run a different command.
+*/
+function enterRuns(rows, selected, moved) {
+	const row = rows[clampSelection(selected, rows.length)];
+	if (row === void 0) return null;
+	return row.prefix || moved ? row.cmd : null;
+}
+function moveSelection(selected, delta, count) {
+	if (count <= 0) return 0;
+	return ((selected + delta) % count + count) % count;
+}
+function clampSelection(selected, count) {
+	return count <= 0 ? 0 : Math.min(Math.max(0, selected), count - 1);
+}
+function completeDraft(c) {
+	return c.args.length > 0 ? `/${c.name} ` : `/${c.name}`;
+}
+function commandUsage(c) {
+	const args = c.args.map((a) => a.optional ? `[${a.name}]` : `<${a.name}>`);
+	return [`/${c.name}`, ...args].join(" ");
+}
+function parseCommandLine(line) {
+	const m = /^\/([a-z][a-z0-9-]*)(?:\s+(.*))?$/is.exec(line.trim());
+	if (m === null) return null;
+	const args = (m[2] ?? "").trim().split(/\s+/).filter((a) => a !== "");
+	return {
+		name: m[1].toLowerCase(),
+		args
+	};
+}
+/** Width of the palette's name column. */
+const MENU_NAME_WIDTH = 22;
+/**
+* The slice of a menu `height` rows tall, centred on the selection so moving keeps it in view, and
+* the position to show beside ↑↓ when some rows are out of view (empty when every row fits).
+*/
+function menuWindow(count, selected, height) {
+	const h = Math.max(1, Math.floor(height));
+	if (count <= h) return {
+		start: 0,
+		end: count,
+		position: ""
+	};
+	const start = Math.min(Math.max(0, selected - Math.floor(h / 2)), count - h);
+	return {
+		start,
+		end: start + h,
+		position: ` · ${start + 1}–${start + h} of ${count}`
+	};
+}
+
+//#endregion
+//#region src/route-input.ts
+/** A handler whose `claims` throws is treated as not claiming, so one bad module cannot block input. */
+function claimOf(handler, line) {
+	try {
+		return handler.claims(line);
+	} catch {
+		return false;
+	}
+}
+/**
+* A command's `unavailable` reason, or null. A throwing thunk, or an empty reason, is unavailable
+* with the reason `unavailable`; an undefined one (a loose JS consumer) is available.
+*/
+function unavailableReason(spec) {
+	if (spec.unavailable === void 0) return null;
+	let reason;
+	try {
+		reason = spec.unavailable() ?? null;
+	} catch {
+		return "unavailable";
+	}
+	return reason === "" ? "unavailable" : reason;
+}
+function routeInput(line, registry, defaultTurn) {
+	const cmd = parseCommandLine(line);
+	if (cmd !== null) {
+		const hit = registry.commands.get(cmd.name);
+		if (!hit) return {
+			kind: "unknown-command",
+			name: cmd.name
+		};
+		const reason = unavailableReason(hit.spec);
+		if (reason !== null) return {
+			kind: "unavailable-command",
+			name: cmd.name,
+			reason
+		};
+		return {
+			kind: "command",
+			module: hit.module,
+			spec: hit.spec,
+			args: cmd.args
+		};
+	}
+	let best = null;
+	for (const t of registry.turns) {
+		const score = claimOf(t.handler, line);
+		if (score === false) continue;
+		if (best === null || score > best.score) best = {
+			...t,
+			score
+		};
+	}
+	if (best !== null) return {
+		kind: "turn",
+		module: best.module,
+		handler: best.handler
+	};
+	if (defaultTurn !== void 0) {
+		const d = registry.turns.find((t) => `${t.module}:${t.handler.id}` === defaultTurn);
+		if (d) return {
+			kind: "turn",
+			module: d.module,
+			handler: d.handler
+		};
+	}
+	return { kind: "no-handler" };
+}
+
+//#endregion
+//#region src/sanitise.ts
+const OSC = /(?:\u001b\]|\u009d)[^\u0007\u001b\u009c]*(?:\u0007|\u009c|\u001b\\)?/g;
+const CSI = /(?:\u001b\[|\u009b)[0-?]*[ -/]*[@-~]?/g;
+const ESC_PAIR = /\u001b[ -~]?/g;
+const CONTROL = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+/** Strips ESC sequences and C0/C1 control characters; keeps `\n`, and a tab becomes a space. */
+function sanitise(text) {
+	return text.replace(/\t/g, " ").replace(OSC, "").replace(CSI, "").replace(ESC_PAIR, "").replace(CONTROL, "");
+}
+
+//#endregion
+//#region src/terminal.ts
+/**
+* OSC 11 sets the terminal's default background, so every cell written without one — prose and
+* the empty space around it — sits on it; Ink could only colour what it draws. `none` (or an
+* empty value) leaves the terminal's background alone. Only `#rrggbb` is accepted: anything else
+* inside an OSC is an escape-injection seam into the operator's terminal, so it is dropped.
+*/
+function groundSequence(ground) {
+	const g = (ground ?? DEFAULT_GROUND).trim();
+	if (g === "" || g.toLowerCase() === "none") return null;
+	if (!/^#[0-9a-fA-F]{6}$/.test(g)) return null;
+	return `\x1b]11;${g}\x07`;
+}
+/** OSC 111: restore the terminal's configured background. */
+const RESET_GROUND = "\x1B]111\x07";
+/** Erase the visible pane (2J) and its scrollback (3J), cursor home. */
+const CLEAR_PANE = "\x1B[2J\x1B[3J\x1B[H";
+/**
+* Blank lines that put the cursor on the last row before the first frame, so the input is
+* bottom-anchored: Ink draws its live region where the cursor is, and printed turns then push the
+* pane up rather than the input down.
+*/
+function anchorPadding(rows) {
+	if (rows === void 0 || !Number.isFinite(rows) || rows < 2) return "";
+	return "\n".repeat(Math.floor(rows) - 1);
+}
+/**
+* What a re-lay writes before the transcript is printed again: the pane and its scrollback wiped,
+* then the input anchored to the last row. A resize cannot be patched, only redone — what `Static`
+* printed was laid out at the old width — and a closed panel left the conversation scrolled up,
+* which a terminal cannot scroll back down. The cost: scrollback from before the session goes too.
+*/
+function reflowSequence(rows) {
+	return CLEAR_PANE + anchorPadding(rows);
+}
+/**
+* Rows the live region just gave up with nothing printed above it — rows that would otherwise open
+* up below the input. Ink redraws its live region from where it began, so when it shrinks the input
+* rises; printing that many blank rows above it scrolls the pane back. Zero when something was
+* printed in the same step (the print scrolled the pane already) or after a re-lay (which anchors
+* on its own).
+*/
+function liveShrink(prev, now) {
+	if (prev === null || now.committed !== prev.committed || now.epoch !== prev.epoch) return 0;
+	return Math.max(0, prev.height - now.height);
+}
+/** The bytes {@link prepareTerminal} writes, in order. */
+function prepareSequence(rows, opts = {}) {
+	return (groundSequence(opts.ground) ?? "") + (opts.clear === false ? "" : CLEAR_PANE) + (opts.anchor === false ? "" : anchorPadding(rows));
+}
+/**
+* Ground, clear and anchor the terminal before `render`. Returns a restore function that puts the
+* terminal's background back. It is also registered on `exit`, and SIGHUP / SIGTERM / SIGINT exit
+* through it, since their default action kills the process with no `exit` event (under Ink's raw
+* mode ctrl+c is input, so SIGINT only arrives from outside: `kill -INT`, a supervisor, tmux).
+* A terminal left black is worse than any rendering bug. A no-op off a TTY.
+*/
+function prepareTerminal(out, opts = {}, proc = process) {
+	if (out.isTTY !== true) return () => {};
+	out.write(prepareSequence(out.rows, opts));
+	if (groundSequence(opts.ground) === null) return () => {};
+	let restored = false;
+	const restore = () => {
+		if (restored) return;
+		restored = true;
+		out.write(RESET_GROUND);
+	};
+	proc.once("exit", restore);
+	proc.once("SIGHUP", () => proc.exit(129));
+	proc.once("SIGTERM", () => proc.exit(143));
+	proc.once("SIGINT", () => proc.exit(130));
+	return restore;
+}
+
+//#endregion
+//#region src/transcript.ts
+function emptyTranscript() {
+	return {
+		committed: [],
+		flights: [],
+		nextMark: 1
+	};
+}
+function sendTurn(t, id, question, emphasis) {
+	const flight = {
+		id,
+		question,
+		mark: null,
+		...emphasis === void 0 ? {} : { emphasis }
+	};
+	return {
+		...t,
+		flights: [...t.flights, flight]
+	};
+}
+function askOf(f, mark) {
+	return {
+		key: `ask:${f.id}`,
+		kind: "ask",
+		question: f.question,
+		mark,
+		...f.emphasis === void 0 ? {} : { emphasis: f.emphasis }
+	};
+}
+function arriveTurn(t, id, reply) {
+	const index = t.flights.findIndex((f) => f.id === id);
+	if (index < 0) return t;
+	const arriving = t.flights[index];
+	const committed = [...t.committed];
+	const flights = [];
+	let nextMark = t.nextMark;
+	t.flights.forEach((f, i) => {
+		if (i === index) return;
+		if (i < index && f.mark === null) {
+			const mark = nextMark;
+			nextMark += 1;
+			committed.push(askOf(f, mark));
+			flights.push({
+				...f,
+				mark
+			});
+			return;
+		}
+		flights.push(f);
+	});
+	const answer = {
+		key: `answer:${id}`,
+		kind: "answer",
+		question: arriving.question,
+		reply,
+		mark: arriving.mark
+	};
+	if (arriving.mark === null) committed.push(askOf(arriving, null), answer);
+	else committed.push(answer);
+	return {
+		committed,
+		flights,
+		nextMark
+	};
+}
+function heldAsks(t) {
+	return t.flights.filter((f) => f.mark === null);
+}
+function markedFlights(t) {
+	return t.flights.filter((f) => f.mark !== null);
+}
+function commitEntry(t, entry) {
+	return {
+		...t,
+		committed: [...t.committed, entry]
+	};
+}
+/** The last answer printed, or the one carrying mark `n`. */
+function answerEntry(t, mark) {
+	for (let i = t.committed.length - 1; i >= 0; i -= 1) {
+		const e = t.committed[i];
+		if (e !== void 0 && e.kind === "answer" && (mark === null || e.mark === mark)) return e;
+	}
+	return null;
+}
+function addGap(t, lines, epoch) {
+	if (lines <= 0) return t;
+	return commitEntry(t, {
+		key: `gap:${t.committed.length}`,
+		kind: "gap",
+		lines,
+		epoch
+	});
+}
+
+//#endregion
+//#region src/module.ts
+const MODULE_ID = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/;
+function defineModule(id, spec) {
+	if (!MODULE_ID.test(id)) throw new Error(`module id '${id}' must be lower-case dotted, e.g. 'app.ask'`);
+	return {
+		id,
+		...spec
+	};
+}
+
+//#endregion
+//#region src/overlay.ts
+/** A panel's state when it is the one open, else `null`. */
+function panelOf(o, kind) {
+	return o !== null && o.kind === kind ? o.panel : null;
+}
+/**
+* The overlay after one panel's setter ran. The updater sees this panel's state, or `null`
+* when another panel (or none) is open, exactly as a per-panel `useState` would have shown it.
+*
+* - A value opens this panel and replaces whatever was open.
+* - `null` closes this panel only if it is the one open. Closing a panel that is not open
+*   must not close the one that is.
+* - An updater returning what it was given changes nothing. That is how a slow read landing
+*   for a panel that has since closed, or been replaced, is dropped.
+*/
+function setPanel(o, kind, next) {
+	const current = panelOf(o, kind);
+	const value = typeof next === "function" ? next(current) : next;
+	if (value === current) return o;
+	if (value === null) return current === null ? o : null;
+	return {
+		kind,
+		panel: value
+	};
+}
+
+//#endregion
+export { wordRight as $, moveSelection as A, remember as B, unavailableReason as C, completeDraft as D, commandUsage as E, keySpecOf as F, EMPTY_DRAFT as G, walk as H, resolveKey as I, graphemeAt as J, atEnd as K, EMPTY_HISTORY as L, paletteQuery as M, paletteRows as N, enterRuns as O, parseCommandLine as P, wordLeft as Q, HISTORY_MAX as R, routeInput as S, clampSelection as T, CTRL_C_WINDOW_MS as U, settle as V, ctrlC as W, maskDraft as X, insertChunk as Y, pasteToLine as Z, liveShrink as _, answerEntry as a, normaliseKeySpec as at, reflowSequence as b, emptyTranscript as c, sendTurn as d, applyInput as et, CLEAR_PANE as f, groundSequence as g, anchorPadding as h, addGap as i, composeModules as it, paletteMatches as j, menuWindow as k, heldAsks as l, RESET_GROUND as m, setPanel as n, RESERVED_GLOBAL_KEYS as nt, arriveTurn as o, applySuggestion as ot, DEFAULT_GROUND as p, editKey as q, defineModule as r, assertComposes as rt, commitEntry as s, mergeCompletions as st, panelOf as t, CompositionError as tt, markedFlights as u, prepareSequence as v, MENU_NAME_WIDTH as w, sanitise as x, prepareTerminal as y, mayWalk as z };