@valyrianjs/terminal 0.1.1 → 0.2.0

package/dist/session.js

@@ -1,11 +1,101 @@
-import { createAnsiDiffWriter, formatPlainFrame, toAnsiFrame } from "./ansi.js";
+import { ANSI_ENTER_ALTERNATE_SCREEN, ANSI_EXIT_ALTERNATE_SCREEN, ANSI_HIDE_CURSOR, ANSI_SHOW_CURSOR, createAnsiDiffWriter, formatPlainFrame, toAnsiFrame } from "./ansi.js";
 import { createSystemClipboardAdapter } from "./clipboard.js";
-import { copySelection, hasSelection, insertText, invokeButton, moveCursorEnd, moveCursorHome, moveCursorLeft, moveCursorRight, moveCursorWordLeft, moveCursorWordRight, normalizeInputState, parseTerminalKey, removeBackward, removeForward, selectAll, submitInput, updateInputValue } from "./events.js";
+import { createEditorState, insertEditorText, moveEditorCursor, removeEditorBackward, removeEditorForward } from "./editor-state.js";
+import { copySelection, hasSelection, insertText, moveCursorEnd, moveCursorHome, moveCursorLeft, moveCursorRight, moveCursorWordLeft, moveCursorWordRight, normalizeInputState, parseTerminalKey, removeBackward, removeForward, selectAll } from "./events.js";
+import { createResolvedTerminalKeymap, resolveTerminalKeyBinding } from "./keymap.js";
 import { mergeVertical } from "./layout.js";
-import { cursorFromHitbox, findHitboxAt, parseTerminalInput } from "./mouse.js";
+import { cursorFromHitbox, parseTerminalInput, resolvePointerTarget } from "./mouse.js";
+import { createOutputWriter } from "./output-writer.js";
+import { parseBracketedPaste } from "./paste.js";
 import { renderTerminalFrame } from "./render.js";
