agent-sh 0.8.0 → 0.9.0

package/dist/utils/line-editor.js

@@ -2,22 +2,93 @@
  * Minimal line editor with readline-style keybindings.
  *
  * Pure logic — no I/O, no rendering, no event bus. Consumers feed raw
- * terminal input bytes and receive high-level actions back. Buffer and
- * cursor state are public for rendering.
+ * terminal input bytes and receive high-level actions back.
+ *
+ * The internal buffer may contain PUA placeholder characters for pasted
+ * multi-line content. Consumers should use the typed accessors:
+ *   - `text`          — resolved content (pastes expanded), for submit/history/logic
+ *   - `displayText`   — display content (pastes collapsed to labels), for rendering
+ *   - `displayCursor` — cursor column in display coordinates
+ *   - `setText()`     — replace buffer content (clears paste attachments)
  */
 // ── Kitty protocol keycode → readable name ──────────────────────
 const KITTY_KEY_NAMES = {
     9: "tab", 13: "enter", 27: "escape", 127: "backspace",
 };
+// ── Paste placeholder ───────────────────────────────────────────
+/** First Unicode Private Use Area codepoint, used as paste placeholder. */
+const PUA_BASE = 0xE000;
+function isPUA(ch) {
+    const code = ch.charCodeAt(0);
+    return code >= PUA_BASE && code <= 0xF8FF;
+}
 // ── Line editor ─────────────────────────────────────────────────
 export class LineEditor {
-    buffer = "";
+    _buf = "";
     cursor = 0;
     pendingSeq = ""; // buffered incomplete escape sequence
+    // ── Bracket paste state ─────────────────────────────────────
+    inPaste = false;
+    pasteAccum = ""; // accumulates during bracket paste
+    pastes = new Map(); // id → pasted content
+    pasteCounter = 0;
     // ── History ──────────────────────────────────────────────────
     history = [];
     historyIndex = -1; // -1 = current input, 0..N = history entries (newest first)
     savedBuffer = ""; // saves current input when browsing history
+    // ── Public accessors ────────────────────────────────────────
+    /** Resolved text — paste placeholders expanded. For submit, history, logic. */
+    get text() {
+        let result = "";
+        for (const ch of this._buf) {
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            result += paste ?? ch;
+        }
+        return result;
+    }
+    /** Display text — paste placeholders replaced with labels. For rendering. */
+    get displayText() {
+        let result = "";
+        for (const ch of this._buf) {
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            if (paste) {
+                const n = paste.split("\n").length;
+                result += `[paste +${n} lines]`;
+            }
+            else {
+                result += ch;
+            }
+        }
+        return result;
+    }
+    /** Cursor position mapped to display-text coordinates. */
+    get displayCursor() {
+        let pos = 0;
+        for (let i = 0; i < this._buf.length && i < this.cursor; i++) {
+            const ch = this._buf[i];
+            const paste = this.pastes.get(ch.charCodeAt(0) - PUA_BASE);
+            if (paste) {
+                const n = paste.split("\n").length;
+                pos += `[paste +${n} lines]`.length;
+            }
+            else {
+                pos++;
+            }
+        }
+        return pos;
+    }
+    /** Number of logical positions in the buffer. */
+    get length() {
+        return this._buf.length;
+    }
+    /** Replace buffer content. Clears paste attachments. */
+    setText(value) {
+        this._buf = value;
+        this.pastes.clear();
+        this.pasteCounter = 0;
+        this.cursor = value.length;
+    }
+    // ── Input processing ────────────────────────────────────────
     /** Process raw terminal input, return actions for the consumer. */
     feed(data) {
         // If we had a pending incomplete escape sequence, prepend it
@@ -68,7 +139,7 @@ export class LineEditor {
                             actions.push({ action: "arrow-down" });
                             break;
                         case "C":
-                            if (this.cursor < this.buffer.length) {
+                            if (this.cursor < this._buf.length) {
                                 this.cursor++;
                                 actions.push({ action: "changed" });
                             }
@@ -86,8 +157,8 @@ export class LineEditor {
                             }
                             break;
                         case "F": // End
-                            if (this.cursor < this.buffer.length) {
-                                this.cursor = this.buffer.length;
+                            if (this.cursor < this._buf.length) {
+                                this.cursor = this._buf.length;
                                 actions.push({ action: "changed" });
                             }
                             break;
@@ -119,6 +190,16 @@ export class LineEditor {
                 // Other Alt+key — ignore
                 continue;
             }
+            // ── Bracket paste: accumulate into side buffer ─────
+            if (this.inPaste) {
+                if (ch === "\r") {
+                    i++;
+                    continue;
+                } // skip CR (CR+LF → just LF)
+                this.pasteAccum += ch;
+                i++;
+                continue;
+            }
             // ── Control characters ──────────────────────────────
             if (ch.charCodeAt(0) < 0x20 || ch === "\x7f") {
                 const action = this.handleControl(ch);
@@ -128,7 +209,7 @@ export class LineEditor {
                 continue;
             }
             // ── Printable character ─────────────────────────────
-            this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+            this._buf = this._buf.slice(0, this.cursor) + ch + this._buf.slice(this.cursor);
             this.cursor++;
             actions.push({ action: "changed" });
             i++;
@@ -148,9 +229,13 @@ export class LineEditor {
         return wasBarEscape ? [{ action: "cancel" }] : [];
     }
     clear() {
-        this.buffer = "";
+        this._buf = "";
         this.cursor = 0;
         this.pendingSeq = "";
+        this.inPaste = false;
+        this.pasteAccum = "";
+        this.pastes.clear();
+        this.pasteCounter = 0;
         this.historyIndex = -1;
         this.savedBuffer = "";
     }
@@ -171,11 +256,10 @@ export class LineEditor {
         if (this.historyIndex + 1 >= this.history.length)
             return null;
         if (this.historyIndex === -1) {
-            this.savedBuffer = this.buffer; // save current input
+            this.savedBuffer = this.text; // save resolved current input
         }
         this.historyIndex++;
-        this.buffer = this.history[this.historyIndex];
-        this.cursor = this.buffer.length;
+        this.setText(this.history[this.historyIndex]);
         return { action: "changed" };
     }
     /** Navigate to a more recent history entry. Returns changed action or null. */
@@ -184,12 +268,11 @@ export class LineEditor {
             return null;
         this.historyIndex--;
         if (this.historyIndex === -1) {
-            this.buffer = this.savedBuffer;
+            this.setText(this.savedBuffer);
         }
         else {
-            this.buffer = this.history[this.historyIndex];
+            this.setText(this.history[this.historyIndex]);
         }
-        this.cursor = this.buffer.length;
         return { action: "changed" };
     }
     // ── Key bindings ────────────────────────────────────────────
@@ -198,17 +281,17 @@ export class LineEditor {
     // characters and kitty protocol sequences resolve to a key name
     // and look it up here. To add a binding, add one entry.
     bindings = {
-        "enter": () => ({ action: "submit", buffer: this.buffer }),
+        "enter": () => ({ action: "submit", buffer: this.text }),
         "ctrl+c": () => ({ action: "cancel" }),
         "tab": () => ({ action: "tab" }),
         "backspace": () => this.deleteBackward(),
-        "ctrl+d": () => this.buffer.length === 0 ? { action: "delete-empty" } : this.deleteForward(),
+        "ctrl+d": () => this._buf.length === 0 ? { action: "delete-empty" } : this.deleteForward(),
         "ctrl+a": () => this.moveTo(0),
-        "ctrl+e": () => this.moveTo(this.buffer.length),
+        "ctrl+e": () => this.moveTo(this._buf.length),
         "ctrl+b": () => this.moveTo(this.cursor - 1),
         "ctrl+f": () => this.moveTo(this.cursor + 1),
         "ctrl+u": () => this.deleteRange(0, this.cursor),
-        "ctrl+k": () => this.deleteRange(this.cursor, this.buffer.length),
+        "ctrl+k": () => this.deleteRange(this.cursor, this._buf.length),
         "ctrl+w": () => this.deleteWordBackward() ? { action: "changed" } : null,
         "alt+f": () => this.wordForward() ? { action: "changed" } : null,
         "alt+b": () => this.wordBackward() ? { action: "changed" } : null,
@@ -259,36 +342,51 @@ export class LineEditor {
     }
     // ── Editing primitives ─────────────────────────────────────
     insertAt(ch) {
-        this.buffer = this.buffer.slice(0, this.cursor) + ch + this.buffer.slice(this.cursor);
+        this._buf = this._buf.slice(0, this.cursor) + ch + this._buf.slice(this.cursor);
         this.cursor++;
         return { action: "changed" };
     }
     moveTo(pos) {
-        const clamped = Math.max(0, Math.min(pos, this.buffer.length));
+        const clamped = Math.max(0, Math.min(pos, this._buf.length));
         if (clamped === this.cursor)
             return null;
         this.cursor = clamped;
         return { action: "changed" };
     }
     deleteBackward() {
-        if (this.buffer.length === 0)
+        if (this._buf.length === 0)
             return { action: "delete-empty" };
         if (this.cursor <= 0)
             return null;
-        this.buffer = this.buffer.slice(0, this.cursor - 1) + this.buffer.slice(this.cursor);
+        // If deleting a paste placeholder, also remove the paste entry
+        const deleted = this._buf[this.cursor - 1];
+        if (isPUA(deleted)) {
+            this.pastes.delete(deleted.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, this.cursor - 1) + this._buf.slice(this.cursor);
         this.cursor--;
         return { action: "changed" };
     }
     deleteForward() {
-        if (this.cursor >= this.buffer.length)
+        if (this.cursor >= this._buf.length)
             return null;
-        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+        const deleted = this._buf[this.cursor];
+        if (isPUA(deleted)) {
+            this.pastes.delete(deleted.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, this.cursor) + this._buf.slice(this.cursor + 1);
         return { action: "changed" };
     }
     deleteRange(start, end) {
         if (start >= end)
             return null;
-        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(end);
+        // Clean up any paste entries in the deleted range
+        for (let k = start; k < end; k++) {
+            const ch = this._buf[k];
+            if (isPUA(ch))
+                this.pastes.delete(ch.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, start) + this._buf.slice(end);
         this.cursor = start;
         return { action: "changed" };
     }
@@ -326,7 +424,7 @@ export class LineEditor {
                         actions.push({ action: "changed" });
                 }
                 else {
-                    if (this.cursor < this.buffer.length) {
+                    if (this.cursor < this._buf.length) {
                         this.cursor++;
                         actions.push({ action: "changed" });
                     }
@@ -351,8 +449,8 @@ export class LineEditor {
                 }
                 break;
             case "F": // End
-                if (this.cursor < this.buffer.length) {
-                    this.cursor = this.buffer.length;
+                if (this.cursor < this._buf.length) {
+                    this.cursor = this._buf.length;
                     actions.push({ action: "changed" });
                 }
                 break;
@@ -365,11 +463,39 @@ export class LineEditor {
                     actions.push(action);
                 break;
             }
-            case "~": // Extended keys: Delete (3~), etc.
+            case "~": // Extended keys: Delete (3~), bracket paste (200~/201~), etc.
                 if (params === "3") {
                     // Delete key: delete char under cursor
-                    if (this.cursor < this.buffer.length) {
-                        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(this.cursor + 1);
+                    if (this.cursor < this._buf.length) {
+                        const deleted = this._buf[this.cursor];
+                        if (isPUA(deleted))
+                            this.pastes.delete(deleted.charCodeAt(0) - PUA_BASE);
+                        this._buf = this._buf.slice(0, this.cursor) + this._buf.slice(this.cursor + 1);
+                        actions.push({ action: "changed" });
+                    }
+                }
+                else if (params === "200") {
+                    this.inPaste = true;
+                    this.pasteAccum = "";
+                }
+                else if (params === "201") {
+                    this.inPaste = false;
+                    if (this.pasteAccum) {
+                        const lines = this.pasteAccum.split("\n");
+                        if (lines.length <= 1) {
+                            // Single-line paste — inline directly
+                            this._buf = this._buf.slice(0, this.cursor) + this.pasteAccum + this._buf.slice(this.cursor);
+                            this.cursor += this.pasteAccum.length;
+                        }
+                        else {
+                            // Multi-line paste — store and insert placeholder
+                            const id = this.pasteCounter++;
+                            this.pastes.set(id, this.pasteAccum);
+                            const placeholder = String.fromCharCode(PUA_BASE + id);
+                            this._buf = this._buf.slice(0, this.cursor) + placeholder + this._buf.slice(this.cursor);
+                            this.cursor++;
+                        }
+                        this.pasteAccum = "";
                         actions.push({ action: "changed" });
                     }
                 }
@@ -383,11 +509,11 @@ export class LineEditor {
         if (this.cursor === 0)
             return false;
         let pos = this.cursor;
-        // Skip spaces
-        while (pos > 0 && this.buffer[pos - 1] === " ")
+        // Skip PUA placeholders and spaces
+        while (pos > 0 && (this._buf[pos - 1] === " " || isPUA(this._buf[pos - 1])))
             pos--;
         // Skip word chars
-        while (pos > 0 && this.buffer[pos - 1] !== " ")
+        while (pos > 0 && this._buf[pos - 1] !== " " && !isPUA(this._buf[pos - 1]))
             pos--;
         if (pos === this.cursor)
             return false;
@@ -395,14 +521,14 @@ export class LineEditor {
         return true;
     }
     wordForward() {
-        if (this.cursor >= this.buffer.length)
+        if (this.cursor >= this._buf.length)
             return false;
         let pos = this.cursor;
-        // Skip word chars
-        while (pos < this.buffer.length && this.buffer[pos] !== " ")
+        // Skip word chars and PUA placeholders
+        while (pos < this._buf.length && this._buf[pos] !== " " && !isPUA(this._buf[pos]))
             pos++;
-        // Skip spaces
-        while (pos < this.buffer.length && this.buffer[pos] === " ")
+        // Skip spaces and PUA
+        while (pos < this._buf.length && (this._buf[pos] === " " || isPUA(this._buf[pos])))
             pos++;
         if (pos === this.cursor)
             return false;
@@ -414,15 +540,27 @@ export class LineEditor {
             return false;
         const start = this.cursor;
         this.wordBackward();
-        this.buffer = this.buffer.slice(0, this.cursor) + this.buffer.slice(start);
+        // Clean up paste entries
+        for (let k = this.cursor; k < start; k++) {
+            const ch = this._buf[k];
+            if (isPUA(ch))
+                this.pastes.delete(ch.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, this.cursor) + this._buf.slice(start);
         return true;
     }
     deleteWordForward() {
-        if (this.cursor >= this.buffer.length)
+        if (this.cursor >= this._buf.length)
             return false;
         const start = this.cursor;
         this.wordForward();
-        this.buffer = this.buffer.slice(0, start) + this.buffer.slice(this.cursor);
+        // Clean up paste entries
+        for (let k = start; k < this.cursor; k++) {
+            const ch = this._buf[k];
+            if (isPUA(ch))
+                this.pastes.delete(ch.charCodeAt(0) - PUA_BASE);
+        }
+        this._buf = this._buf.slice(0, start) + this._buf.slice(this.cursor);
         this.cursor = start;
         return true;
     }

package/dist/utils/markdown.d.ts

@@ -1,3 +1,4 @@
+export declare const MAX_CONTENT_WIDTH = 90;
 /**
  * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
  * Returns an array of lines, each fitting within `maxWidth` visible characters.

package/dist/utils/markdown.js

@@ -1,6 +1,6 @@
 import { visibleLen, truncateToWidth, padEndToWidth } from "./ansi.js";
 import { palette as p } from "./palette.js";
-const MAX_CONTENT_WIDTH = 90;
+export const MAX_CONTENT_WIDTH = 90;
 /**
  * Word-wrap a string (which may contain ANSI codes) to a maximum visible width.
  * Returns an array of lines, each fitting within `maxWidth` visible characters.

package/dist/utils/message-utils.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Utilities for manipulating OpenAI-format message arrays.
+ *
+ * Used by extensions advising `conversation:prepare` to transform
+ * the message array before it's sent to the LLM.
+ */
+/**
+ * Find tool call IDs matching a tool name and optional argument filter.
+ *
+ * Scans assistant messages for tool_calls where `function.name` matches
+ * and parsed arguments satisfy the filter (shallow key/value match).
+ *
+ * Returns call IDs in message order (earliest first).
+ */
+export declare function findToolCallIds(messages: any[], toolName: string, argFilter?: Record<string, unknown>): string[];
+/**
+ * Replace tool result content for specific call IDs.
+ *
+ * Returns a new array (shallow copy) with matching tool messages
+ * replaced. Non-matching messages are passed through by reference.
+ */
+export declare function stubToolResults(messages: any[], callIds: Set<string>, stub: string): any[];
+/**
+ * Deduplicate tool results: keep only the latest result for a given
+ * tool name + argument filter, replace all older results with a stub.
+ *
+ * Common use case: a file that's read repeatedly (e.g. a live transcript)
+ * — only the most recent read matters.
+ *
+ * Example:
+ *   dedupeToolResults(messages, "read_file",
+ *     { path: "/path/to/transcript.txt" },
+ *     "[stale — superseded by later read]")
+ */
+export declare function dedupeToolResults(messages: any[], toolName: string, argFilter?: Record<string, unknown>, stub?: string): any[];

package/dist/utils/message-utils.js

@@ -0,0 +1,75 @@
+/**
+ * Utilities for manipulating OpenAI-format message arrays.
+ *
+ * Used by extensions advising `conversation:prepare` to transform
+ * the message array before it's sent to the LLM.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Find tool call IDs matching a tool name and optional argument filter.
+ *
+ * Scans assistant messages for tool_calls where `function.name` matches
+ * and parsed arguments satisfy the filter (shallow key/value match).
+ *
+ * Returns call IDs in message order (earliest first).
+ */
+export function findToolCallIds(messages, toolName, argFilter) {
+    const ids = [];
+    for (const msg of messages) {
+        if (msg.role !== "assistant" || !msg.tool_calls)
+            continue;
+        for (const tc of msg.tool_calls) {
+            const fn = tc.function ?? tc.fn;
+            if (!fn || fn.name !== toolName)
+                continue;
+            if (argFilter) {
+                let args;
+                try {
+                    args = JSON.parse(fn.arguments);
+                }
+                catch {
+                    continue;
+                }
+                const match = Object.entries(argFilter).every(([k, v]) => args[k] === v);
+                if (!match)
+                    continue;
+            }
+            ids.push(tc.id);
+        }
+    }
+    return ids;
+}
+/**
+ * Replace tool result content for specific call IDs.
+ *
+ * Returns a new array (shallow copy) with matching tool messages
+ * replaced. Non-matching messages are passed through by reference.
+ */
+export function stubToolResults(messages, callIds, stub) {
+    return messages.map((msg) => {
+        if (msg.role === "tool" && callIds.has(msg.tool_call_id)) {
+            return { ...msg, content: stub };
+        }
+        return msg;
+    });
+}
+/**
+ * Deduplicate tool results: keep only the latest result for a given
+ * tool name + argument filter, replace all older results with a stub.
+ *
+ * Common use case: a file that's read repeatedly (e.g. a live transcript)
+ * — only the most recent read matters.
+ *
+ * Example:
+ *   dedupeToolResults(messages, "read_file",
+ *     { path: "/path/to/transcript.txt" },
+ *     "[stale — superseded by later read]")
+ */
+export function dedupeToolResults(messages, toolName, argFilter, stub = "[superseded by later call]") {
+    const callIds = findToolCallIds(messages, toolName, argFilter);
+    if (callIds.length <= 1)
+        return messages;
+    // Keep the last one, stub the rest
+    const staleIds = new Set(callIds.slice(0, -1));
+    return stubToolResults(messages, staleIds, stub);
+}

package/dist/utils/terminal-buffer.d.ts

@@ -47,7 +47,9 @@ export declare class TerminalBuffer {
     /** Get the raw serialized terminal output (includes ANSI sequences). */
     serialize(): string;
     /** Read clean screen text with metadata. */
-    readScreen(): ScreenSnapshot;
+    readScreen(opts?: {
+        includeScrollback?: boolean;
+    }): ScreenSnapshot;
     /**
      * Get terminal screen as lines, padded/trimmed to exactly `rows` lines.
      * Clean text only (ANSI stripped).  Reads from the active buffer's
@@ -57,6 +59,8 @@ export declare class TerminalBuffer {
     getScreenLines(rows?: number): string[];
     /** Read visible viewport lines from a buffer. */
     private readViewportLines;
+    /** Read all lines including scrollback from a buffer. */
+    private readAllLines;
     /** Get cursor position. */
     getCursor(): {
         x: number;

package/dist/utils/terminal-buffer.js

@@ -130,9 +130,11 @@ export class TerminalBuffer {
         return this.serializeAddon.serialize();
     }
     /** Read clean screen text with metadata. */
-    readScreen() {
+    readScreen(opts) {
         const buf = this.term.buffer.active;
-        const lines = this.readViewportLines(buf);
+        const lines = opts?.includeScrollback
+            ? this.readAllLines(buf)
+            : this.readViewportLines(buf);
         return {
             text: lines.join("\n"),
             altScreen: buf.type === "alternate",
@@ -161,6 +163,20 @@ export class TerminalBuffer {
         }
         return lines;
     }
+    /** Read all lines including scrollback from a buffer. */
+    readAllLines(buf) {
+        const total = (buf.baseY ?? 0) + buf.length;
+        const lines = [];
+        for (let y = 0; y < total; y++) {
+            const line = buf.getLine(y);
+            lines.push(line ? line.translateToString(true) : "");
+        }
+        // Trim trailing empty lines
+        while (lines.length > 0 && lines[lines.length - 1] === "") {
+            lines.pop();
+        }
+        return lines;
+    }
     /** Get cursor position. */
     getCursor() {
         return {

package/dist/utils/tool-interactive.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Interactive UI primitive for tools.
+ *
+ * Gives a tool imperative control over rendering and input on the active
+ * surface. The tool provides render() + handleInput(), the primitive
+ * handles surface writing, input interception, shell pause/unpause,
+ * and cleanup.
+ */
+import type { EventBus } from "../event-bus.js";
+import type { RenderSurface } from "./compositor.js";
+import type { ToolUI } from "../agent/types.js";
+export declare function createToolUI(bus: EventBus, surface: RenderSurface): ToolUI;

package/dist/utils/tool-interactive.js

@@ -0,0 +1,53 @@
+/** Clear N lines above the cursor. */
+function clearLines(surface, count) {
+    for (let i = 0; i < count; i++) {
+        surface.write("\x1b[A\x1b[2K");
+    }
+}
+export function createToolUI(bus, surface) {
+    return {
+        custom(session) {
+            return new Promise((resolve) => {
+                let prevLineCount = 0;
+                let finished = false;
+                const done = (result) => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    clearLines(surface, prevLineCount);
+                    bus.offPipe("input:intercept", interceptor);
+                    bus.emit("shell:stdout-hide", {});
+                    bus.emit("tool:interactive-end", {});
+                    session.onUnmount?.();
+                    resolve(result);
+                };
+                const render = () => {
+                    if (finished)
+                        return;
+                    clearLines(surface, prevLineCount);
+                    const lines = session.render(surface.columns);
+                    for (const line of lines) {
+                        surface.writeLine(line);
+                    }
+                    prevLineCount = lines.length;
+                };
+                const interceptor = (payload) => {
+                    if (finished)
+                        return payload;
+                    // Let Ctrl+C through for agent cancellation
+                    if (payload.data === "\x03")
+                        return payload;
+                    session.handleInput(payload.data, done);
+                    render();
+                    return { ...payload, consumed: true };
+                };
+                // Setup
+                bus.emit("tool:interactive-start", {});
+                bus.emit("shell:stdout-show", {});
+                bus.onPipe("input:intercept", interceptor);
+                session.onMount?.(() => render());
+                render();
+            });
+        },
+    };
+}