@tiagojct/subsub 0.20.0 → 0.22.0

package/dist/rpc.js

@@ -0,0 +1,185 @@
+/**
+ * pi in RPC mode, for the clients that show Sub-Sub: the web view (src/web.ts) and the full-screen terminal client (src/tui.ts). One child
+ * process, strict JSONL (records end at LF only), requests answered by id, every other record handed to the listeners. Sub-Sub's extension
+ * tells its clients what pi's RPC protocol has no place for through two status texts: the state of the library ("subsub.web") and the
+ * answer to a library search ("subsub.find").
+ */
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+import { field, frontMatter } from "./notes.js";
+/** pi as a child process in RPC mode. Strict JSONL: records end at LF only. */
+export class Agent {
+    proc;
+    decoder = new StringDecoder("utf8");
+    buf = "";
+    n = 0;
+    pending = new Map();
+    listeners = new Set();
+    stderr = "";
+    onExit;
+    command;
+    args;
+    cwd;
+    env;
+    constructor(command, args, cwd, env) {
+        this.command = command;
+        this.args = args;
+        this.cwd = cwd;
+        this.env = env;
+    }
+    start(extra = []) {
+        this.buf = "";
+        this.decoder = new StringDecoder("utf8");
+        const proc = spawn(this.command, [...this.args, ...extra], { cwd: this.cwd, env: this.env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+        this.proc = proc;
+        proc.stdout.on("data", (chunk) => this.feed(this.decoder.write(chunk)));
+        proc.stderr.on("data", (d) => {
+            this.stderr = (this.stderr + d.toString()).slice(-20_000);
+        });
+        proc.once("exit", (code) => {
+            if (this.proc !== proc)
+                return;
+            this.proc = undefined;
+            for (const p of this.pending.values()) {
+                clearTimeout(p.timer);
+                p.reject(new Error(`pi stopped (code ${code}). ${this.stderr.slice(-500)}`));
+            }
+            this.pending.clear();
+            this.onExit?.(code);
+        });
+    }
+    feed(text) {
+        this.buf += text;
+        let i;
+        while ((i = this.buf.indexOf("\n")) >= 0) {
+            const line = this.buf.slice(0, i).replace(/\r$/, "");
+            this.buf = this.buf.slice(i + 1);
+            if (!line.trim())
+                continue;
+            let rec;
+            try {
+                rec = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (rec.type === "response" && typeof rec.id === "string" && this.pending.has(rec.id)) {
+                const p = this.pending.get(rec.id);
+                this.pending.delete(rec.id);
+                clearTimeout(p.timer);
+                if (rec.success === false)
+                    p.reject(new Error(rec.error ?? `${rec.command} failed`));
+                else
+                    p.resolve(rec.data);
+                continue;
+            }
+            for (const l of this.listeners)
+                l(rec);
+        }
+    }
+    on(l) {
+        this.listeners.add(l);
+        return () => this.listeners.delete(l);
+    }
+    write(rec) {
+        const stdin = this.proc?.stdin;
+        if (!stdin || !stdin.writable)
+            throw new Error("pi is not running");
+        stdin.write(`${JSON.stringify(rec)}\n`);
+    }
+    request(cmd, timeoutMs = 30_000) {
+        const id = `w${++this.n}`;
+        return new Promise((resolvePromise, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`pi did not answer ${String(cmd.type)} in time`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve: resolvePromise, reject, timer });
+            try {
+                this.write({ ...cmd, id });
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(err);
+            }
+        });
+    }
+    async stop() {
+        const proc = this.proc;
+        if (!proc)
+            return;
+        this.proc = undefined;
+        for (const p of this.pending.values()) {
+            clearTimeout(p.timer);
+            p.reject(new Error("pi was stopped"));
+        }
+        this.pending.clear();
+        await new Promise((done) => {
+            const t = setTimeout(() => {
+                proc.kill("SIGKILL");
+                done();
+            }, 3000);
+            proc.once("exit", () => {
+                clearTimeout(t);
+                done();
+            });
+            proc.kill();
+        });
+    }
+}
+/** The dialogs that wait for an answer (extension_ui_response): the rest of the extension UI requests are notices. */
+export function isDialog(ev) {
+    return ev?.type === "extension_ui_request" && ["select", "confirm", "input", "editor"].includes(ev.method);
+}
+/** What the extension sends as status texts: the state of the library and the answer to the last library search. */
+export class Side {
+    state = null;
+    find = null;
+    /** Decode an extension_ui_request; tells which of the two it was, or undefined. */
+    take(ev) {
+        if (ev?.type !== "extension_ui_request" || ev.method !== "setStatus")
+            return undefined;
+        const decode = () => {
+            try {
+                return ev.statusText ? JSON.parse(ev.statusText) : null;
+            }
+            catch {
+                return null;
+            }
+        };
+        if (ev.statusKey === "subsub.web") {
+            this.state = decode();
+            return "state";
+        }
+        if (ev.statusKey === "subsub.find") {
+            this.find = decode();
+            return "find";
+        }
+        return undefined;
+    }
+}
+/** Search the library through the extension (the hidden /subsub-find command); the answer comes back as a status text. */
+export async function findLibrary(agent, side, q) {
+    if (!q)
+        return { q, items: [] };
+    await agent.request({ type: "prompt", message: `/subsub-find ${q}` });
+    return side.find?.q === q ? side.find : { q, items: [] };
+}
+function readText(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+/** RPC has no argument hints: read them from the front matter of the prompt files. */
+export function withHints(commands) {
+    return commands.map((c) => {
+        const front = c.source === "prompt" && c.sourceInfo?.path ? frontMatter(readText(c.sourceInfo.path)) : undefined;
+        const hint = front && field(front, "argument-hint");
+        return hint ? { ...c, hint } : c;
+    });
+}

package/dist/screens.js

@@ -0,0 +1,425 @@
+/**
+ * The notes and library screens of the terminal look, as pi-tui components for `ctx.ui.custom()`. Each has a pure function that draws it as
+ * lines (snapshots at 40, 80 and 120 columns) and a class that holds the state and the keys. The notes screen has two columns from 100 columns
+ * up (the list, and the note under the cursor); below that it is a list, and Enter opens a note.
+ */
+import { matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { cut, evidenceLine, fill, rule } from "./chrome.js";
+import { frontMatter, field } from "./notes.js";
+import { UNICODE } from "./skin.js";
+export const SCREEN_WORDS = {
+    en: {
+        notes: "Notes", of: "of", filter: "filter", none: "No notes yet. Sub-Sub writes them in Literature/, Research/ and Syntheses/.", noMatch: "No note matches.", empty: "(empty note)",
+        hintNotes: "up and down: choose   type: filter   PgUp PgDn: scroll   ctrl+o: open   Esc: close", hintRead: "up and down: scroll   ctrl+o: open   Esc: back",
+        library: "Library", typeToSearch: "Type to search your library.", searching: "Searching...", noItems: "Nothing found.", failed: "The search failed",
+        hintLibrary: "up and down: choose   Enter: read   ctrl+n: note   Esc: close", hintLibrarian: "up and down: choose   Enter: copy the key   Esc: close",
+        hintChoice: "up and down: choose   Enter: select   type: filter   Esc: cancel", noChoice: "Nothing matches.", hintInput: "Enter: send   Esc: cancel",
+    },
+    pt: {
+        notes: "Notas", of: "de", filter: "filtro", none: "Ainda não há notas. O Sub-Sub escreve-as em Literature/, Research/ e Syntheses/.", noMatch: "Nenhuma nota corresponde.", empty: "(nota vazia)",
+        hintNotes: "cima e baixo: escolher   escrever: filtrar   PgUp PgDn: deslocar   ctrl+o: abrir   Esc: fechar", hintRead: "cima e baixo: deslocar   ctrl+o: abrir   Esc: voltar",
+        library: "Biblioteca", typeToSearch: "Escreva para pesquisar na biblioteca.", searching: "A pesquisar...", noItems: "Nada encontrado.", failed: "A pesquisa falhou",
+        hintLibrary: "cima e baixo: escolher   Enter: ler   ctrl+n: nota   Esc: fechar", hintLibrarian: "cima e baixo: escolher   Enter: copiar a chave   Esc: fechar",
+        hintChoice: "cima e baixo: escolher   Enter: selecionar   escrever: filtrar   Esc: cancelar", noChoice: "Nada corresponde.", hintInput: "Enter: enviar   Esc: cancelar",
+    },
+};
+const LEFT = 36;
+const WIDE = 100;
+function pad(s, width) {
+    return s + " ".repeat(Math.max(0, width - visibleWidth(s)));
+}
+/** A key that types text (a letter, a digit, a pasted string), not a control or escape sequence. */
+export function printable(data) {
+    return data.length > 0 && !/[\x00-\x1f\x7f]/.test(data);
+}
+export function notesLines(o) {
+    const g = o.glyphs ?? UNICODE;
+    const p = o.paint;
+    const w = Math.max(20, o.width);
+    const words = SCREEN_WORDS[o.lang];
+    const rows = Math.max(3, o.rows - 5);
+    const wide = w >= WIDE && o.mode === "list";
+    const count = o.entries.length === o.total ? `${o.total}` : `${o.entries.length} ${words.of} ${o.total}`;
+    const out = [p.mark(cut(` ${words.notes}`, w)) + p.muted(cut(` (${count})${o.filter ? `   ${words.filter}: ${o.filter}` : ""}`, Math.max(0, w - words.notes.length - 1))), rule(w, "solid", p.muted, g)];
+    let bodyMax = 0;
+    const hint = (text) => wrapTextWithAnsi(` ${text}`, w).map((l) => p.muted(l));
+    if (o.total === 0 || o.entries.length === 0) {
+        out.push(p.muted(cut(`  ${o.total === 0 ? words.none : words.noMatch}`, w)), rule(w, "solid", p.muted, g), ...hint(words.hintNotes));
+        return { lines: out, bodyMax };
+    }
+    const list = (width) => {
+        const start = Math.max(0, Math.min(o.selected - Math.floor(rows / 2), o.entries.length - rows));
+        return o.entries.slice(start, start + rows).map((rel, k) => {
+            const chosen = start + k === o.selected;
+            return chosen ? `${p.mark(g.pointer)} ${p.text(cut(rel, width - 2))}` : `  ${p.muted(cut(rel, width - 2))}`;
+        });
+    };
+    const body = (width) => {
+        const lines = o.renderBody(Math.max(10, width));
+        const head = o.evidence ? [evidenceLine(o.evidence, o.lang, width, p, g), ""] : [];
+        const room = Math.max(1, rows - head.length);
+        bodyMax = Math.max(0, lines.length - room);
+        const from = Math.min(o.bodyScroll, bodyMax);
+        const shown = lines.slice(from, from + room).map((l) => truncateToWidth(l, width));
+        return [...head, ...(shown.length ? shown : [p.dim(words.empty)])];
+    };
+    if (wide) {
+        const right = w - LEFT - 3;
+        const left = list(LEFT);
+        const detail = body(right);
+        for (let i = 0; i < rows; i++)
+            out.push(`${pad(left[i] ?? "", LEFT)} ${p.muted(g.vertical)} ${detail[i] ?? ""}`);
+        out.push(rule(w, "solid", p.muted, g), ...hint(words.hintNotes));
+    }
+    else if (o.mode === "list") {
+        out.push(...list(w), rule(w, "solid", p.muted, g), ...hint(words.hintNotes));
+    }
+    else {
+        out.push(...body(w), rule(w, "solid", p.muted, g), ...hint(words.hintRead));
+    }
+    return { lines: out, bodyMax };
+}
+export class NotesView {
+    o;
+    filter = "";
+    selected = 0;
+    mode = "list";
+    bodyScroll = 0;
+    bodyMax = 0;
+    lastWidth = 80;
+    texts = new Map();
+    constructor(o) {
+        this.o = o;
+    }
+    entries() {
+        const f = this.filter.toLowerCase();
+        return f ? this.o.notes.filter((n) => n.rel.toLowerCase().includes(f)) : this.o.notes;
+    }
+    text() {
+        const n = this.entries()[this.selected];
+        if (!n)
+            return "";
+        let t = this.texts.get(n.path);
+        if (t === undefined) {
+            try {
+                t = this.o.read(n.path);
+            }
+            catch {
+                t = "";
+            }
+            this.texts.set(n.path, t);
+        }
+        return t;
+    }
+    render(width) {
+        this.lastWidth = width;
+        const text = this.text();
+        const front = frontMatter(text);
+        const evidence = front ? field(front, "evidence") : undefined;
+        const body = front ? text.slice(text.indexOf("\n---", 3) + 4).replace(/^\r?\n/, "") : text;
+        const entries = this.entries();
+        const view = notesLines({
+            width, rows: this.height(), lang: this.o.lang, paint: this.o.paint, glyphs: this.o.glyphs, mode: this.mode, entries: entries.map((n) => n.rel), total: this.o.notes.length,
+            selected: this.selected, filter: this.filter, evidence, renderBody: (w) => this.o.markdown(body, w), bodyScroll: this.bodyScroll,
+        });
+        this.bodyMax = view.bodyMax;
+        this.bodyScroll = Math.min(this.bodyScroll, this.bodyMax);
+        return fill(view.lines, width, this.height());
+    }
+    /** The screen covers the terminal, but for one line. */
+    height() {
+        return Math.max(8, (this.o.rows?.() ?? 24) - 1);
+    }
+    invalidate() { }
+    move(by) {
+        const n = this.entries().length;
+        if (!n)
+            return;
+        this.selected = Math.min(n - 1, Math.max(0, this.selected + by));
+        this.bodyScroll = 0;
+    }
+    handleInput(data) {
+        const page = Math.max(3, this.height() - 6);
+        const wideList = this.lastWidth >= WIDE && this.mode === "list";
+        const scrolls = this.mode === "read" || wideList;
+        if (matchesKey(data, "ctrl+c"))
+            return this.o.done();
+        if (matchesKey(data, "escape")) {
+            if (this.mode === "read")
+                this.mode = "list";
+            else if (this.filter) {
+                this.filter = "";
+                this.selected = 0;
+            }
+            else
+                return this.o.done();
+        }
+        else if (matchesKey(data, "ctrl+o")) {
+            const n = this.entries()[this.selected];
+            if (n)
+                this.o.open(n.path);
+            return;
+        }
+        else if (matchesKey(data, "enter")) {
+            if (this.mode === "list" && !wideList && this.entries().length) {
+                this.mode = "read";
+                this.bodyScroll = 0;
+            }
+        }
+        else if (matchesKey(data, "up")) {
+            if (this.mode === "read")
+                this.bodyScroll = Math.max(0, this.bodyScroll - 1);
+            else
+                this.move(-1);
+        }
+        else if (matchesKey(data, "down")) {
+            if (this.mode === "read")
+                this.bodyScroll = Math.min(this.bodyMax, this.bodyScroll + 1);
+            else
+                this.move(1);
+        }
+        else if (matchesKey(data, "pageUp")) {
+            if (scrolls)
+                this.bodyScroll = Math.max(0, this.bodyScroll - page);
+            else
+                this.move(-page);
+        }
+        else if (matchesKey(data, "pageDown")) {
+            if (scrolls)
+                this.bodyScroll = Math.min(this.bodyMax, this.bodyScroll + page);
+            else
+                this.move(page);
+        }
+        else if (this.mode === "list" && matchesKey(data, "backspace")) {
+            this.filter = this.filter.slice(0, -1);
+            this.selected = 0;
+        }
+        else if (this.mode === "list" && printable(data)) {
+            this.filter += data;
+            this.selected = 0;
+            this.bodyScroll = 0;
+        }
+        else
+            return;
+        this.o.redraw?.();
+    }
+}
+export function libraryLines(o) {
+    const g = o.glyphs ?? UNICODE;
+    const p = o.paint;
+    const w = Math.max(20, o.width);
+    const words = SCREEN_WORDS[o.lang];
+    const room = Math.max(2, o.rows - 5);
+    const out = [p.mark(cut(` ${words.library}`, w)), `${p.muted(" > ")}${p.text(cut(o.query, w - 4))}${p.mark("_")}`, rule(w, "solid", p.muted, g)];
+    if (o.state === "idle" && !o.query)
+        out.push(p.muted(cut(`  ${words.typeToSearch}`, w)));
+    else if (o.state === "searching")
+        out.push(p.muted(cut(`  ${words.searching}`, w)));
+    else if (o.state === "failed")
+        out.push(p.text(cut(`  ${g.hollow} ${words.failed}${o.error ? `: ${o.error.split("\n")[0]}` : ""}`, w)));
+    else if (!o.items.length)
+        out.push(p.muted(cut(`  ${words.noItems}`, w)));
+    else {
+        const per = 2;
+        const fit = Math.max(1, Math.floor(room / per));
+        const start = Math.max(0, Math.min(o.selected - Math.floor(fit / 2), o.items.length - fit));
+        for (const [k, it] of o.items.slice(start, start + fit).entries()) {
+            const chosen = start + k === o.selected;
+            const meta = [it.authors, it.year, it.citekey].filter(Boolean).join(" · ");
+            out.push(chosen ? `${p.mark(g.pointer)} ${p.text(cut(it.title || it.key, w - 2))}` : `  ${p.muted(cut(it.title || it.key, w - 2))}`, `  ${p.dim(cut(meta, w - 2))}`);
+        }
+    }
+    out.push(rule(w, "solid", p.muted, g), ...wrapTextWithAnsi(` ${o.researcher ? words.hintLibrary : words.hintLibrarian}`, w).map((l) => p.muted(l)));
+    return out;
+}
+export class LibraryView {
+    o;
+    query = "";
+    items = [];
+    selected = 0;
+    state = "idle";
+    error;
+    timer;
+    seq = 0;
+    constructor(o) {
+        this.o = o;
+    }
+    render(width) {
+        const height = Math.max(8, (this.o.rows?.() ?? 24) - 1);
+        return fill(libraryLines({
+            width, rows: height, lang: this.o.lang, paint: this.o.paint, glyphs: this.o.glyphs, researcher: this.o.researcher,
+            query: this.query, items: this.items, selected: this.selected, state: this.state, error: this.error,
+        }), width, height);
+    }
+    invalidate() { }
+    dispose() {
+        clearTimeout(this.timer);
+    }
+    schedule() {
+        clearTimeout(this.timer);
+        const q = this.query.replace(/\s+/g, " ").trim();
+        const mine = ++this.seq;
+        if (!q) {
+            this.items = [];
+            this.state = "idle";
+            return;
+        }
+        this.state = "searching";
+        this.timer = setTimeout(async () => {
+            try {
+                const items = await this.o.search(q);
+                if (mine !== this.seq)
+                    return; // a newer search is on its way
+                this.items = items;
+                this.state = "done";
+                this.selected = 0;
+            }
+            catch (err) {
+                if (mine !== this.seq)
+                    return;
+                this.state = "failed";
+                this.error = err.message;
+            }
+            this.o.redraw?.();
+        }, this.o.delay ?? 250);
+    }
+    handleInput(data) {
+        if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c"))
+            return this.o.done();
+        const item = this.items[this.selected];
+        if (matchesKey(data, "enter")) {
+            if (item)
+                this.o.choose(item);
+            return;
+        }
+        if (matchesKey(data, "ctrl+n")) {
+            if (item && this.o.researcher)
+                this.o.note(item);
+            return;
+        }
+        if (matchesKey(data, "up"))
+            this.selected = Math.max(0, this.selected - 1);
+        else if (matchesKey(data, "down"))
+            this.selected = Math.min(Math.max(0, this.items.length - 1), this.selected + 1);
+        else if (matchesKey(data, "backspace")) {
+            this.query = this.query.slice(0, -1);
+            this.schedule();
+        }
+        else if (printable(data)) {
+            this.query += data;
+            this.schedule();
+        }
+        else
+            return;
+        this.o.redraw?.();
+    }
+}
+export function choiceLines(o) {
+    const g = o.glyphs ?? UNICODE;
+    const p = o.paint;
+    const w = Math.max(20, o.width);
+    const words = SCREEN_WORDS[o.lang];
+    const room = Math.max(1, o.rows - 4);
+    const out = [p.mark(cut(` ${o.title}`, w)) + (o.filter ? p.muted(cut(`   ${words.filter}: ${o.filter}`, Math.max(0, w - o.title.length - 1))) : ""), rule(w, "solid", p.muted, g)];
+    if (!o.choices.length)
+        out.push(p.muted(cut(`  ${words.noChoice}`, w)));
+    const start = Math.max(0, Math.min(o.selected - Math.floor(room / 2), o.choices.length - room));
+    for (const [k, c] of o.choices.slice(start, start + room).entries()) {
+        const chosen = start + k === o.selected;
+        const hint = c.hint ? `  ${c.hint}` : "";
+        const label = cut(c.label, Math.max(8, w - 2 - hint.length));
+        out.push(`${chosen ? p.mark(g.pointer) : " "} ${chosen ? p.text(label) : p.muted(label)}${p.dim(cut(hint, Math.max(0, w - 2 - label.length)))}`);
+    }
+    out.push(rule(w, "solid", p.muted, g), ...wrapTextWithAnsi(` ${words.hintChoice}`, w).map((l) => p.muted(l)));
+    return out;
+}
+export class ChoiceView {
+    o;
+    filter = "";
+    selected = 0;
+    answered = false;
+    constructor(o) {
+        this.o = o;
+    }
+    shown() {
+        const f = this.filter.toLowerCase();
+        return f ? this.o.choices.filter((c) => `${c.label} ${c.hint ?? ""}`.toLowerCase().includes(f)) : this.o.choices;
+    }
+    render(width) {
+        const rows = Math.max(8, Math.floor(((this.o.rows?.() ?? 24) * 8) / 10));
+        return fill(choiceLines({ title: this.o.title, choices: this.shown(), selected: this.selected, filter: this.filter, width, rows, lang: this.o.lang, paint: this.o.paint, glyphs: this.o.glyphs }), width);
+    }
+    invalidate() { }
+    handleInput(data) {
+        if (this.answered)
+            return;
+        const list = this.shown();
+        if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+            this.answered = true;
+            return this.o.cancel();
+        }
+        if (matchesKey(data, "enter")) {
+            const c = list[this.selected];
+            if (!c)
+                return;
+            this.answered = true;
+            return this.o.choose(c.value);
+        }
+        if (matchesKey(data, "up"))
+            this.selected = Math.max(0, this.selected - 1);
+        else if (matchesKey(data, "down"))
+            this.selected = Math.min(Math.max(0, list.length - 1), this.selected + 1);
+        else if (matchesKey(data, "backspace")) {
+            this.filter = this.filter.slice(0, -1);
+            this.selected = 0;
+        }
+        else if (printable(data)) {
+            this.filter += data;
+            this.selected = 0;
+        }
+        else
+            return;
+        this.o.redraw?.();
+    }
+}
+export function inputLines(o) {
+    const g = o.glyphs ?? UNICODE;
+    const p = o.paint;
+    const w = Math.max(20, o.width);
+    const shown = o.text ? p.text(cut(o.text, w - 5)) + p.mark("_") : p.dim(cut(o.placeholder ?? "", w - 5)) + p.mark("_");
+    return [p.mark(cut(` ${o.title}`, w)), rule(w, "solid", p.muted, g), ` ${p.muted(">")} ${shown}`, rule(w, "solid", p.muted, g), p.muted(cut(` ${SCREEN_WORDS[o.lang].hintInput}`, w))];
+}
+export class InputView {
+    o;
+    text;
+    answered = false;
+    constructor(o) {
+        this.o = o;
+        this.text = o.prefill ?? "";
+    }
+    render(width) {
+        return fill(inputLines({ title: this.o.title, placeholder: this.o.placeholder, text: this.text, width, lang: this.o.lang, paint: this.o.paint, glyphs: this.o.glyphs }), width);
+    }
+    invalidate() { }
+    handleInput(data) {
+        if (this.answered)
+            return;
+        if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+            this.answered = true;
+            return this.o.cancel();
+        }
+        if (matchesKey(data, "enter")) {
+            this.answered = true;
+            return this.o.submit(this.text);
+        }
+        if (matchesKey(data, "backspace"))
+            this.text = this.text.slice(0, -1);
+        else if (matchesKey(data, "ctrl+u"))
+            this.text = "";
+        else if (printable(data))
+            this.text += data;
+        else
+            return;
+        this.o.redraw?.();
+    }
+}

package/dist/skin.js

@@ -0,0 +1,37 @@
+/**
+ * The skin of the terminal screens: the paint roles drawn from a pi theme, and the glyphs. Meaning is never carried by
+ * colour alone: a rule is solid, dashed or dotted, a failure has a hollow mark and a word, and a terminal that cannot show
+ * the box-drawing glyphs (a non-UTF-8 locale, or SUBSUB_ASCII=1) gets plain ASCII.
+ */
+export const UNICODE = { solid: "─", dashed: "┄", dotted: "┈", hollow: "○", cell: "▰", cellEmpty: "▱", vertical: "│", pointer: "›" };
+export const ASCII = { solid: "=", dashed: "-", dotted: ".", hollow: "o", cell: "#", cellEmpty: "-", vertical: "|", pointer: ">" };
+/** ASCII when SUBSUB_ASCII is set, or when the locale is C, POSIX or names a character set that is not UTF-8 (pt_PT.ISO-8859-1). No locale, or one without a character set, means UTF-8. */
+export function useAscii(env = process.env) {
+    if (env.SUBSUB_ASCII && env.SUBSUB_ASCII !== "0")
+        return true;
+    const locale = env.LC_ALL || env.LC_CTYPE || env.LANG;
+    if (!locale || /utf-?8/i.test(locale))
+        return false;
+    return locale === "C" || locale === "POSIX" || /\.[^.]+$/.test(locale);
+}
+export function glyphs(env = process.env) {
+    return useAscii(env) ? ASCII : UNICODE;
+}
+/** Paint roles from the colours of a pi theme (themes/*.json): accent, text, muted, dim, success (sap) and warning (gamboge). */
+export function paintFromTheme(th) {
+    return {
+        mark: (x) => th.fg("accent", x),
+        text: (x) => th.fg("text", x),
+        muted: (x) => th.fg("muted", x),
+        dim: (x) => th.fg("dim", x),
+        ok: (x) => th.fg("success", x),
+        pend: (x) => th.fg("warning", x),
+        // A removal has no colour of its own: muted ink, struck through, and the "-" in front stays for terminals that ignore the strike.
+        strike: (x) => (th.strikethrough ? th.strikethrough(th.fg("muted", x)) : th.fg("muted", x)),
+    };
+}
+/** Frames of the working indicator: dotted, dashed, solid, dashed. One static frame when motion is reduced (SUBSUB_REDUCE_MOTION=1). */
+export function workingFrames(g, reduceMotion = false) {
+    const dashed = g.dashed.repeat(4);
+    return reduceMotion ? [dashed] : [g.dotted.repeat(4), dashed, g.solid.repeat(4), dashed];
+}