-import { collectFocusableNodes, findFocusableById, findFocused, resolveRoot } from "./tree.js";
-function applyInteractiveState(nodes, focusedId, inputStateById, listIndexById, scrollOffsetById, listHoverById, scrollHoverRowById) {
+import { createRenderScheduler } from "./scheduler.js";
+import { plainText, stripTerminalControls } from "./text.js";
+import { collectActiveFocusScopeFocusableNodes, collectDirectOverlayFocusableNodes, collectFocusableNodes, findFocusableById, findFocused } from "./tree.js";
+import { createValyrianTerminalRuntime } from "./runtime.js";
+const DEFAULT_TERMINAL_SIZE = { cols: 80, rows: 24 };
+const BRACKETED_PASTE_START = "\u001b[200~";
+const KNOWN_TERMINAL_KEY_SEQUENCES = [
+    "\u001b[13;2u",
+    "\u001b[13;130u",
+    "\u001b[13;129u",
+    "\u001b[27;2;13~",
+    "\u001b[13;2~",
+    "\u001b[1;2C",
+    "\u001b[1;2D",
+    "\u001b[1;3C",
+    "\u001b[1;3D",
+    "\u001b[3~",
+    "\u001b[Z",
+    "\u001b[A",
+    "\u001b[B",
+    "\u001b[C",
+    "\u001b[D",
+    "\u001b[H",
+    "\u001b[F",
+    "\u001bf",
+    "\u001bb"
+];
+const ESCAPE = "\u001b";
+const CSI_PREFIX = "\u001b[";
+const DOUBLE_PRESS_INTERVAL_MS = 500;
+function isBracketedPasteStartPrefix(value) {
+    return value.length > 0 && value.length < BRACKETED_PASTE_START.length && BRACKETED_PASTE_START.startsWith(value);
+}
+function isDisambiguatedBracketedPasteStartPrefix(value) {
+    return isBracketedPasteStartPrefix(value) && value.length > CSI_PREFIX.length;
+}
+function isKnownTerminalKeySequencePrefix(value) {
+    return KNOWN_TERMINAL_KEY_SEQUENCES.some((sequence) => value.length > 0 && value.length < sequence.length && sequence.startsWith(value));
+}
+function canContinueEscapeSequence(value) {
+    return value.startsWith("[") || value.startsWith("b") || value.startsWith("f");
+}
+function validateTerminalDimension(name, value) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error(`Invalid terminal ${name}: expected an integer >= 1`);
+    }
+    return value;
+}
+function isValidTerminalDimension(value) {
+    return Number.isInteger(value) && Number(value) >= 1;
+}
+function getProcessStdin() {
+    const candidate = globalThis.process?.stdin;
+    return candidate && typeof candidate.on === "function" ? candidate : undefined;
+}
+function getProcessStdout() {
+    const candidate = globalThis.process?.stdout;
+    return candidate && typeof candidate.write === "function" ? candidate : undefined;
+}
+function isInteractiveTTY(stdin, stdout) {
+    return Boolean(stdin?.isTTY && stdout?.isTTY);
+}
+function resolveRuntimeOptions(options) {
+    const processStdin = getProcessStdin();
+    const processStdout = getProcessStdout();
+    const canUseProcessTTY = isInteractiveTTY(processStdin, processStdout);
+    const runtime = options.runtime ?? (canUseProcessTTY || options.stdin || options.stdout ? "app" : "headless");
+    const stdin = options.stdin ?? (runtime === "app" && canUseProcessTTY ? processStdin : undefined);
+    const stdout = options.stdout ?? (runtime === "app" && canUseProcessTTY ? processStdout : undefined);
+    const ownsInteractiveTTY = runtime === "app" && isInteractiveTTY(stdin, stdout);
+    return {
+        runtime,
+        stdin,
+        stdout,
+        alternateScreen: options.alternateScreen ?? ownsInteractiveTTY,
+        hideCursor: options.hideCursor ?? ownsInteractiveTTY,
+        writesAnsi: runtime === "app" && Boolean(stdout)
+    };
+}
+function resolveTerminalSize(options, stdout) {
+    const cols = options.cols ?? stdout?.columns ?? DEFAULT_TERMINAL_SIZE.cols;
+    const rows = options.rows ?? stdout?.rows ?? DEFAULT_TERMINAL_SIZE.rows;
+    return {
+        cols: validateTerminalDimension("cols", cols),
+        rows: validateTerminalDimension("rows", rows)
+    };
+}
+function applyInteractiveState(nodes, focusedId, inputStateById, editorStateById, listIndexById, scrollOffsetById, listHoverById, scrollHoverRowById) {
     for (let i = 0; i < nodes.length; i += 1) {
         const node = nodes[i];
         if (node.type !== "element") {
@@ -14,11 +104,18 @@ function applyInteractiveState(nodes, focusedId, inputStateById, listIndexById,
         const id = node.props.id;
         node.props.__focused = Boolean(focusedId && id === focusedId);
         if (node.tag === "terminal-input" && id) {
-            const value = String(node.props.value ?? "");
+            const value = plainText(node.props.value ?? "");
             const current = normalizeInputState(inputStateById.get(id), value.length);
             inputStateById.set(id, current);
             node.props.__inputState = current;
         }
+        if (node.tag === "terminal-editor" && id) {
+            const value = plainText(node.props.value ?? "");
+            const previous = editorStateById.get(id);
+            const current = createEditorState(value, previous?.cursor, previous?.desiredColumn);
+            editorStateById.set(id, current);
+            node.props.__editorState = current;
+        }
         if (node.tag === "terminal-list" && id) {
             node.props.__selectedIndex = listIndexById.get(id) || 0;
             if (listHoverById.has(id)) {
@@ -31,46 +128,134 @@ function applyInteractiveState(nodes, focusedId, inputStateById, listIndexById,
                 node.props.__hoveredRow = scrollHoverRowById.get(id);
             }
         }
-        applyInteractiveState(node.children, focusedId, inputStateById, listIndexById, scrollOffsetById, listHoverById, scrollHoverRowById);
+        applyInteractiveState(node.children, focusedId, inputStateById, editorStateById, listIndexById, scrollOffsetById, listHoverById, scrollHoverRowById);
     }
 }
 export function mountTerminal(input, options = {}) {
     let focusedId = null;
+    let skipFocusContainmentOnce = false;
     let clipboardValue = "";
     let mouseSelectionId = null;
     let pointerCaptureId = null;
+    let pendingPasteChunk = "";
+    let pendingKeyChunk = "";
+    let pendingEscapeFlush = null;
+    let lastPrimaryPress = null;
+    let destroyed = false;
+    let autoProjectionEnabled = false;
+    let suppressAutoProjection = false;
     const clipboardAdapter = options.clipboard === false ? null : options.clipboard || createSystemClipboardAdapter();
     const inputStateById = new Map();
+    const editorStateById = new Map();
     const listIndexById = new Map();
     const scrollOffsetById = new Map();
     const listHoverById = new Map();
     const scrollHoverRowById = new Map();
-    let currentTree = resolveRoot(input);
-    applyInteractiveState(currentTree, focusedId, inputStateById, listIndexById, scrollOffsetById, listHoverById, scrollHoverRowById);
-    let currentFrame = mergeVertical(currentTree.map(renderTerminalFrame));
-    let currentOutput = formatPlainFrame(currentFrame).trimEnd();
+    const keyBindings = createResolvedTerminalKeymap(options.keymap?.bindings);
+    const runtimeOptions = resolveRuntimeOptions(options);
+    let terminalSize = resolveTerminalSize(options, runtimeOptions.stdout);
+    const terminalRuntime = createValyrianTerminalRuntime(input, () => {
+        if (!autoProjectionEnabled || suppressAutoProjection || destroyed) {
+            return;
+        }
+        renderNow();
+    });
+    let currentTree = terminalRuntime.project();
+    applyInteractiveState(currentTree, focusedId, inputStateById, editorStateById, listIndexById, scrollOffsetById, listHoverById, scrollHoverRowById);
+    let currentFrame = renderTreeFrame(currentTree);
+    let currentOutput = formatPlainFrame(currentFrame, { theme: options.theme }).trimEnd();
     let currentHitboxes = currentFrame.hitboxes;
-    const toAnsiDiff = createAnsiDiffWriter();
+    const outputWriter = createOutputWriter(runtimeOptions.stdout);
+    const toAnsiDiff = createAnsiDiffWriter({ showCursor: !runtimeOptions.hideCursor, showCursorWhenFrameHasCursor: true, theme: options.theme });
+    const renderScheduler = createRenderScheduler(renderNow);
+    const outputResizeScheduler = createRenderScheduler(applyPendingOutputResize);
+    let cleanupOutputResize = null;
+    let pendingOutputResize = null;
+    function renderContext() {
+        return { ...terminalSize, theme: options.theme };
+    }
+    function renderTreeFrame(nodes) {
+        const context = renderContext();
+        return mergeVertical(nodes.map((node) => renderTerminalFrame(node, context)));
+    }
+    function emitLifecycleSetup() {
+        const writes = [];
+        if (runtimeOptions.alternateScreen) {
+            writes.push(ANSI_ENTER_ALTERNATE_SCREEN);
+        }
+        if (runtimeOptions.hideCursor) {
+            writes.push(ANSI_HIDE_CURSOR);
+        }
+        if (writes.length > 0) {
+            outputWriter.write(writes.join(""), { force: true });
+        }
+    }
+    function emitLifecycleRestore() {
+        if (options.restoreOnDestroy === false) {
+            return;
+        }
+        const writes = [];
+        if (runtimeOptions.hideCursor) {
+            writes.push(ANSI_SHOW_CURSOR);
+        }
+        if (runtimeOptions.alternateScreen) {
+            writes.push(ANSI_EXIT_ALTERNATE_SCREEN);
+        }
+        if (writes.length > 0) {
+            outputWriter.write(writes.join(""), { force: true });
+        }
+    }
     function emitOutput() {
-        if (options.stdout) {
-            options.stdout.write(options.ansi ? toAnsiDiff(currentFrame.lines, currentFrame.cursor, currentFrame.spans) : currentOutput);
+        if (!destroyed) {
+            outputWriter.write(runtimeOptions.writesAnsi ? toAnsiDiff(currentFrame.lines, currentFrame.cursor, currentFrame.spans) : currentOutput);
         }
     }
-    function rerender() {
-        currentTree = resolveRoot(input);
+    function renderNow() {
+        currentTree = terminalRuntime.project();
         const focusables = [];
         collectFocusableNodes(currentTree, focusables);
-        if (focusedId && !focusables.some((node) => node.props.id === focusedId)) {
-            focusedId = focusables[0]?.props.id || null;
+        const overlayFocusables = [];
+        collectDirectOverlayFocusableNodes(currentTree, overlayFocusables);
+        const scopedFocusables = [];
+        collectActiveFocusScopeFocusableNodes(currentTree, focusedId, scopedFocusables);
+        const activeFocusables = overlayFocusables.length ? overlayFocusables : scopedFocusables.length ? scopedFocusables : focusables;
+        if (!skipFocusContainmentOnce && focusedId && !activeFocusables.some((node) => node.props.id === focusedId)) {
+            focusedId = activeFocusables[0]?.props.id || null;
         }
-        applyInteractiveState(currentTree, focusedId, inputStateById, listIndexById, scrollOffsetById, listHoverById, scrollHoverRowById);
-        currentFrame = mergeVertical(currentTree.map(renderTerminalFrame));
-        currentOutput = formatPlainFrame(currentFrame).trimEnd();
+        skipFocusContainmentOnce = false;
+        applyInteractiveState(currentTree, focusedId, inputStateById, editorStateById, listIndexById, scrollOffsetById, listHoverById, scrollHoverRowById);
+        currentFrame = renderTreeFrame(currentTree);
+        currentOutput = formatPlainFrame(currentFrame, { theme: options.theme }).trimEnd();
         currentHitboxes = currentFrame.hitboxes;
         emitOutput();
         return currentOutput;
     }
+    function rerender() {
+        if (destroyed) {
+            return currentOutput;
+        }
+        suppressAutoProjection = true;
+        try {
+            terminalRuntime.update();
+        }
+        finally {
+            suppressAutoProjection = false;
+        }
+        renderScheduler.requestRender();
+        renderScheduler.flush();
+        return currentOutput;
+    }
     function orderedFocusables() {
+        const overlayFocusables = [];
+        collectDirectOverlayFocusableNodes(currentTree, overlayFocusables);
+        if (overlayFocusables.length) {
+            return overlayFocusables;
+        }
+        const scopedFocusables = [];
+        collectActiveFocusScopeFocusableNodes(currentTree, focusedId, scopedFocusables);
+        if (scopedFocusables.length) {
+            return scopedFocusables;
+        }
         const out = [];
         collectFocusableNodes(currentTree, out);
         return out;
@@ -105,21 +290,51 @@ export function mountTerminal(input, options = {}) {
     }
     function setInputCursor(id, cursor, extendSelection = false) {
         const node = findFocusableById(currentTree, id);
-        const value = String(node?.props.value ?? "");
+        const value = stripTerminalControls(node?.props.value ?? "");
         const current = normalizeInputState(inputStateById.get(id), value.length);
         inputStateById.set(id, extendSelection ? { cursor: Math.max(0, Math.min(value.length, cursor)), anchor: current.anchor } : { cursor: Math.max(0, Math.min(value.length, cursor)), anchor: Math.max(0, Math.min(value.length, cursor)) });
     }
     function replaceInputState(id, state) {
         const node = findFocusableById(currentTree, id);
-        const value = String(node?.props.value ?? "");
+        const value = stripTerminalControls(node?.props.value ?? "");
         inputStateById.set(id, normalizeInputState(state, value.length));
     }
+    function dispatchNodeEvent(node, type, payload) {
+        const id = String(node.props.id || "");
+        if (!id) {
+            return false;
+        }
+        return terminalRuntime.dispatchTerminalEvent(id, type, payload);
+    }
     function updateInputByState(node, next) {
         const id = String(node.props.id || "");
-        updateInputValue(node, next.value);
+        dispatchNodeEvent(node, "change", { type: "change", id, value: next.value });
         inputStateById.set(id, next.state);
         return rerender();
     }
+    function replaceEditorState(id, state) {
+        const node = findFocusableById(currentTree, id);
+        const value = plainText(node?.props.value ?? "");
+        editorStateById.set(id, createEditorState(value, state.cursor, state.desiredColumn));
+    }
+    function updateEditorValue(node, nextValue) {
+        const id = String(node.props.id || "");
+        dispatchNodeEvent(node, "change", { type: "change", id, value: plainText(nextValue) });
+    }
+    function updateEditorByState(node, next) {
+        const id = String(node.props.id || "");
+        updateEditorValue(node, next.value);
+        editorStateById.set(id, next.state);
+        return rerender();
+    }
+    function submitEditor(node) {
+        const id = String(node.props.id || "");
+        dispatchNodeEvent(node, "submit", { type: "submit", id, value: plainText(node.props.value ?? "") });
+    }
+    function cancelEditor(node) {
+        const id = String(node.props.id || "");
+        dispatchNodeEvent(node, "cancel", { type: "cancel", id, value: plainText(node.props.value ?? "") });
+    }
     function setCursorFromHitbox(id, x, extendSelection = false) {
         const hitbox = currentHitboxes.find((box) => box.id === id && box.tag === "terminal-input");
         if (!hitbox) {
@@ -130,7 +345,8 @@ export function mountTerminal(input, options = {}) {
         return rerender();
     }
     function visibleScrollLines(node) {
-        const lines = mergeVertical(node.children.map(renderTerminalFrame)).lines;
+        const context = renderContext();
+        const lines = mergeVertical(node.children.map((child) => renderTerminalFrame(child, context))).lines;
         const offset = Number(node.props.__scrollOffset || 0);
         const height = Number(node.props.height || lines.length || 0);
         return lines.slice(offset, offset + height).map((line) => line.trimEnd());
@@ -145,6 +361,13 @@ export function mountTerminal(input, options = {}) {
         }
         return 1;
     }
+    function sourceRowFromHitbox(node, hitbox, y) {
+        const visibleRow = Math.max(1, y - hitbox.y1 + 1);
+        if (node.tag !== "terminal-list") {
+            return Math.max(1, Math.min(rowCountForNode(node), visibleRow));
+        }
+        return Math.max(1, Math.min(rowCountForNode(node), visibleRow + (hitbox.itemOffset || 0)));
+    }
     function shouldPointerCapture(node) {
         return Boolean(node.props.pointerCapture && (node.tag === "terminal-list" || node.tag === "terminal-scroll"));
     }
@@ -166,12 +389,8 @@ export function mountTerminal(input, options = {}) {
         if (!node || !node.props.id) {
             return;
         }
-        const handler = node.props[`on${type}`];
-        if (typeof handler !== "function") {
-            return;
-        }
         const payload = { type, id: node.props.id, source, row, x, y };
-        handler(payload);
+        dispatchNodeEvent(node, type, payload);
     }
     function setPointerCapture(id, source, row = null, x = null, y = null) {
         if (pointerCaptureId === id) {
@@ -187,9 +406,53 @@ export function mountTerminal(input, options = {}) {
             emitCaptureEvent(next, "capturestart", source, row ?? hoveredRowForNode(next), x, y);
         }
     }
+    function dispatchListPressEvent(node, type, index) {
+        const id = node.props.id;
+        if (!id) {
+            return false;
+        }
+        const items = Array.isArray(node.props.items) ? node.props.items : [];
+        if (typeof items[index] === "undefined") {
+            return false;
+        }
+        const payload = { type, id, index, value: items[index] };
+        return dispatchNodeEvent(node, type, payload);
+    }
+    function dispatchButtonPressEvent(node, type) {
+        const id = String(node.props.id || "");
+        if (!id) {
+            return false;
+        }
+        return dispatchNodeEvent(node, type, { type, id });
+    }
+    function dispatchListPointerPressEvent(node, type, row) {
+        const items = Array.isArray(node.props.items) ? node.props.items : [];
+        const index = Math.max(0, Math.min(items.length - 1, row - 1));
+        return dispatchListPressEvent(node, type, index);
+    }
+    function dispatchInputContextPressEvent(node, hitbox, x, y) {
+        const id = String(node.props.id || "");
+        if (!id) {
+            return false;
+        }
+        const value = stripTerminalControls(node.props.value ?? "");
+        const current = normalizeInputState(inputStateById.get(id), value.length);
+        const cursor = typeof x === "number" ? cursorFromHitbox(hitbox, x) : current.cursor;
+        return dispatchNodeEvent(node, "contextpress", { type: "contextpress", id, value, cursor, x, y });
+    }
+    function dispatchScrollContextPressEvent(node, row, x, y) {
+        if (!node.props.id) {
+            return false;
+        }
+        const lines = visibleScrollLines(node);
+        const index = Math.max(0, Math.min(lines.length - 1, row - 1));
+        if (typeof lines[index] === "undefined") {
+            return false;
+        }
+        return dispatchNodeEvent(node, "contextpress", { type: "contextpress", id: node.props.id, row: index + 1, value: lines[index], x, y });
+    }
     function emitMouseRowEvent(node, type, row, x = null, y = null) {
-        const handler = node.props[`on${type}`];
-        if (typeof handler !== "function" || !node.props.id) {
+        if (!node.props.id) {
             return;
         }
         if (node.tag === "terminal-list") {
@@ -199,7 +462,7 @@ export function mountTerminal(input, options = {}) {
                 return;
             }
             const payload = { type, id: node.props.id, row: index + 1, index, value: items[index], x, y };
-            handler(payload);
+            dispatchNodeEvent(node, type, payload);
             return;
         }
         if (node.tag === "terminal-scroll") {
@@ -209,7 +472,7 @@ export function mountTerminal(input, options = {}) {
                 return;
             }
             const payload = { type, id: node.props.id, row: index + 1, value: lines[index], x, y };
-            handler(payload);
+            dispatchNodeEvent(node, type, payload);
         }
     }
     function clearSemanticHover(exceptId, x = null, y = null) {
@@ -242,7 +505,7 @@ export function mountTerminal(input, options = {}) {
             return;
         }
         clearSemanticHover(id, x, y);
-        const row = Math.max(1, Math.min(rowCountForNode(node), y - hitbox.y1 + 1));
+        const row = sourceRowFromHitbox(node, hitbox, y);
         if (node.tag === "terminal-list") {
             const nextIndex = row - 1;
             const prevIndex = listHoverById.get(id);
@@ -272,7 +535,7 @@ export function mountTerminal(input, options = {}) {
         }
     }
     function hoverAt(x, y) {
-        const hitbox = findHitboxAt(currentHitboxes, x, y);
+        const hitbox = resolvePointerTarget(currentHitboxes, x, y);
         if (!hitbox) {
             if (pointerCaptureId) {
                 setSemanticHoverFromHitbox(pointerCaptureId, x, y);
@@ -283,12 +546,260 @@ export function mountTerminal(input, options = {}) {
         }
         const node = findFocusableById(currentTree, hitbox.id);
         if (node && shouldPointerCapture(node)) {
-            setPointerCapture(hitbox.id, "drag", Math.max(1, Math.min(rowCountForNode(node), y - hitbox.y1 + 1)), x, y);
+            setPointerCapture(hitbox.id, "drag", sourceRowFromHitbox(node, hitbox, y), x, y);
         }
         setSemanticHoverFromHitbox(hitbox.id, x, y);
         return rerender();
     }
+    function changeListSelection(node, direction) {
+        const id = node.props.id;
+        if (!id) {
+            return currentOutput;
+        }
+        const items = Array.isArray(node.props.items) ? node.props.items : [];
+        const currentIndex = listIndexById.get(id) || 0;
+        const nextIndex = direction < 0 ? Math.max(0, currentIndex - 1) : Math.min(items.length - 1, currentIndex + 1);
+        listIndexById.set(id, nextIndex);
+        const payload = { type: "change", id, index: nextIndex, value: items[nextIndex] };
+        dispatchNodeEvent(node, "change", payload);
+        return rerender();
+    }
+    function pressListSelection(node) {
+        const id = node.props.id;
+        if (!id) {
+            return currentOutput;
+        }
+        const currentIndex = listIndexById.get(id) || 0;
+        dispatchListPressEvent(node, "press", currentIndex);
+        return rerender();
+    }
+    function scrollFocusedNode(node, direction) {
+        const id = node.props.id;
+        if (!id) {
+            return currentOutput;
+        }
+        const context = renderContext();
+        const rendered = mergeVertical(node.children.map((child) => renderTerminalFrame(child, context)));
+        const height = Number(node.props.height || rendered.lines.length || 0);
+        const currentOffset = scrollOffsetById.get(id) || 0;
+        const maxOffset = Math.max(0, rendered.lines.length - height);
+        scrollOffsetById.set(id, direction < 0 ? Math.max(0, currentOffset - 1) : Math.min(maxOffset, currentOffset + 1));
+        return rerender();
+    }
+    function wheelAt(x, y, direction) {
+        const hitbox = resolvePointerTarget(currentHitboxes, x, y);
+        if (!hitbox) {
+            return currentOutput;
+        }
+        setSemanticHoverFromHitbox(hitbox.id, x, y);
+        const node = findFocusableById(currentTree, hitbox.id);
+        if (node?.tag === "terminal-scroll") {
+            return scrollFocusedNode(node, direction);
+        }
+        if (node?.tag === "terminal-list" && node.props.virtualized) {
+            return changeListSelection(node, direction);
+        }
+        return rerender();
+    }
+    function runInputCommand(node, command) {
+        const id = node.props.id;
+        if (!id) {
+            return currentOutput;
+        }
+        const currentValue = stripTerminalControls(node.props.value ?? "");
+        const state = normalizeInputState(inputStateById.get(id), currentValue.length);
+        switch (command.id) {
+            case "input.submit":
+                dispatchNodeEvent(node, "submit", { type: "submit", id, value: stripTerminalControls(node.props.value ?? "") });
+                return rerender();
+            case "input.cursorLeft":
+                replaceInputState(id, moveCursorLeft(state, currentValue.length));
+                return rerender();
+            case "input.cursorRight":
+                replaceInputState(id, moveCursorRight(state, currentValue.length));
+                return rerender();
+            case "input.selectLeft":
+                replaceInputState(id, moveCursorLeft(state, currentValue.length, true));
+                return rerender();
+            case "input.selectRight":
+                replaceInputState(id, moveCursorRight(state, currentValue.length, true));
+                return rerender();
+            case "input.wordLeft":
+                replaceInputState(id, moveCursorWordLeft(currentValue, state));
+                return rerender();
+            case "input.wordRight":
+                replaceInputState(id, moveCursorWordRight(currentValue, state));
+                return rerender();
+            case "input.home":
+                replaceInputState(id, moveCursorHome(state, currentValue.length));
+                return rerender();
+            case "input.end":
+                replaceInputState(id, moveCursorEnd(state, currentValue.length));
+                return rerender();
+            case "input.selectAll":
+                replaceInputState(id, selectAll(currentValue));
+                return rerender();
+            case "input.copy":
+                writeClipboard(copySelection(currentValue, state));
+                return rerender();
+            case "input.cut":
+                writeClipboard(copySelection(currentValue, state));
+                if (hasSelection(state)) {
+                    return updateInputByState(node, insertText(currentValue, state, ""));
+                }
+                return currentOutput;
+            case "input.paste":
+                return updateInputByState(node, insertText(currentValue, state, stripTerminalControls(readClipboard())));
+            case "input.pasteText":
+                return updateInputByState(node, insertText(currentValue, state, stripTerminalControls(command.text ?? "")));
+            case "input.backspace":
+                return updateInputByState(node, removeBackward(currentValue, state));
+            case "input.delete":
+                return updateInputByState(node, removeForward(currentValue, state));
+            case "input.insertText":
+                return updateInputByState(node, insertText(currentValue, state, stripTerminalControls(command.text ?? "")));
+            default:
+                return currentOutput;
+        }
+    }
+    function isBuiltInInputCommand(command) {
+        return command.id === "input.submit"
+            || command.id === "input.cursorLeft"
+            || command.id === "input.cursorRight"
+            || command.id === "input.selectLeft"
+            || command.id === "input.selectRight"
+            || command.id === "input.wordLeft"
+            || command.id === "input.wordRight"
+            || command.id === "input.home"
+            || command.id === "input.end"
+            || command.id === "input.selectAll"
+            || command.id === "input.copy"
+            || command.id === "input.cut"
+            || command.id === "input.paste"
+            || command.id === "input.pasteText"
+            || command.id === "input.backspace"
+            || command.id === "input.delete"
+            || command.id === "input.insertText";
+    }
+    function runEditorCommand(node, command) {
+        const id = node.props.id;
+        if (!id) {
+            return currentOutput;
+        }
+        const currentValue = plainText(node.props.value ?? "");
+        const previous = editorStateById.get(id);
+        const state = createEditorState(currentValue, previous?.cursor, previous?.desiredColumn);
+        switch (command.id) {
+            case "editor.submit":
+                submitEditor(node);
+                return rerender();
+            case "editor.cancel":
+                cancelEditor(node);
+                return rerender();
+            case "editor.newline":
+                return updateEditorByState(node, insertEditorText(currentValue, state, "\n"));
+            case "editor.backspace":
+                return updateEditorByState(node, removeEditorBackward(currentValue, state));
+            case "editor.delete":
+                return updateEditorByState(node, removeEditorForward(currentValue, state));
+            case "editor.cursorLeft":
+                replaceEditorState(id, moveEditorCursor(currentValue, state, "left"));
+                return rerender();
+            case "editor.cursorRight":
+                replaceEditorState(id, moveEditorCursor(currentValue, state, "right"));
+                return rerender();
+            case "editor.cursorUp":
+                replaceEditorState(id, moveEditorCursor(currentValue, state, "up"));
+                return rerender();
+            case "editor.cursorDown":
+                replaceEditorState(id, moveEditorCursor(currentValue, state, "down"));
+                return rerender();
+            case "editor.home":
+                replaceEditorState(id, moveEditorCursor(currentValue, state, "home"));
+                return rerender();
+            case "editor.end":
+                replaceEditorState(id, moveEditorCursor(currentValue, state, "end"));
+                return rerender();
+            case "editor.paste":
+                return updateEditorByState(node, insertEditorText(currentValue, state, plainText(readClipboard())));
+            case "editor.pasteText":
+            case "editor.insertText":
+                return updateEditorByState(node, insertEditorText(currentValue, state, plainText(command.text ?? "")));
+            default:
+                return currentOutput;
+        }
+    }
+    function isBuiltInEditorCommand(command) {
+        return command.id === "editor.submit"
+            || command.id === "editor.cancel"
+            || command.id === "editor.newline"
+            || command.id === "editor.backspace"
+            || command.id === "editor.delete"
+            || command.id === "editor.cursorLeft"
+            || command.id === "editor.cursorRight"
+            || command.id === "editor.cursorUp"
+            || command.id === "editor.cursorDown"
+            || command.id === "editor.home"
+            || command.id === "editor.end"
+            || command.id === "editor.paste"
+            || command.id === "editor.pasteText"
+            || command.id === "editor.insertText";
+    }
+    function runCommand(command, node, context) {
+        switch (command.id) {
+            case "focus.next":
+                session.focusNext();
+                return currentOutput;
+            case "focus.prev":
+                session.focusPrev();
+                return currentOutput;
+            case "button.press":
+                if (node?.tag === "terminal-button") {
+                    dispatchButtonPressEvent(node, "press");
+                    return rerender();
+                }
+                return currentOutput;
+            case "list.prev":
+                return node?.tag === "terminal-list" ? changeListSelection(node, -1) : currentOutput;
+            case "list.next":
+                return node?.tag === "terminal-list" ? changeListSelection(node, 1) : currentOutput;
+            case "list.press":
+                return node?.tag === "terminal-list" ? pressListSelection(node) : currentOutput;
+            case "scroll.up":
+                return node?.tag === "terminal-scroll" ? scrollFocusedNode(node, -1) : currentOutput;
+            case "scroll.down":
+                return node?.tag === "terminal-scroll" ? scrollFocusedNode(node, 1) : currentOutput;
+            default:
+                if (node?.tag === "terminal-input" && isBuiltInInputCommand(command)) {
+                    return runInputCommand(node, command);
+                }
+                if (node?.tag === "terminal-editor" && isBuiltInEditorCommand(command)) {
+                    return runEditorCommand(node, command);
+                }
+                if (typeof options.keymap?.onCommand === "function") {
+                    const consumed = options.keymap.onCommand(command, context);
+                    return consumed ? rerender() : currentOutput;
+                }
+                return currentOutput;
+        }
+    }
     const session = {
+        size() {
+            return { ...terminalSize };
+        },
+        resize(cols, rows) {
+            const nextSize = {
+                cols: validateTerminalDimension("cols", cols),
+                rows: validateTerminalDimension("rows", rows)
+            };
+            pendingOutputResize = null;
+            outputResizeScheduler.cancel();
+            if (nextSize.cols === terminalSize.cols && nextSize.rows === terminalSize.rows) {
+                return;
+            }
+            terminalSize = nextSize;
+            rerender();
+        },
         update() {
             return rerender();
         },
@@ -296,7 +807,7 @@ export function mountTerminal(input, options = {}) {
             return currentOutput;
         },
         ansiOutput() {
-            return toAnsiFrame(currentFrame.lines, currentFrame.cursor, currentFrame.spans);
+            return toAnsiFrame(currentFrame.lines, currentFrame.cursor, currentFrame.spans, { showCursor: !options.hideCursor, showCursorWhenFrameHasCursor: true, theme: options.theme });
         },
         tree() {
             return currentTree;
@@ -311,13 +822,20 @@ export function mountTerminal(input, options = {}) {
             return true;
         },
         focusAt(x, y) {
-            const hitbox = findHitboxAt(currentHitboxes, x, y);
+            const hitbox = resolvePointerTarget(currentHitboxes, x, y);
             if (!hitbox) {
                 clearSemanticHover(undefined, x, y);
                 return false;
             }
             setSemanticHoverFromHitbox(hitbox.id, x, y);
-            return this.focus(hitbox.id);
+            const node = findFocusableById(currentTree, hitbox.id);
+            if (!node) {
+                return false;
+            }
+            focusedId = node.props.id || focusedId;
+            skipFocusContainmentOnce = true;
+            rerender();
+            return true;
         },
         focusNext() {
             const focusables = orderedFocusables();
@@ -341,143 +859,16 @@ export function mountTerminal(input, options = {}) {
             return true;
         },
         dispatchKey(key) {
-            if (key === "TAB") {
-                this.focusNext();
-                return currentOutput;
-            }
-            if (key === "SHIFT_TAB") {
-                this.focusPrev();
-                return currentOutput;
-            }
             const node = findFocused(currentTree, focusedId);
-            if (!node) {
-                return currentOutput;
-            }
-            if (node.tag === "terminal-button" && (key === "ENTER" || key === "SPACE")) {
-                invokeButton(node);
-                return rerender();
-            }
-            if (node.tag === "terminal-list") {
-                const id = node.props.id;
-                if (!id) {
-                    return currentOutput;
-                }
-                const items = Array.isArray(node.props.items) ? node.props.items : [];
-                const currentIndex = listIndexById.get(id) || 0;
-                if (key === "UP" || key === "LEFT") {
-                    const nextIndex = Math.max(0, currentIndex - 1);
-                    listIndexById.set(id, nextIndex);
-                    if (typeof node.props.onchange === "function") {
-                        const payload = { type: "change", id, index: nextIndex, value: items[nextIndex] };
-                        node.props.onchange(payload);
-                    }
-                    return rerender();
-                }
-                if (key === "DOWN" || key === "RIGHT") {
-                    const nextIndex = Math.min(items.length - 1, currentIndex + 1);
-                    listIndexById.set(id, nextIndex);
-                    if (typeof node.props.onchange === "function") {
-                        const payload = { type: "change", id, index: nextIndex, value: items[nextIndex] };
-                        node.props.onchange(payload);
-                    }
-                    return rerender();
-                }
-                if (key === "ENTER" && typeof node.props.onpress === "function") {
-                    const payload = { type: "press", id, index: currentIndex, value: items[currentIndex] };
-                    node.props.onpress(payload);
-                    return rerender();
-                }
+            const context = { key, focusedId: node?.props.id, focusedTag: node?.tag };
+            let command = resolveTerminalKeyBinding(keyBindings, context);
+            if (!command && node?.tag === "terminal-editor" && key.length === 1) {
+                command = { id: "editor.insertText", text: key };
             }
-            if (node.tag === "terminal-scroll") {
-                const id = node.props.id;
-                if (!id) {
-                    return currentOutput;
-                }
-                const rendered = mergeVertical(node.children.map(renderTerminalFrame));
-                const height = Number(node.props.height || rendered.lines.length || 0);
-                const currentOffset = scrollOffsetById.get(id) || 0;
-                const maxOffset = Math.max(0, rendered.lines.length - height);
-                if (key === "UP") {
-                    scrollOffsetById.set(id, Math.max(0, currentOffset - 1));
-                    return rerender();
-                }
-                if (key === "DOWN") {
-                    scrollOffsetById.set(id, Math.min(maxOffset, currentOffset + 1));
-                    return rerender();
-                }
+            if (!command && node?.tag === "terminal-editor" && key === "CTRL_V") {
+                command = { id: "editor.paste" };
             }
-            if (node.tag === "terminal-input") {
-                const id = node.props.id;
-                if (!id) {
-                    return currentOutput;
-                }
-                const currentValue = String(node.props.value ?? "");
-                const state = normalizeInputState(inputStateById.get(id), currentValue.length);
-                if (key === "ENTER") {
-                    submitInput(node);
-                    return rerender();
-                }
-                if (key === "LEFT") {
-                    replaceInputState(id, moveCursorLeft(state, currentValue.length));
-                    return rerender();
-                }
-                if (key === "RIGHT") {
-                    replaceInputState(id, moveCursorRight(state, currentValue.length));
-                    return rerender();
-                }
-                if (key === "SHIFT_LEFT") {
-                    replaceInputState(id, moveCursorLeft(state, currentValue.length, true));
-                    return rerender();
-                }
-                if (key === "SHIFT_RIGHT") {
-                    replaceInputState(id, moveCursorRight(state, currentValue.length, true));
-                    return rerender();
-                }
-                if (key === "ALT_LEFT") {
-                    replaceInputState(id, moveCursorWordLeft(currentValue, state));
-                    return rerender();
-                }
-                if (key === "ALT_RIGHT") {
-                    replaceInputState(id, moveCursorWordRight(currentValue, state));
-                    return rerender();
-                }
-                if (key === "HOME") {
-                    replaceInputState(id, moveCursorHome(state, currentValue.length));
-                    return rerender();
-                }
-                if (key === "END") {
-                    replaceInputState(id, moveCursorEnd(state, currentValue.length));
-                    return rerender();
-                }
-                if (key === "CTRL_A") {
-                    replaceInputState(id, selectAll(currentValue));
-                    return rerender();
-                }
-                if (key === "CTRL_C") {
-                    writeClipboard(copySelection(currentValue, state));
-                    return rerender();
-                }
-                if (key === "CTRL_X") {
-                    writeClipboard(copySelection(currentValue, state));
-                    if (hasSelection(state)) {
-                        return updateInputByState(node, insertText(currentValue, state, ""));
-                    }
-                    return currentOutput;
-                }
-                if (key === "CTRL_V") {
-                    return updateInputByState(node, insertText(currentValue, state, readClipboard()));
-                }
-                if (key === "BACKSPACE") {
-                    return updateInputByState(node, removeBackward(currentValue, state));
-                }
-                if (key === "DELETE") {
-                    return updateInputByState(node, removeForward(currentValue, state));
-                }
-                if (key.length === 1) {
-                    return updateInputByState(node, insertText(currentValue, state, key));
-                }
-            }
-            return currentOutput;
+            return command ? runCommand(command, node, context) : currentOutput;
         },
         click(id) {
             const node = id ? findFocusableById(currentTree, id) : findFocused(currentTree, focusedId);
@@ -487,11 +878,11 @@ export function mountTerminal(input, options = {}) {
             if (id) {
                 focusedId = node.props.id || focusedId;
             }
-            invokeButton(node);
+            dispatchButtonPressEvent(node, "press");
             return rerender();
         },
         clickAt(x, y) {
-            const hitbox = findHitboxAt(currentHitboxes, x, y);
+            const hitbox = resolvePointerTarget(currentHitboxes, x, y);
             if (!hitbox) {
                 clearSemanticHover(undefined, x, y);
                 return currentOutput;
@@ -523,31 +914,259 @@ export function mountTerminal(input, options = {}) {
             return rerender();
         },
         destroy() {
-            if (options.stdin) {
-                if (typeof options.stdin.off === "function") {
-                    options.stdin.off("data", onData);
+            if (destroyed) {
+                return;
+            }
+            destroyed = true;
+            cancelPendingEscapeFlush();
+            cleanupOutputResize?.();
+            cleanupOutputResize = null;
+            outputResizeScheduler.cancel();
+            renderScheduler.cancel();
+            terminalRuntime.destroy();
+            emitLifecycleRestore();
+            outputWriter.destroy();
+            if (runtimeOptions.stdin) {
+                if (typeof runtimeOptions.stdin.off === "function") {
+                    runtimeOptions.stdin.off("data", onData);
                 }
-                else if (typeof options.stdin.removeListener === "function") {
-                    options.stdin.removeListener("data", onData);
+                else if (typeof runtimeOptions.stdin.removeListener === "function") {
+                    runtimeOptions.stdin.removeListener("data", onData);
                 }
-                options.stdin.setRawMode?.(false);
-                options.stdin.pause?.();
+                runtimeOptions.stdin.setRawMode?.(false);
+                runtimeOptions.stdin.pause?.();
             }
         }
     };
-    const onData = (chunk) => {
-        const parsed = parseTerminalInput(chunk);
+    function dispatchPasteText(text) {
+        const node = findFocused(currentTree, focusedId);
+        if (node?.tag === "terminal-editor") {
+            runCommand({ id: "editor.pasteText", text }, node, { key: text, focusedId: node.props.id, focusedTag: node.tag });
+        }
+        else if (node?.tag === "terminal-input") {
+            runCommand({ id: "input.pasteText", text }, node, { key: text, focusedId: node.props.id, focusedTag: node.tag });
+        }
+    }
+    function cancelPendingEscapeFlush() {
+        if (pendingEscapeFlush) {
+            clearTimeout(pendingEscapeFlush);
+            pendingEscapeFlush = null;
+        }
+    }
+    function flushPendingEscape() {
+        cancelPendingEscapeFlush();
+        if (destroyed || !pendingKeyChunk.startsWith(ESCAPE)) {
+            return;
+        }
+        const buffered = pendingKeyChunk;
+        pendingKeyChunk = "";
+        session.dispatchKey(parseTerminalKey(ESCAPE));
+        processInputStream(buffered.slice(ESCAPE.length));
+    }
+    function schedulePendingEscapeFlush() {
+        cancelPendingEscapeFlush();
+        pendingEscapeFlush = setTimeout(flushPendingEscape, 0);
+    }
+    function processKeyStream(value) {
+        if (!value) {
+            return;
+        }
+        for (const sequence of KNOWN_TERMINAL_KEY_SEQUENCES) {
+            if (value.startsWith(sequence)) {
+                session.dispatchKey(parseTerminalKey(sequence));
+                processInputStream(value.slice(sequence.length));
+                return;
+            }
+        }
+        if (value === ESCAPE) {
+            pendingKeyChunk = value;
+            schedulePendingEscapeFlush();
+            return;
+        }
+        if (isDisambiguatedBracketedPasteStartPrefix(value)) {
+            pendingPasteChunk = value;
+            return;
+        }
+        if (isKnownTerminalKeySequencePrefix(value)) {
+            pendingKeyChunk = value;
+            schedulePendingEscapeFlush();
+            return;
+        }
+        const paste = parseBracketedPaste(value);
+        if (paste) {
+            dispatchPasteText(paste.text);
+            processInputStream(paste.rest);
+            return;
+        }
+        const escapeIndex = value.indexOf("\u001b");
+        if (escapeIndex > 0) {
+            for (const char of value.slice(0, escapeIndex)) {
+                session.dispatchKey(parseTerminalKey(char));
+            }
+            processInputStream(value.slice(escapeIndex));
+            return;
+        }
+        const parsedKey = parseTerminalKey(value);
+        if (parsedKey !== value) {
+            session.dispatchKey(parsedKey);
+            return;
+        }
+        if (value.startsWith("\u001b")) {
+            session.dispatchKey(value);
+            return;
+        }
+        for (const char of value) {
+            session.dispatchKey(parseTerminalKey(char));
+        }
+    }
+    function isPrimaryMouseButton(button) {
+        return button < 64 && (button & 3) === 0;
+    }
+    function isContextMouseButton(button) {
+        return button < 64 && (button & 3) === 2;
+    }
+    function isDoublePrimaryPress(hitbox, row) {
+        const now = Date.now();
+        const isDouble = Boolean(lastPrimaryPress
+            && lastPrimaryPress.id === hitbox.id
+            && lastPrimaryPress.tag === hitbox.tag
+            && lastPrimaryPress.row === row
+            && now - lastPrimaryPress.at <= DOUBLE_PRESS_INTERVAL_MS);
+        lastPrimaryPress = { id: hitbox.id, tag: hitbox.tag, row, at: now };
+        return isDouble;
+    }
+    function doublePressAt(hitbox, x, y) {
+        const node = findFocusableById(currentTree, hitbox.id);
+        if (!node) {
+            return currentOutput;
+        }
+        focusedId = hitbox.id;
+        setSemanticHoverFromHitbox(hitbox.id, x, y);
+        if (node.tag === "terminal-button") {
+            dispatchButtonPressEvent(node, "doublepress");
+            return rerender();
+        }
+        if (node.tag === "terminal-list") {
+            dispatchListPointerPressEvent(node, "doublepress", sourceRowFromHitbox(node, hitbox, y));
+            return rerender();
+        }
+        return currentOutput;
+    }
+    function contextPressAt(x, y) {
+        const hitbox = resolvePointerTarget(currentHitboxes, x, y);
+        if (!hitbox) {
+            clearSemanticHover(undefined, x, y);
+            return currentOutput;
+        }
+        const node = findFocusableById(currentTree, hitbox.id);
+        if (!node) {
+            return currentOutput;
+        }
+        focusedId = hitbox.id;
+        setSemanticHoverFromHitbox(hitbox.id, x, y);
+        if (node.tag === "terminal-button") {
+            dispatchButtonPressEvent(node, "contextpress");
+            return rerender();
+        }
+        if (node.tag === "terminal-list") {
+            dispatchListPointerPressEvent(node, "contextpress", sourceRowFromHitbox(node, hitbox, y));
+            return rerender();
+        }
+        if (node.tag === "terminal-input") {
+            dispatchInputContextPressEvent(node, hitbox, x, y);
+            return rerender();
+        }
+        if (node.tag === "terminal-scroll") {
+            dispatchScrollContextPressEvent(node, sourceRowFromHitbox(node, hitbox, y), x, y);
+            return rerender();
+        }
+        return currentOutput;
+    }
+    function processInputStream(value) {
+        if (!value) {
+            return;
+        }
+        if (pendingPasteChunk) {
+            pendingPasteChunk += value;
+            const paste = parseBracketedPaste(pendingPasteChunk);
+            if (!paste && isBracketedPasteStartPrefix(pendingPasteChunk)) {
+                return;
+            }
+            if (!paste) {
+                const buffered = pendingPasteChunk;
+                pendingPasteChunk = "";
+                processKeyStream(buffered);
+                return;
+            }
+            pendingPasteChunk = "";
+            dispatchPasteText(paste.text);
+            processInputStream(paste.rest);
+            return;
+        }
+        if (pendingKeyChunk) {
+            if (pendingKeyChunk === ESCAPE && !canContinueEscapeSequence(value)) {
+                flushPendingEscape();
+                processInputStream(value);
+                return;
+            }
+            const buffered = pendingKeyChunk + value;
+            cancelPendingEscapeFlush();
+            pendingKeyChunk = "";
+            processKeyStream(buffered);
+            return;
+        }
+        if (value === ESCAPE) {
+            processKeyStream(value);
+            return;
+        }
+        if (isBracketedPasteStartPrefix(value)) {
+            pendingPasteChunk = value;
+            return;
+        }
+        if (value.startsWith(BRACKETED_PASTE_START)) {
+            const paste = parseBracketedPaste(value);
+            if (!paste) {
+                pendingPasteChunk = value;
+                return;
+            }
+            dispatchPasteText(paste.text);
+            processInputStream(paste.rest);
+            return;
+        }
+        const parsed = parseTerminalInput(value);
         if (parsed.type === "mouse") {
             if (parsed.action === "press") {
-                const hitbox = findHitboxAt(currentHitboxes, parsed.x, parsed.y);
+                const hitbox = resolvePointerTarget(currentHitboxes, parsed.x, parsed.y);
+                if (isContextMouseButton(parsed.button)) {
+                    lastPrimaryPress = null;
+                    contextPressAt(parsed.x, parsed.y);
+                    return;
+                }
                 if (hitbox?.tag === "terminal-input") {
                     mouseSelectionId = hitbox.id;
                 }
                 const node = hitbox ? findFocusableById(currentTree, hitbox.id) : null;
                 if (hitbox && node && shouldPointerCapture(node)) {
-                    setPointerCapture(hitbox.id, "press", Math.max(1, Math.min(rowCountForNode(node), parsed.y - hitbox.y1 + 1)), parsed.x, parsed.y);
+                    setPointerCapture(hitbox.id, "press", sourceRowFromHitbox(node, hitbox, parsed.y), parsed.x, parsed.y);
+                }
+                const isPrimaryPress = isPrimaryMouseButton(parsed.button);
+                const isDoublePressEligible = Boolean(hitbox
+                    && node
+                    && (hitbox.tag === "terminal-button" || hitbox.tag === "terminal-list"));
+                const primaryPressRow = hitbox && node && hitbox.tag === "terminal-list"
+                    ? sourceRowFromHitbox(node, hitbox, parsed.y)
+                    : null;
+                const shouldDispatchDoublePress = Boolean(isPrimaryPress
+                    && isDoublePressEligible
+                    && hitbox
+                    && isDoublePrimaryPress(hitbox, primaryPressRow));
+                if (isPrimaryPress && !isDoublePressEligible) {
+                    lastPrimaryPress = null;
                 }
                 session.clickAt(parsed.x, parsed.y);
+                if (hitbox && shouldDispatchDoublePress) {
+                    doublePressAt(hitbox, parsed.x, parsed.y);
+                }
             }
             else if (parsed.action === "drag") {
                 if (mouseSelectionId) {
@@ -560,13 +1179,13 @@ export function mountTerminal(input, options = {}) {
             else if (parsed.action === "release") {
                 mouseSelectionId = null;
                 const capturedId = pointerCaptureId;
-                const releaseHitbox = findHitboxAt(currentHitboxes, parsed.x, parsed.y);
+                const releaseHitbox = resolvePointerTarget(currentHitboxes, parsed.x, parsed.y);
                 const releaseNode = releaseHitbox ? findFocusableById(currentTree, releaseHitbox.id) : null;
                 const releaseRow = releaseHitbox && releaseNode
-                    ? Math.max(1, Math.min(rowCountForNode(releaseNode), parsed.y - releaseHitbox.y1 + 1))
+                    ? sourceRowFromHitbox(releaseNode, releaseHitbox, parsed.y)
                     : null;
                 setPointerCapture(null, "release", capturedId && releaseHitbox?.id === capturedId ? releaseRow : null, parsed.x, parsed.y);
-                const hitbox = findHitboxAt(currentHitboxes, parsed.x, parsed.y);
+                const hitbox = resolvePointerTarget(currentHitboxes, parsed.x, parsed.y);
                 if (capturedId && hitbox && hitbox.id === capturedId && (hitbox.tag === "terminal-list" || hitbox.tag === "terminal-scroll")) {
                     setSemanticHoverFromHitbox(hitbox.id, parsed.x, parsed.y);
                     rerender();
@@ -577,23 +1196,63 @@ export function mountTerminal(input, options = {}) {
                 }
             }
             else if (parsed.action === "wheel-up") {
-                session.focusAt(parsed.x, parsed.y);
-                session.dispatchKey("UP");
+                wheelAt(parsed.x, parsed.y, -1);
             }
             else if (parsed.action === "wheel-down") {
-                session.focusAt(parsed.x, parsed.y);
-                session.dispatchKey("DOWN");
+                wheelAt(parsed.x, parsed.y, 1);
             }
             return;
         }
-        session.dispatchKey(parsed.key || parseTerminalKey(chunk));
+        processKeyStream(value);
+    }
+    const onData = (chunk) => {
+        const value = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        processInputStream(value);
     };
-    if (options.stdin) {
-        options.stdin.on("data", onData);
-        options.stdin.setRawMode?.(true);
-        options.stdin.resume?.();
+    if (runtimeOptions.stdin) {
+        runtimeOptions.stdin.on("data", onData);
+        runtimeOptions.stdin.setRawMode?.(true);
+        runtimeOptions.stdin.resume?.();
+    }
+    function subscribeOutputResize() {
+        const stdout = runtimeOptions.stdout;
+        if (!stdout || typeof stdout.on !== "function") {
+            return;
+        }
+        const removeResizeListener = typeof stdout.off === "function" ? stdout.off.bind(stdout) : stdout.removeListener?.bind(stdout);
+        if (!removeResizeListener) {
+            return;
+        }
+        const onResize = () => {
+            const cols = stdout.columns;
+            const rows = stdout.rows;
+            if (!isValidTerminalDimension(cols) || !isValidTerminalDimension(rows)) {
+                return;
+            }
+            pendingOutputResize = { cols, rows };
+            outputResizeScheduler.requestRender();
+        };
+        try {
+            stdout.on("resize", onResize);
+        }
+        catch {
+            return;
+        }
+        cleanupOutputResize = () => removeResizeListener("resize", onResize);
+    }
+    function applyPendingOutputResize() {
+        const nextSize = pendingOutputResize;
+        pendingOutputResize = null;
+        if (!nextSize || destroyed || (nextSize.cols === terminalSize.cols && nextSize.rows === terminalSize.rows)) {
+            return;
+        }
+        terminalSize = nextSize;
+        rerender();
     }
+    subscribeOutputResize();
+    emitLifecycleSetup();
     emitOutput();
+    autoProjectionEnabled = true;
     return session;
 }
 //# sourceMappingURL=session.js.map