oakode 0.0.0-stage → 0.5.0

package/dist/tui/screen.js

@@ -0,0 +1,146 @@
+/**
+ * The ONLY writer to the interactive terminal.
+ *
+ * Output has two parts: finished lines ("committed") that go to the terminal's scrollback and are never touched again,
+ * and a small "live frame" at the bottom (streaming block, spinner, editor, menus) that is erased and redrawn in place.
+ * Every update is one write wrapped in synchronized-output markers, so nothing flickers and components cannot interleave.
+ */
+import { truncate, width } from "../ui.js";
+const BSU = "\x1b[?2026h", ESU = "\x1b[?2026l", HIDE = "\x1b[?25l", SHOW = "\x1b[?25h";
+export class Screen {
+    out;
+    pending = [];
+    frame = null;
+    drawn = null; // what is on screen right now
+    liveRows = 0;
+    cursorRow = 0;
+    timer;
+    disposed = false;
+    onResize;
+    resizeTimer;
+    resizeHandler = () => {
+        // The terminal has already re-wrapped the old frame: recount its rows now, or a redraw before the debounce fires
+        // (a spinner tick) erases too few rows and leaves its top lines behind, once per resize step.
+        this.reflow();
+        clearTimeout(this.resizeTimer);
+        this.resizeTimer = setTimeout(() => {
+            this.onResize?.();
+            this.flush();
+        }, 25);
+    };
+    constructor(out) {
+        this.out = out;
+        out.on?.("resize", this.resizeHandler);
+    }
+    get cols() {
+        return Math.max(20, this.out.columns || 80);
+    }
+    /** Rows the live frame may use (always leaves one row of scrollback visible). */
+    get maxLive() {
+        return Math.max(4, (this.out.rows || 24) - 1);
+    }
+    commit(lines) {
+        if (lines.length)
+            this.pending.push(...lines);
+        this.schedule();
+    }
+    setFrame(f) {
+        this.frame = f;
+        this.schedule();
+    }
+    schedule() {
+        if (this.disposed || this.timer)
+            return;
+        this.timer = setTimeout(() => this.flush(), 12);
+    }
+    /** Draw now (used before blocking, on exit, and by tests). */
+    flush() {
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        if (this.disposed)
+            return;
+        const cols = this.cols;
+        let buf = BSU + HIDE;
+        // 1. erase the live frame (cursor is on `cursorRow` of it)
+        if (this.liveRows > 0) {
+            if (this.cursorRow > 0)
+                buf += `\x1b[${this.cursorRow}A`;
+            buf += "\r\x1b[J";
+        }
+        else
+            buf += "\r";
+        // 2. finished lines go above the live frame
+        // finished lines are not cut at the width: they scroll away, and the terminal soft-wraps them, so a long URL or code
+        // line can still be clicked or copied whole (only the live frame below must fit, to be redrawn in place)
+        for (const l of this.pending)
+            buf += l + "\r\n";
+        this.pending = [];
+        // 3. redraw the live frame
+        const f = this.frame;
+        if (f && f.lines.length) {
+            let lines = f.lines;
+            let cursor = f.cursor;
+            const max = this.maxLive;
+            if (lines.length > max) {
+                const cut = lines.length - max;
+                lines = lines.slice(cut);
+                if (cursor)
+                    cursor = { row: Math.max(0, cursor.row - cut), col: cursor.col };
+            }
+            buf += lines.map((l) => this.fit(l, cols)).join("\r\n");
+            this.liveRows = lines.length;
+            if (cursor) {
+                const up = lines.length - 1 - Math.min(cursor.row, lines.length - 1);
+                if (up > 0)
+                    buf += `\x1b[${up}A`;
+                buf += `\x1b[${Math.min(cursor.col, cols - 1) + 1}G`;
+                this.cursorRow = Math.min(cursor.row, lines.length - 1);
+            }
+            else
+                this.cursorRow = lines.length - 1;
+            this.drawn = { lines, cursor };
+            buf += cursor ? SHOW : "";
+        }
+        else {
+            this.liveRows = 0;
+            this.cursorRow = 0;
+            this.drawn = null;
+            buf += SHOW;
+        }
+        buf += ESU;
+        this.out.write(buf);
+    }
+    fit(line, cols) {
+        return width(line) > cols ? truncate(line, cols) : line;
+    }
+    /** After a resize, the terminal may have re-wrapped the old frame: work out how many rows it occupies now. */
+    reflow() {
+        const d = this.drawn;
+        if (!d)
+            return;
+        const cols = this.cols;
+        const rows = (l) => Math.max(1, Math.ceil(width(l) / cols));
+        const cr = Math.min(d.cursor?.row ?? d.lines.length - 1, d.lines.length - 1);
+        this.liveRows = d.lines.reduce((n, l) => n + rows(l), 0);
+        this.cursorRow = d.lines.slice(0, cr).reduce((n, l) => n + rows(l), 0) + (d.cursor ? Math.floor(d.cursor.col / cols) : 0);
+    }
+    /** Clear the visible screen (not the scrollback) and forget the old frame. */
+    clear() {
+        this.pending = [];
+        this.liveRows = 0;
+        this.cursorRow = 0;
+        this.drawn = null;
+        this.out.write("\x1b[2J\x1b[H");
+    }
+    /** Erase the live frame and give the terminal back. */
+    dispose() {
+        if (this.disposed)
+            return;
+        this.frame = null;
+        this.flush();
+        this.disposed = true;
+        clearTimeout(this.resizeTimer);
+        this.out.off?.("resize", this.resizeHandler);
+        this.out.write(SHOW);
+    }
+}

