@loomwork/ui-renderer-terminal 0.0.0-stage → 0.1.1

package/dist/esm/interactive.js

@@ -0,0 +1,677 @@
+import { HYDRATION_VALUES_PREFIX, createSay, oneLineChatText, optionsProblem, viewedVersionOf, } from "@loomwork/ui-core";
+import { MAX_MULTI_SELECTED, SELECT_ACTION, SELECT_MANY_ACTION, SUBMIT_TEXT_ACTION, multiSelectValueIssues, newSubmitKey, stripUnsafeChars, validateSelectValue, validateTextValue, } from "@loomwork/ui-core/chat-ui";
+import { inert } from "./inert";
+import { renderExperience } from "./status";
+/** Bracketed paste: the terminal wraps a paste in these, so it can never be taken for typing. */
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+/** Enable / disable bracketed paste mode. */
+const PASTE_ON = "\x1b[?2004h";
+const PASTE_OFF = "\x1b[?2004l";
+/** Most paste text one span keeps (a paste is a draft, not a file). */
+const MAX_PASTE = 1 << 20;
+const pasteText = (raw) => stripUnsafeChars(raw.replace(/\r\n?|\u2028|\u2029/g, "\n").replace(/\t/g, " "));
+/** One printable code point: what a `char` key may carry. Anything else is not typed text. */
+export function isPrintableChar(ch) {
+    if (typeof ch !== "string" || ch === "" || Array.from(ch).length !== 1)
+        return false;
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp < 0x20 || cp === 0x2028 || cp === 0x2029)
+        return false;
+    return stripUnsafeChars(ch) === ch;
+}
+const NAMED = [
+    ["\x1b[Z", "shift-tab"],
+    ["\x1b[A", "up"],
+    ["\x1b[B", "down"],
+    ["\x1bOA", "up"],
+    ["\x1bOB", "down"],
+    ["\t", "tab"],
+    ["\r\n", "enter"],
+    ["\r", "enter"],
+    ["\n", "enter"],
+    ["\x7f", "backspace"],
+    ["\b", "backspace"],
+    ["\x03", "interrupt"],
+];
+/** How long a bracketed paste may sit with no byte before it is abandoned (ms of the injected clock). */
+const PASTE_IDLE_MS = 2000;
+/** The longest proper suffix of `s` that is a prefix of the paste end marker (a marker split across chunks). */
+function markerTail(s) {
+    for (let n = Math.min(PASTE_END.length - 1, s.length); n > 0; n--) {
+        if (PASTE_END.startsWith(s.slice(s.length - n)))
+            return s.slice(s.length - n);
+    }
+    return "";
+}
+/**
+ * A decoder that remembers an unfinished bracketed paste across chunks. `decodeKeys` is the
+ * stateless form (one chunk, a fresh decoder). It returns EVERY input unit, dropped sequences and
+ * non-printables included as `ignored`, so a caller can tell a lone key from one with company.
+ *
+ * Paste mode always ends: at the end marker (even split across chunks), at Ctrl-C (the paste is
+ * discarded and the interrupt delivered), when the paste outgrows MAX_PASTE (it is discarded, and
+ * the rest is swallowed up to the end marker, never typed), or after `pasteIdleMs` of silence, when the
+ * remainder (if any) is drained: discarded up to the end marker, Ctrl-C, or MAX_PASTE more UTF-16
+ * code units AND `pasteIdleMs` of silence (a still-flowing paste keeps draining). A drain or an
+ * overflowed paste that ends inside a chunk emits an `ignored` key, so what follows is never sole.
+ * Nothing it discards ever becomes a key.
+ */
+export function createKeyDecoder(opts = {}) {
+    const now = opts.now ?? Date.now;
+    const idleMs = opts.pasteIdleMs ?? PASTE_IDLE_MS;
+    let pasting;
+    let overflow = false;
+    let carry = "";
+    let lastByteAt = 0;
+    // After an idle-abandon the rest of the stalled paste may still arrive: drain (discard) it up to
+    // the end marker or Ctrl-C, so it is never typed. Silence does NOT end the drain (a slow link can
+    // stall again mid-paste, and what follows is still the paste); a bound (MAX_PASTE UTF-16 code
+    // units) PLUS idleMs of silence does, so a lost end marker costs at most that, never all input.
+    let draining = false;
+    let drained = 0;
+    const leavePaste = () => {
+        pasting = undefined;
+        overflow = false;
+        carry = "";
+    };
+    return (chunk) => {
+        const keys = [];
+        let i = 0;
+        if (pasting !== undefined && now() - lastByteAt > idleMs) {
+            leavePaste();
+            draining = true;
+            drained = 0;
+        }
+        if (draining && drained > MAX_PASTE && now() - lastByteAt > idleMs) {
+            // Past the bound AND silent for idleMs: the end marker is lost, hand the input back.
+            draining = false;
+            carry = "";
+        }
+        if (draining) {
+            lastByteAt = now();
+            const text = carry + chunk;
+            const lead = carry.length;
+            carry = "";
+            const end = text.indexOf(PASTE_END);
+            const ctrl = text.indexOf("\x03");
+            if (ctrl !== -1 && (end === -1 || ctrl < end)) {
+                draining = false;
+                keys.push({ name: "interrupt" });
+                i = ctrl - lead + 1;
+            }
+            else if (end !== -1) {
+                draining = false;
+                // Discarded content yields no key of its own, so mark the end: whatever follows in this
+                // chunk is then never a sole key.
+                keys.push({ name: "ignored" });
+                i = end - lead + PASTE_END.length;
+            }
+            else {
+                // Past the bound the drain ends only after idleMs of silence (checked above), so a
+                // still-flowing paste is never typed.
+                drained += chunk.length;
+                carry = markerTail(text);
+                return keys;
+            }
+        }
+        while (i < chunk.length) {
+            if (pasting !== undefined) {
+                lastByteAt = now();
+                const text = carry + chunk.slice(i);
+                const lead = carry.length;
+                carry = "";
+                const end = text.indexOf(PASTE_END);
+                const ctrl = text.indexOf("\x03");
+                if (ctrl !== -1 && (end === -1 || ctrl < end)) {
+                    // Ctrl-C always gets out: the paste is dropped and the interrupt is delivered.
+                    leavePaste();
+                    keys.push({ name: "interrupt" });
+                    i += ctrl - lead + 1;
+                    continue;
+                }
+                const stop = end === -1 ? text.length - markerTail(text).length : end;
+                if (!overflow) {
+                    pasting += text.slice(0, stop);
+                    if (pasting.length > MAX_PASTE) {
+                        overflow = true;
+                        pasting = "";
+                    }
+                }
+                if (end === -1) {
+                    carry = text.slice(stop);
+                    return keys;
+                }
+                keys.push(overflow ? { name: "ignored" } : { name: "paste", text: pasteText(pasting) });
+                leavePaste();
+                i += end - lead + PASTE_END.length;
+                continue;
+            }
+            const rest = chunk.slice(i);
+            if (rest.startsWith(PASTE_START)) {
+                pasting = "";
+                lastByteAt = now();
+                i += PASTE_START.length;
+                continue;
+            }
+            const hit = NAMED.find(([seq]) => rest.startsWith(seq));
+            if (hit !== undefined) {
+                keys.push({ name: hit[1] });
+                i += hit[0].length;
+                continue;
+            }
+            if (rest.startsWith("\x1b")) {
+                // A control string (OSC/DCS/SOS/PM/APC) is dropped WHOLE, payload included; so is a CSI/SS3.
+                const seq = CONTROL_STRING.exec(rest) ?? CSI.exec(rest) ?? SS3.exec(rest);
+                if (seq !== null) {
+                    keys.push({ name: "ignored" });
+                    i += seq[0].length;
+                    continue;
+                }
+                keys.push({ name: "escape" });
+                i += 1;
+                continue;
+            }
+            const cp = rest.codePointAt(0) ?? 0;
+            const ch = String.fromCodePoint(cp);
+            i += ch.length;
+            // Controls, bidi and invisible marks are never typed text (core's one unsafe set).
+            keys.push(isPrintableChar(ch) ? { name: "char", char: ch } : { name: "ignored" });
+        }
+        return keys;
+    };
+}
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC begins the sequences being matched
+const CONTROL_STRING = /^\x1b[\]PX^_][^\x07\x1b]*(?:\x07|\x1b\\)?/;
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC begins the sequences being matched
+const CSI = /^\x1b\[[0-9;?]*[ -/]*[@-~]/;
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC begins the sequences being matched
+const SS3 = /^\x1bO[@-~]/;
+/**
+ * Split a chunk of terminal input into keys. Unknown escape sequences (arrows left/right, function
+ * keys, mouse reports, OSC strings) are dropped whole rather than leaking their bytes in as
+ * characters; a lone ESC is `escape`. Printable code points become `char` keys; a bracketed paste
+ * (`ESC[200~ … ESC[201~`) is ONE `paste` key, text only.
+ */
+export function decodeKeys(chunk) {
+    return createKeyDecoder()(chunk).filter((k) => k.name !== "ignored");
+}
+/** The lines that differ between two frames, in order. Equal frames diff to nothing. */
+export function diffFrames(prev, next) {
+    const out = [];
+    const n = Math.max(prev.length, next.length);
+    for (let i = 0; i < n; i++)
+        if (prev[i] !== next[i])
+            out.push({ line: i, text: next[i] });
+    return out;
+}
+const CLEAR_SCREEN = "\x1b[2J\x1b[H";
+const at = (line) => `\x1b[${line + 1};1H`;
+/** The escape sequences that apply `patches`, then park the cursor under the frame. */
+export function paintPatches(patches, nextLength) {
+    if (patches.length === 0)
+        return "";
+    const body = patches.map((p) => `${at(p.line)}\x1b[2K${p.text ?? ""}`).join("");
+    return `${body}${at(nextLength)}`;
+}
+/** Every widget under `layout`, in document order (a grid child is a `GridCell` holding its node). */
+function widgetsOf(layout) {
+    const out = [];
+    const visit = (node) => {
+        if ("_tag" in node) {
+            out.push(node);
+            return;
+        }
+        for (const child of node.children)
+            visit("node" in child ? child.node : child);
+    };
+    visit(layout);
+    return out;
+}
+const propLabel = (raw) => typeof raw === "string" ? oneLineChatText(raw, 80) : "";
+/**
+ * Run the renderer as a live, keyboard-driven session.
+ *
+ * Consent (`y` / `n`, a submit) acts only as the SOLE unit of an input chunk: every decoded unit
+ * counts, dropped escape sequences and non-printables included. KNOWN LIMITS, because a chunk
+ * boundary is all the terminal gives us: (1) a terminal WITHOUT bracketed paste delivers a one-char
+ * paste (`y`) as a one-key chunk, indistinguishable from a keypress; (2) a host that reads byte by
+ * byte (slow serial / ssh) makes every key a one-key chunk, so a multi-line non-bracketed paste can
+ * reach `\t`, `y`. For such hosts turn on `confirmConsent`, which asks for the same key again in a
+ * later chunk. Default off.
+ */
+export function interactiveTerminal(initial, opts) {
+    const { store, onAction, input, output, onPaint, labels, compile } = opts;
+    const say = createSay(opts.i18n);
+    const focusMark = labels?.focus ?? "▸";
+    const hint = labels?.hint ?? "⇥ ⏎ ⎋";
+    const renderOpts = (({ store: _s, onAction: _a, input: _i, output: _o, onPaint: _p, onInterrupt: _t, labels: _l, compile: _c, confirmConsent: _cc, now: _n, pasteIdleMs: _pi, ...rest }) => rest)(opts);
+    let blueprint = initial;
+    let focusId;
+    let mode = { kind: "nav" };
+    let note = "";
+    let previous;
+    let stopped = false;
+    let current = "";
+    let queue = Promise.resolve();
+    /** The APPROVE/REJECT already sent for a pending approval: further y/n are ignored until the frame moves. */
+    let armed;
+    let answered;
+    const boundValue = (w) => {
+        const p = w.binding?.path;
+        if (p === undefined || !p.startsWith(`${HYDRATION_VALUES_PREFIX}.`))
+            return undefined;
+        return store.value(p.slice(HYDRATION_VALUES_PREFIX.length + 1));
+    };
+    const statusOf = (w) => {
+        if (w.binding === undefined)
+            return undefined;
+        const st = store.status(w.binding.path.slice(HYDRATION_VALUES_PREFIX.length + 1));
+        return st === undefined
+            ? undefined
+            : { state: st.state, ...(st.seq !== undefined && { seq: st.seq }) };
+    };
+    function capture() {
+        const statuses = new Map();
+        const parts = [blueprint.id];
+        for (const c of controlsNow()) {
+            const st = statusOf(c.widget);
+            statuses.set(c.id, st);
+            parts.push([c.id, c.kind, st?.state, st?.seq]);
+        }
+        return { id: blueprint.id, statuses, fp: JSON.stringify(parts) };
+    }
+    function controlsNow() {
+        const out = [];
+        for (const w of widgetsOf(blueprint.layout)) {
+            const label = propLabel(w.props.label) || propLabel(w.title);
+            if (w.kind === "ApprovalCard") {
+                // Like the web: no pending approval, no controls.
+                if (boundValue(w))
+                    out.push({
+                        id: w.id,
+                        kind: "approval",
+                        label: label || say("lu.approval.approve"),
+                        widget: w,
+                    });
+            }
+            else if (w.kind === "SelectInput") {
+                if (optionsProblem(w.props.options) === undefined)
+                    out.push({ id: w.id, kind: "select", label: label || say("lu.input.choose"), widget: w });
+            }
+            else if (w.kind === "MultiSelectInput") {
+                if (multiSelectValueIssues(boundValue(w)).length === 0)
+                    out.push({ id: w.id, kind: "multi", label: label || say("lu.input.choose"), widget: w });
+            }
+            else if (w.kind === "TextInput") {
+                out.push({ id: w.id, kind: "text", label: label || say("lu.input.message"), widget: w });
+            }
+        }
+        return out;
+    }
+    const optionsOf = (w) => optionsProblem(w.props.options) === undefined
+        ? w.props.options
+        : [];
+    const multiOf = (w) => {
+        const v = boundValue(w);
+        return multiSelectValueIssues(v).length === 0 ? v : undefined;
+    };
+    const maxOf = (w) => {
+        const m = w.props.maxSelected;
+        return typeof m === "number" && Number.isInteger(m) && m >= 1 && m <= MAX_MULTI_SELECTED
+            ? m
+            : MAX_MULTI_SELECTED;
+    };
+    /** The checklist's cursor and ticks, held to the CURRENT options and cap: what is drawn is what a send uses. */
+    const reconcile = (w, index, picks) => {
+        const m = multiOf(w);
+        const have = new Set((m?.options ?? []).map((o) => o.value));
+        const kept = [...new Set(picks)].filter((p) => have.has(p)).slice(0, maxOf(w));
+        const last = Math.max(0, (m?.options.length ?? 1) - 1);
+        return { index: Math.min(Math.max(0, index), last), picks: kept };
+    };
+    function build() {
+        const body = renderExperience(blueprint, store, renderOpts);
+        const controls = controlsNow();
+        if (controls.length === 0)
+            return inert(body);
+        if (focusId === undefined || !controls.some((c) => c.id === focusId)) {
+            focusId = controls[0]?.id;
+            mode = { kind: "nav" };
+        }
+        const lines = ["─".repeat(24)];
+        for (const c of controls) {
+            const focused = c.id === focusId;
+            const mark = focused ? focusMark : " ";
+            if (c.kind === "approval") {
+                lines.push(`${mark} ${c.label}  [y] ${say("lu.approval.approve")}  [n] ${say("lu.approval.reject")}`);
+            }
+            else if (c.kind === "text") {
+                const editing = focused && mode.kind === "text";
+                lines.push(`${mark} ${c.label}: ${editing ? `${mode.draft}▏` : "…"}`);
+            }
+            else if (c.kind === "multi") {
+                lines.push(`${mark} ${c.label}`);
+                const m = multiOf(c.widget);
+                if (focused && mode.kind === "multi" && m !== undefined) {
+                    const rec = reconcile(c.widget, mode.index, mode.picks);
+                    const at = rec.index;
+                    const from = Math.max(0, Math.min(at - 4, m.options.length - 10));
+                    const picks = new Set(rec.picks);
+                    m.options.slice(from, from + 10).forEach((o, k) => {
+                        const i = from + k;
+                        lines.push(`   ${i === at ? "›" : " "} [${picks.has(o.value) ? "x" : " "}] ${oneLineChatText(o.label, 60)}`);
+                    });
+                }
+            }
+            else {
+                lines.push(`${mark} ${c.label}`);
+                const w = controls.find((x) => x.id === c.id)?.widget;
+                if (focused && mode.kind === "pick" && w !== undefined) {
+                    const at = mode.index;
+                    optionsOf(w).forEach((o, i) => lines.push(`   ${i === at ? "›" : " "} ${i + 1}) ${oneLineChatText(o.label, 60)}`));
+                }
+            }
+        }
+        if (note !== "")
+            lines.push(note);
+        lines.push(hint);
+        // The WHOLE frame is made inert, footer included: the i18n words, the hint and focus marks, and
+        // the draft echo are as host- or viewer-authored as any title.
+        return inert(`${body}${lines.join("\n")}\n`);
+    }
+    function paint(force = false) {
+        if (stopped)
+            return;
+        current = build();
+        const next = current.replace(/\n$/, "").split("\n");
+        const prev = previous;
+        previous = next;
+        if (output === undefined)
+            return;
+        if (prev === undefined || force) {
+            output.write(`${CLEAR_SCREEN}${next.join("\n")}\n`);
+            onPaint?.({ mode: "full", changedLines: next.length, totalLines: next.length });
+            return;
+        }
+        const patches = diffFrames(prev, next);
+        if (patches.length > 0)
+            output.write(paintPatches(patches, next.length));
+        onPaint?.({
+            mode: patches.length === 0 ? "none" : "patch",
+            changedLines: patches.length,
+            totalLines: next.length,
+        });
+    }
+    async function dispatch(action, w, snap) {
+        if (onAction === undefined) {
+            note = say("lu.chat.dispatch.unavailable");
+            return false;
+        }
+        // Stamped from what the viewer saw when the key ARRIVED, not from whatever is current by the
+        // time a queued key runs.
+        const status = snap.statuses.get(w.id);
+        const stamped = {
+            ...action,
+            viewedVersion: viewedVersionOf(snap.id, status, compile),
+        };
+        note = say("lu.chat.sending");
+        paint();
+        try {
+            const out = (await onAction(stamped));
+            if (typeof out === "object" && out !== null && out.ok === false) {
+                note = say(out.reason === "stale" ? "lu.chat.dispatch.stale" : "lu.chat.dispatch.failed");
+                return false;
+            }
+            note = say("lu.input.sent");
+            return true;
+        }
+        catch {
+            note = say("lu.chat.dispatch.failed");
+            return false;
+        }
+    }
+    /**
+     * A consent key (y/n on an approval, any submit) acts only when it is the SOLE key of its input
+     * chunk and the frame it was pressed on is still the current one. Otherwise it is refused.
+     */
+    function consent(sole, snap) {
+        if (!sole)
+            return false;
+        if (snap.fp !== capture().fp) {
+            note = say("lu.chat.dispatch.stale");
+            return false;
+        }
+        return true;
+    }
+    async function handle(key, sole, snap) {
+        // Any key but the confirming one disarms; the confirming key is checked below.
+        const wasArmed = armed;
+        armed = undefined;
+        if (key.name === "interrupt") {
+            (opts.onInterrupt ?? stop)();
+            return "stop";
+        }
+        if (key.name === "char" && !isPrintableChar(key.char))
+            return undefined;
+        const controls = controlsNow();
+        const i = controls.findIndex((c) => c.id === focusId);
+        const c = controls[i];
+        if (c === undefined)
+            return undefined;
+        if (mode.kind === "text") {
+            if (key.name === "escape")
+                mode = { kind: "nav" };
+            else if (key.name === "backspace")
+                mode = { kind: "text", draft: Array.from(mode.draft).slice(0, -1).join("") };
+            else if (key.name === "char")
+                mode = { kind: "text", draft: mode.draft + (key.char ?? "") };
+            else if (key.name === "paste")
+                mode = { kind: "text", draft: mode.draft + (key.text ?? "") };
+            else if (key.name === "enter") {
+                if (!consent(sole, snap))
+                    return "stop";
+                const v = validateTextValue(mode.draft);
+                if (!v.ok) {
+                    note = v.error === "too-long" ? say("lu.input.error.tooLong") : say("lu.chat.typeFirst");
+                }
+                else {
+                    const ok = await dispatch({
+                        type: SUBMIT_TEXT_ACTION,
+                        widgetId: c.id,
+                        payload: { text: v.text, key: newSubmitKey() },
+                    }, c.widget, snap);
+                    // Like the web: what was typed is kept until the host says it arrived.
+                    if (ok)
+                        mode = { kind: "nav" };
+                    return "stop";
+                }
+            }
+            return undefined;
+        }
+        if (mode.kind === "pick") {
+            const options = optionsOf(c.widget);
+            let choose;
+            if (key.name === "escape")
+                mode = { kind: "nav" };
+            else if (key.name === "up")
+                mode = { kind: "pick", index: Math.max(0, mode.index - 1) };
+            else if (key.name === "down")
+                mode = { kind: "pick", index: Math.min(options.length - 1, mode.index + 1) };
+            else if (key.name === "enter")
+                choose = mode.index;
+            else if (key.name === "char" && key.char !== undefined && /^[1-9]$/.test(key.char))
+                choose = Number(key.char) - 1;
+            if (choose !== undefined) {
+                const picked = options[choose];
+                const v = picked === undefined ? undefined : validateSelectValue(options, picked.value);
+                if (v?.ok === true) {
+                    if (!consent(sole, snap))
+                        return "stop";
+                    const ok = await dispatch({
+                        type: SELECT_ACTION,
+                        widgetId: c.id,
+                        payload: { value: v.value, key: newSubmitKey() },
+                    }, c.widget, snap);
+                    if (ok)
+                        mode = { kind: "nav" };
+                    return "stop";
+                }
+            }
+            return undefined;
+        }
+        if (mode.kind === "multi") {
+            const m = multiOf(c.widget);
+            if (m === undefined) {
+                mode = { kind: "nav" };
+                return undefined;
+            }
+            mode = { kind: "multi", ...reconcile(c.widget, mode.index, mode.picks) };
+            const last = m.options.length - 1;
+            if (key.name === "escape")
+                mode = { kind: "nav" };
+            else if (key.name === "up")
+                mode = { ...mode, index: Math.max(0, mode.index - 1) };
+            else if (key.name === "down")
+                mode = { ...mode, index: Math.min(last, mode.index + 1) };
+            else if (key.name === "char" && key.char === " ") {
+                const o = m.options[mode.index];
+                if (o !== undefined) {
+                    const has = mode.picks.includes(o.value);
+                    if (has)
+                        mode = { ...mode, picks: mode.picks.filter((p) => p !== o.value) };
+                    else if (mode.picks.length < maxOf(c.widget))
+                        mode = { ...mode, picks: [...mode.picks, o.value] };
+                }
+            }
+            else if (key.name === "enter") {
+                if (!consent(sole, snap))
+                    return "stop";
+                const ok = await dispatch({
+                    type: SELECT_MANY_ACTION,
+                    widgetId: c.id,
+                    payload: { values: [...mode.picks], key: newSubmitKey() },
+                }, c.widget, snap);
+                if (ok)
+                    mode = { kind: "nav" };
+                return "stop";
+            }
+            return undefined;
+        }
+        // Navigation. A paste is text: with no draft open it is nothing.
+        if (key.name === "paste")
+            return undefined;
+        note = "";
+        const move = (d) => {
+            focusId = controls[(i + d + controls.length) % controls.length]?.id;
+        };
+        if (key.name === "tab" || key.name === "down")
+            move(1);
+        else if (key.name === "shift-tab" || key.name === "up")
+            move(-1);
+        else if (c.kind === "approval" &&
+            key.name === "char" &&
+            (key.char === "y" || key.char === "n")) {
+            if (!consent(sole, snap))
+                return "stop";
+            // One answer per pending approval: until the frame moves (the host answered, or a new
+            // version landed) a second y/n is ignored, so a repeat cannot double-submit.
+            if (answered !== undefined && answered.id === c.id && answered.fp === snap.fp)
+                return "stop";
+            if (opts.confirmConsent === true &&
+                !(wasArmed?.id === c.id && wasArmed.fp === snap.fp && wasArmed.char === key.char)) {
+                const char = key.char ?? "";
+                armed = { id: c.id, fp: snap.fp, char };
+                note = labels?.confirm ?? `${char} ×2`;
+                return "stop";
+            }
+            const approved = key.char === "y";
+            const ok = await dispatch({ type: approved ? "APPROVE" : "REJECT", widgetId: c.id, payload: { approved } }, c.widget, snap);
+            answered = ok ? { id: c.id, fp: snap.fp } : undefined;
+            return "stop";
+        }
+        else if (key.name === "enter") {
+            if (c.kind === "text")
+                mode = { kind: "text", draft: "" };
+            else if (c.kind === "select")
+                mode = { kind: "pick", index: 0 };
+            else if (c.kind === "multi")
+                mode = { kind: "multi", ...reconcile(c.widget, 0, multiOf(c.widget)?.selected ?? []) };
+        }
+        return undefined;
+    }
+    const run = (work) => {
+        queue = queue.then(work, work);
+        return queue;
+    };
+    /** One INPUT CHUNK: the keys the terminal delivered together (a paste arrives this way). */
+    async function chunkOf(keys) {
+        // The frame the keys were pressed on is captured NOW, before they queue behind anything.
+        const snap = capture();
+        const sole = keys.length === 1;
+        await run(async () => {
+            for (const k of keys) {
+                if (stopped)
+                    return;
+                const before = mode.kind;
+                const out = await handle(k, sole, snap);
+                paint();
+                // A key that changed mode or submitted ends the chunk: what follows in the SAME chunk was
+                // typed (or pasted) for the old mode, never for the new one.
+                if (out === "stop" || mode.kind !== before)
+                    return;
+            }
+        });
+    }
+    /** Programmatic keys: each is its own arrival, in order (a caller pressing keys means each one). */
+    async function press(...keys) {
+        await Promise.all(keys.map((k) => chunkOf([k])));
+    }
+    const decode = createKeyDecoder({
+        ...(opts.now !== undefined ? { now: opts.now } : {}),
+        ...(opts.pasteIdleMs !== undefined ? { pasteIdleMs: opts.pasteIdleMs } : {}),
+    });
+    const onData = (chunk) => {
+        void chunkOf(decode(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8")));
+    };
+    // Bracketed paste is on while a session reads input AND paints, so a paste arrives wrapped.
+    const pasteMode = input !== undefined && output !== undefined;
+    const stops = [];
+    function stop() {
+        if (stopped)
+            return;
+        stopped = true;
+        for (const s of stops.splice(0))
+            s();
+        if (pasteMode)
+            output?.write(PASTE_OFF);
+    }
+    stops.push(store.runtimeSubscribe(() => paint()));
+    if (opts.projectionSubscribe !== undefined)
+        stops.push(opts.projectionSubscribe(() => paint()));
+    if (input !== undefined) {
+        input.setRawMode?.(true);
+        input.resume?.();
+        input.on("data", onData);
+        stops.push(() => {
+            (input.off ?? input.removeListener)?.call(input, "data", onData);
+            input.setRawMode?.(false);
+        });
+    }
+    if (pasteMode)
+        output?.write(PASTE_ON);
+    paint();
+    return {
+        frame: () => current,
+        controls: () => controlsNow().map(({ id, kind, label }) => ({ id, kind, label })),
+        focused: () => focusId,
+        send: (chunk) => chunkOf(decode(chunk)),
+        press,
+        update(next) {
+            blueprint = next;
+            paint();
+        },
+        stop,
+    };
+}
+//# sourceMappingURL=interactive.js.map