package/dist/tui/tui.js

@@ -0,0 +1,505 @@
+/**
+ * Interactive terminal controller: raw keyboard input in, one `Screen` out.
+ *
+ * The live frame (bottom of the terminal) is composed here from, top to bottom:
+ *   live provider (streaming answer, running tools, spinner)  ·  rule  ·  editor or menu  ·  completions  ·  footer.
+ * Everything finished is committed to scrollback via `print`. Typing while the agent works queues messages.
+ */
+import { KeyParser, armWatchdog } from "../input.js";
+import { bold, cyan, dim, gray, truncate, width, yellow } from "../ui.js";
+import { Editor } from "./editor.js";
+import { Screen } from "./screen.js";
+const PROMPT = "› ";
+const MENU_GUARD_MS = 400;
+/** Terminals that show OSC 9 as a desktop notification (inside tmux the outer terminal is unknown: BEL). */
+const osc9 = (env = process.env) => !env.TMUX && ["iTerm.app", "WezTerm", "ghostty"].includes(env.TERM_PROGRAM ?? "");
+export class Tui {
+    screen;
+    /** Called when the user asks to interrupt (Esc / Ctrl+C while busy). */
+    onAbort;
+    /** Lines for the area above the input (stream, tools, spinner). Receives the usable width and row budget. */
+    live = () => [];
+    footer = () => "";
+    completer;
+    /** Shift+Tab at the prompt (also while the agent works). */
+    onShiftTab;
+    /** A /command typed while busy: return true if it was handled now (e.g. /agents); otherwise it is queued. */
+    onBusyCommand;
+    /** The search text of the menu that was shown last (valid after chooseFrom resolves). */
+    menuQuery = "";
+    watchdog = false;
+    /** Messages typed (and sent with Enter) while the agent was busy. */
+    queue = [];
+    inp;
+    out;
+    parser = new KeyParser();
+    editor = new Editor();
+    started = false;
+    firstChunk = true;
+    escTimer;
+    busy = false;
+    reading;
+    lastCtrlC = 0;
+    notice = "";
+    noticeTimer;
+    popup = null;
+    popupSel = 0;
+    // menu state
+    menu;
+    lastKeyAt = 0;
+    paintTimer;
+    constructor(inp, out) {
+        this.inp = inp;
+        this.out = out;
+        this.screen = new Screen(out);
+        this.screen.onResize = () => this.invalidate();
+    }
+    // ------------------------------------------------------------------ lifecycle
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.firstChunk = true;
+        this.inp.setEncoding("utf8");
+        this.inp.setRawMode(true);
+        this.inp.resume();
+        this.out.write("\x1b[?2004h\x1b[?1004h"); // bracketed paste on; focus reporting on (for notify)
+        this.inp.on("data", this.onData);
+        this.inp.on("end", this.onEnd);
+        this.invalidate();
+    }
+    /** Always safe to call (signal handlers, exit). Callers settle commands and session data BEFORE this point. */
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        clearTimeout(this.escTimer);
+        clearTimeout(this.noticeTimer);
+        clearTimeout(this.paintTimer);
+        this.paintTimer = undefined;
+        this.inp.off("data", this.onData);
+        this.inp.off("end", this.onEnd);
+        try {
+            this.screen.dispose();
+        }
+        catch { }
+        // setRawMode(false) blocks if the terminal stopped reading; the watchdog (real terminal only) guarantees we can exit.
+        if (this.inp === process.stdin)
+            this.watchdog = armWatchdog(process.pid);
+        try {
+            this.out.write("\x1b[?2004l\x1b[?1004l");
+            this.inp.setRawMode(false);
+        }
+        catch { }
+        this.inp.pause();
+    }
+    onEnd = () => {
+        this.reading?.(null);
+        this.menu?.resolve(-1);
+    };
+    // ------------------------------------------------------------------ output
+    print(lines) {
+        this.screen.commit(lines);
+    }
+    /** Repaint at most once per frame: a fast stream sends many events per frame, and each paint re-renders the answer. */
+    invalidate() {
+        if (!this.started || this.paintTimer)
+            return;
+        this.paintTimer = setTimeout(() => this.flush(), 12);
+    }
+    flush() {
+        clearTimeout(this.paintTimer);
+        this.paintTimer = undefined;
+        this.paint();
+        this.screen.flush();
+    }
+    setBusy(b) {
+        this.busy = b;
+        this.invalidate();
+    }
+    flash(msg, ms = 2000) {
+        this.notice = msg;
+        clearTimeout(this.noticeTimer);
+        this.noticeTimer = setTimeout(() => {
+            this.notice = "";
+            this.invalidate();
+        }, ms);
+        this.invalidate();
+    }
+    paint() {
+        if (!this.started)
+            return;
+        const cols = this.screen.cols;
+        const max = this.screen.maxLive;
+        const lower = [];
+        let cursor;
+        const rule = gray("─".repeat(Math.min(cols, 200)));
+        if (this.menu) {
+            lower.push(rule, ...this.menuLines(cols));
+        }
+        else {
+            const view = this.editor.render(cols, this.busy ? dim(PROMPT) : bold(cyan(PROMPT)), width(PROMPT));
+            lower.push(...this.queueLines(cols));
+            lower.push(rule);
+            cursor = { row: lower.length + view.cursor.row, col: view.cursor.col };
+            lower.push(...view.lines);
+            if (this.popup && this.popup.items.length)
+                lower.push(...this.popupLines(cols));
+        }
+        const foot = this.notice ? yellow(this.notice) : this.footer();
+        if (foot)
+            lower.push(truncate(foot, cols));
+        const upperBudget = Math.max(0, max - lower.length);
+        const upper = this.live(cols, upperBudget).slice(-upperBudget || undefined);
+        const lines = upperBudget === 0 ? lower : [...upper, ...lower];
+        if (cursor)
+            cursor = { row: cursor.row + (upperBudget === 0 ? 0 : upper.length), col: cursor.col };
+        this.screen.setFrame({ lines, cursor });
+    }
+    /** Queued messages, waiting for the agent's next step: the last ones, and how to take one back. */
+    queueLines(cols) {
+        if (!this.queue.length)
+            return [];
+        const shown = this.queue.slice(-3);
+        const out = shown.map((m, i) => {
+            const first = m.trim().split("\n")[0];
+            const when = m.startsWith("/") ? " (runs after this turn)" : "";
+            return truncate(dim(`⏎ queued ${this.queue.length - shown.length + i + 1}: `) + first + dim(when), cols);
+        });
+        if (this.queue.length > shown.length)
+            out.unshift(dim(`⏎ ${this.queue.length - shown.length} more queued`));
+        out.push(truncate(dim("  Alt+↑ edits or withdraws the last · sent after this step"), cols));
+        return out;
+    }
+    /** Alt+Up: the last queued message back into the editor (before any draft), to edit and queue again, or delete. */
+    unqueue() {
+        let at = -1;
+        for (let i = this.queue.length - 1; i >= 0; i--)
+            if (!this.queue[i].startsWith("/")) {
+                at = i;
+                break;
+            }
+        const last = at >= 0 ? this.queue.splice(at, 1)[0] : undefined;
+        if (last === undefined)
+            return;
+        const draft = this.editor.text();
+        this.editor.reset(draft.trim() ? `${last}\n${draft}` : last);
+        this.invalidate();
+    }
+    popupLines(cols) {
+        const p = this.popup;
+        const rows = 8;
+        const start = Math.min(Math.max(0, this.popupSel - rows + 1), Math.max(0, p.items.length - rows));
+        const vis = p.items.slice(start, start + rows);
+        const w = Math.max(...vis.map((i) => width(i.value)));
+        const out = vis.map((it, i) => {
+            const on = start + i === this.popupSel;
+            const line = ` ${on ? "❯" : " "} ${it.value}${" ".repeat(w - width(it.value))}${it.desc ? "  " + it.desc : ""}`;
+            return truncate(on ? bold(cyan(line)) : dim(line), cols);
+        });
+        if (p.items.length > rows)
+            out.push(dim(`   (${this.popupSel + 1}/${p.items.length})`));
+        return out;
+    }
+    menuLines(cols) {
+        const m = this.menu;
+        const opts = m.spec.options(m.query);
+        const out = [];
+        if (m.spec.title)
+            out.push(bold(m.spec.title));
+        for (const l of typeof m.spec.lines === "function" ? m.spec.lines() : (m.spec.lines ?? []))
+            out.push(truncate(l, cols));
+        if (m.spec.search)
+            out.push(truncate(`${dim("Search:")} ${m.query}${cyan("▏")}${opts.length === 0 ? dim("  (no matches)") : ""}`, cols));
+        const rows = 12;
+        const start = Math.min(Math.max(0, m.sel - 5), Math.max(0, opts.length - rows));
+        if (start > 0)
+            out.push(dim(`   ↑ ${start} more`));
+        opts.slice(start, start + rows).forEach((o, k) => {
+            const i = start + k;
+            const line = ` ${i === m.sel ? "❯" : " "} ${i + 1}. ${o.label}${o.hint ? "  " + dim(o.hint) : ""}`;
+            out.push(truncate(i === m.sel ? bold(cyan(line)) : line, cols));
+        });
+        if (start + rows < opts.length)
+            out.push(dim(`   ↓ ${opts.length - start - rows} more`));
+        out.push(dim(m.spec.hint ?? "↑/↓ choose · Enter confirm · Esc cancel"));
+        return out;
+    }
+    // ------------------------------------------------------------------ input
+    /** From focus reports; undefined until the terminal sends one (then OAKODE never notifies). */
+    focused;
+    /** Desktop notifications (config `"notifications": false` turns them off). */
+    notifications = true;
+    notifiedAt = 0;
+    /**
+     * Tells the person something is waiting for them, but only when the terminal said it lost focus: OSC 9 (a desktop
+     * notification) where the terminal supports it, else BEL (which most terminals turn into an alert when unfocused).
+     * At most one every 5 s.
+     */
+    notify(message) {
+        if (this.focused !== false || !this.notifications || Date.now() - this.notifiedAt < 5000)
+            return;
+        this.notifiedAt = Date.now();
+        const text = [...message.replace(/[\p{Cc}\p{Cf}\u2028\u2029]/gu, " ").replace(/\s+/g, " ").trim()].slice(0, 80).join("");
+        this.out.write(osc9() ? `\x1b]9;${text}\x07` : "\x07");
+    }
+    /** Whether the last submitted message began with a typed (not pasted) character. */
+    submittedTyped = false;
+    /** Edit a message. While busy, Enter queues it instead; resolves with the text on Enter when idle (null: Ctrl+D / EOF). */
+    readMessage(opts = {}) {
+        this.editor.multiline = opts.multiline ?? true;
+        if (opts.prefill !== undefined)
+            this.editor.reset(opts.prefill);
+        this.busy = false;
+        this.refreshPopup();
+        this.invalidate();
+        return new Promise((resolve) => (this.reading = resolve));
+    }
+    /** Queued messages, removed from the queue. `messagesOnly`: leave /commands queued (they are for OAKODE, not the model; they come back to the editor after the turn). */
+    /** The unsent text in the editor (kept aside while the editor is used for something else, then put back). */
+    get draft() {
+        return this.editor.text();
+    }
+    set draft(text) {
+        this.editor.reset(text);
+        this.invalidate();
+    }
+    takeQueued(messagesOnly = false) {
+        const keep = (m) => messagesOnly && m.startsWith("/");
+        const q = this.queue.filter((m) => !keep(m));
+        this.queue = this.queue.filter(keep);
+        if (q.length)
+            this.invalidate(); // no longer shown as queued
+        return q;
+    }
+    /** Text typed but not sent (queued messages + the unfinished line), to put back in the editor. */
+    leftover() {
+        const parts = [...this.queue, this.editor.text()].filter((x) => x.trim());
+        this.queue = [];
+        this.editor.reset("");
+        return parts.join("\n\n");
+    }
+    /** Show a selection menu in place of the editor. Resolves with the chosen index, or -1 for Esc / end of input. */
+    chooseFrom(spec) {
+        return new Promise((resolve) => {
+            this.popup = null;
+            this.menu = { spec, sel: spec.initial ?? 0, shownAt: Date.now(), armed: !!spec.search, query: "", resolve: (i) => { if (this.menu)
+                    this.menuQuery = this.menu.query; this.menu = undefined; this.invalidate(); resolve(i); } };
+            this.invalidate();
+        });
+    }
+    /** Dismiss an open menu as if Esc was pressed (e.g. the turn was aborted from outside). */
+    cancelMenu() {
+        this.menu?.resolve(-1);
+    }
+    /** Clear the visible screen (scrollback is kept). */
+    clearScreen() {
+        this.screen.clear();
+        this.invalidate();
+    }
+    onData = (d) => {
+        clearTimeout(this.escTimer);
+        // Anything typed before raw mode was line-buffered by the kernel, which turned Enter (CR) into LF (our Ctrl+J).
+        if (this.firstChunk) {
+            this.firstChunk = false;
+            d = d.replace(/\n/g, "\r");
+        }
+        for (const key of this.parser.feed(d))
+            this.onKey(key);
+        this.escTimer = setTimeout(() => {
+            for (const key of this.parser.flushPending())
+                this.onKey(key);
+        }, 40);
+    };
+    onKey(key) {
+        if (key.k === "focusin" || key.k === "focusout")
+            return void (this.focused = key.k === "focusin");
+        const now = Date.now();
+        const sinceLast = now - this.lastKeyAt;
+        this.lastKeyAt = now;
+        if (this.menu)
+            return this.menuKey(key, sinceLast);
+        this.editKey(key);
+    }
+    menuKey(key, sinceLast) {
+        const m = this.menu;
+        // Keys that were already in flight when the menu appeared, or part of a typing burst, can never choose anything.
+        // The menu "arms" on the first key that follows a pause; from then on it responds at normal speed.
+        if (key.k === "text")
+            m.spec.onChar?.(key.s);
+        if (m.spec.search) {
+            if (key.k === "text" || key.k === "paste") {
+                m.query += (key.k === "text" ? key.s : key.s).replace(/[\r\n]+/g, " ").slice(0, 200);
+                m.sel = 0;
+                return this.invalidate();
+            }
+            if (key.k === "backspace") {
+                m.query = [...m.query].slice(0, -1).join("");
+                m.sel = 0;
+                return this.invalidate();
+            }
+            if (key.k === "ctrl" && key.c === "u") {
+                m.query = "";
+                m.sel = 0;
+                return this.invalidate();
+            }
+        }
+        if (!m.armed) {
+            if (key.k === "text" || key.k === "paste")
+                return; // typing never arms a menu
+            if (Date.now() - m.shownAt < MENU_GUARD_MS || sinceLast < MENU_GUARD_MS)
+                return;
+            m.armed = true;
+        }
+        const n = Math.max(1, m.spec.options(m.query).length);
+        if (m.spec.onKey?.(key, m.sel))
+            return this.invalidate();
+        switch (key.k) {
+            case "up":
+                m.sel = (m.sel + n - 1) % n;
+                break;
+            case "down":
+                m.sel = (m.sel + 1) % n;
+                break;
+            case "tab":
+                m.spec.onTab?.();
+                break;
+            case "enter": return m.spec.options(m.query).length ? m.resolve(m.sel) : undefined;
+            case "escape": return m.resolve(-1);
+            case "ctrl":
+                if (key.c === "c") {
+                    m.resolve(-1);
+                    this.onAbort?.();
+                    return;
+                }
+                break;
+            default: return; // text and paste are ignored
+        }
+        this.invalidate();
+    }
+    refreshPopup() {
+        const r = this.completer?.(this.editor.beforeCursor()) ?? null;
+        this.popup = r && r.items.length ? r : null;
+        this.popupSel = Math.min(this.popupSel, Math.max(0, (this.popup?.items.length ?? 1) - 1));
+    }
+    acceptCompletion() {
+        const p = this.popup;
+        if (!p)
+            return false;
+        const it = p.items[this.popupSel];
+        if (!it)
+            return false;
+        this.editor.replaceBeforeCursor(p.from, it.value + (it.space ? " " : ""));
+        this.popupSel = 0;
+        this.refreshPopup();
+        return true;
+    }
+    editKey(key) {
+        switch (key.k) {
+            case "escape":
+                if (this.popup)
+                    this.popup = null;
+                else if (this.busy)
+                    this.onAbort?.();
+                this.invalidate();
+                return;
+            case "tab":
+                if (!this.popup)
+                    this.refreshPopup();
+                this.acceptCompletion();
+                this.invalidate();
+                return;
+            case "shifttab":
+                this.onShiftTab?.();
+                this.invalidate();
+                return;
+            case "altup":
+                // takes back a queued message while the agent works; otherwise it is just Up
+                if (this.busy && this.queue.some((m) => !m.startsWith("/")))
+                    return this.unqueue();
+                key = { k: "up" };
+                break;
+            case "ctrl":
+                if (key.c === "c") {
+                    if (this.busy)
+                        return void this.onAbort?.();
+                    if (this.popup)
+                        this.popup = null;
+                    else if (!this.editor.empty) {
+                        // a cleared draft stays reachable with Up, as if it had been sent
+                        this.editor.remember(this.editor.text());
+                        this.editor.reset("");
+                        this.flash("Cleared (Up brings it back)");
+                    }
+                    else if (Date.now() - this.lastCtrlC < 2000)
+                        return void this.reading?.(null);
+                    else {
+                        this.lastCtrlC = Date.now();
+                        this.flash("Press Ctrl+C again (or Ctrl+D) to exit");
+                    }
+                    this.invalidate();
+                    return;
+                }
+                if (key.c === "d") {
+                    if (this.editor.empty && !this.busy)
+                        return void this.reading?.(null);
+                    if (!this.editor.empty)
+                        this.editor.handle({ k: "delete" });
+                    this.refreshPopup();
+                    this.invalidate();
+                    return;
+                }
+                if (key.c === "l")
+                    return void this.invalidate();
+                break;
+            case "up":
+            case "down":
+                if (this.popup && !this.editor.multiLine) {
+                    const n = this.popup.items.length;
+                    this.popupSel = (this.popupSel + (key.k === "up" ? n - 1 : 1)) % n;
+                    this.invalidate();
+                    return;
+                }
+                break;
+            case "enter": {
+                // A partially typed command NAME completes instead of sending (arguments complete with Tab; Enter sends them as typed).
+                if (this.popup && this.popup.from === 0 && this.popup.items[this.popupSel] && this.editor.beforeCursor().slice(this.popup.from) !== this.popup.items[this.popupSel].value) {
+                    this.acceptCompletion();
+                    this.invalidate();
+                    return;
+                }
+                break;
+            }
+            default: break;
+        }
+        const r = this.editor.handle(key);
+        if (r === "submit") {
+            const text = this.editor.text();
+            const typed = this.editor.startTyped;
+            this.editor.remember(text);
+            this.editor.reset("");
+            this.popup = null;
+            if (this.busy) {
+                const m = text.trim();
+                if (m && text.startsWith("/") && this.onBusyCommand?.(m)) {
+                    this.invalidate();
+                    return;
+                }
+                // shown above the editor until it is delivered (then it is printed as sent) or taken back with Alt+Up
+                if (m)
+                    this.queue.push(text.trimEnd()); // a leading space keeps "/path" a message, not a command (as in App.run)
+            }
+            else {
+                const resolve = this.reading;
+                this.reading = undefined;
+                this.submittedTyped = typed;
+                resolve?.(text);
+            }
+            this.invalidate();
+            return;
+        }
+        if (r === "edited")
+            this.refreshPopup();
+        this.invalidate();
+    }
+}