@timurproko/a1 0.1.8-dev.137 → 0.1.8-dev.151

package/dist/integrations/pi/session-ui/session-viewport-controller.js

@@ -0,0 +1,369 @@
+import { TranscriptViewport, routeMouseInput, scrollForTrackPage, scrollForThumbRow, scrollbarSelectionRows, scrollbarWheelRows, } from "../../../ui/components/index.js";
+/**
+ * Owns the stateful interaction policy of the bare-A1 session viewport. The
+ * shell root supplies semantic rows and dock geometry; this controller owns
+ * follow state, selection, pointer latches, timers, and input routing.
+ */
+export class SessionViewportController {
+    #enabled;
+    #editor;
+    #requestRender;
+    #hasEditorLinks;
+    #viewport = new TranscriptViewport();
+    #config = {
+        scrollbarAppearance: "auto",
+        scrollbarStyle: "thin",
+        scrollbarSpeed: "normal",
+    };
+    #dragGrabOffset = null;
+    /** A left-button sequence begun in status/editor/footer chrome is swallowed. */
+    #dockPointerSuppressed = false;
+    /** True only while the editor owns a held left mouse button. */
+    #editorPointerSelecting = false;
+    /** Last composed terminal rows occupied by the default prompt editor. */
+    #editorPointerFrame;
+    #selectionAutoScrollTimer;
+    #selectionAutoScrollPointer;
+    #activityTimer;
+    constructor(options) {
+        this.#enabled = options.enabled;
+        this.#editor = options.editor;
+        this.#requestRender = options.requestRender;
+        this.#hasEditorLinks = options.hasEditorLinks ?? (() => false);
+    }
+    get config() {
+        return this.#config;
+    }
+    get editorPointerSelecting() {
+        return this.#editorPointerSelecting;
+    }
+    get transcriptPointerSelecting() {
+        return this.#viewport.selectionActive;
+    }
+    setEditorPointerFrame(frame) {
+        this.#editorPointerFrame = frame;
+    }
+    compose(input) {
+        this.#viewport.setConfig(this.#config);
+        return this.#viewport.compose(input);
+    }
+    /** Returns true when document wrapping may have changed. */
+    setConfig(config) {
+        const appearanceChanged = config.scrollbarAppearance !== this.#config.scrollbarAppearance;
+        this.#config = config;
+        this.#viewport.setConfig(config);
+        this.#requestRender();
+        return appearanceChanged;
+    }
+    resumeFollowing() {
+        if (!this.#enabled)
+            return;
+        this.#stopSelectionAutoScroll();
+        const selectionChanged = this.#viewport.clearSelection();
+        const scrolled = this.#viewport.scrollToEnd();
+        if (scrolled)
+            this.#scheduleActivityExpiry();
+        if (scrolled || selectionChanged)
+            this.#requestRender();
+    }
+    noteCompletedAssistantMessage() {
+        if (!this.#enabled || !this.#viewport.noteNewMessage())
+            return;
+        this.#requestRender();
+    }
+    reset() {
+        this.#clearActivityTimer();
+        this.#stopSelectionAutoScroll();
+        this.#editorPointerSelecting = false;
+        this.#editorPointerFrame = undefined;
+        this.#viewport.reset();
+    }
+    clearPointerState() {
+        this.#clearActivityTimer();
+        this.#dragGrabOffset = null;
+        this.#dockPointerSuppressed = false;
+        this.#editorPointerSelecting = false;
+        this.#editorPointerFrame = undefined;
+        this.#stopSelectionAutoScroll();
+        this.#viewport.clearSelection();
+        this.#viewport.clearTransient();
+    }
+    handlePreInput(data, allowWheel = true, now = Date.now()) {
+        if (!this.#enabled)
+            return { data, consumed: false };
+        // Pi components share one keybinding manager. Restore bare A1's aliases
+        // before the focused vanilla editor handles this input.
+        this.#editor.activateKeybindings();
+        // Handle the physical paste chord at the pre-input boundary. Windows
+        // terminals vary between forwarding Ctrl+V and terminal-owned bracketed paste.
+        if (this.#editor.matchesTerminalKey(data, "ctrl+v") && this.#editor.pasteClipboard()) {
+            return { data: "", consumed: true };
+        }
+        // URL chip deletion must overwrite terminal link cells in the same frame.
+        if (EDITOR_LINK_DELETION_INPUTS.has(data) && this.#hasEditorLinks())
+            this.#requestRender(true);
+        if (this.#viewport.frame === null)
+            return { data, consumed: false };
+        if (data === "\u0003") {
+            if (this.#editor.hasSelection()) {
+                if (this.#viewport.clearSelection())
+                    this.#requestRender();
+            }
+            else {
+                const copyText = this.#viewport.selectedText();
+                if (copyText !== null && copyText.length > 0) {
+                    this.#viewport.clearSelection();
+                    this.#requestRender();
+                    return { data: "", consumed: true, copyText };
+                }
+            }
+        }
+        if (allowWheel && this.#editor.matchesTerminalKey(data, "home")) {
+            if (this.#viewport.scrollTo(0, now)) {
+                this.#scheduleActivityExpiry();
+                this.#requestRender();
+            }
+            return { data: "", consumed: true };
+        }
+        if (allowWheel && this.#editor.matchesTerminalKey(data, "end")) {
+            if (!this.#viewport.followingEnd) {
+                this.#viewport.scrollToEnd(now);
+                this.#scheduleActivityExpiry();
+                this.#requestRender();
+            }
+            return { data: "", consumed: true };
+        }
+        if (allowWheel && (SHIFT_UP_INPUTS.has(data) || SHIFT_DOWN_INPUTS.has(data))) {
+            const scrolled = SHIFT_UP_INPUTS.has(data)
+                ? this.#viewport.scrollToPreviousPrompt(now)
+                : this.#viewport.scrollToNextPrompt(now);
+            if (scrolled) {
+                this.#scheduleActivityExpiry();
+                this.#requestRender();
+            }
+            return { data: "", consumed: true };
+        }
+        if (!data.includes("\u001b[<") && data !== "\u0003" && this.#viewport.clearSelection()) {
+            this.#requestRender();
+        }
+        const frame = this.#viewport.frame;
+        let repaint = false;
+        let forceRepaint = false;
+        let activity = false;
+        const routed = routeMouseInput(data, event => {
+            const hits = frame.hits;
+            const overRail = hits.rail !== null
+                && event.column === hits.rail.column
+                && event.row >= hits.rail.rowStart
+                && event.row < hits.rail.rowStart + hits.rail.trackHeight;
+            const overSticky = hits.sticky !== null && event.row === hits.sticky.row && event.column <= hits.sticky.width;
+            const overBottom = hits.bottom !== null && event.row === hits.bottom.row
+                && event.column >= hits.bottom.columnStart && event.column <= hits.bottom.columnEnd;
+            if (event.kind === "motion") {
+                this.#viewport.setRailHovered(overRail);
+                this.#viewport.setStickyHovered(overSticky);
+                this.#viewport.setBottomHovered(overBottom);
+                repaint = true;
+                if (this.#editor.ownsPointer() && this.#editorPointerFrame !== undefined) {
+                    this.#editor.handlePointer({
+                        kind: "motion",
+                        button: event.button,
+                        column: event.column,
+                        row: event.row - this.#editorPointerFrame.rowStart + 1,
+                    });
+                    return true;
+                }
+                if (this.#dockPointerSuppressed)
+                    return true;
+                if (this.#viewport.selectionActive) {
+                    this.#viewport.extendSelection(event.column, event.row, now, false);
+                    this.#updateSelectionAutoScroll(event.column, event.row, hits.viewportHeight);
+                    activity = true;
+                    return true;
+                }
+                if (this.#dragGrabOffset !== null && hits.rail !== null) {
+                    const target = scrollForThumbRow(hits.rail.geometry, event.row - hits.rail.rowStart - this.#dragGrabOffset);
+                    this.#viewport.scrollTo(target, now);
+                    activity = true;
+                    return true;
+                }
+                return overRail || overSticky || overBottom;
+            }
+            if (event.kind === "wheel-up" || event.kind === "wheel-down") {
+                if (!allowWheel || event.row < 1 || event.row > hits.viewportHeight)
+                    return false;
+                const distance = scrollbarWheelRows(this.#config.scrollbarSpeed);
+                this.#viewport.scrollBy(event.kind === "wheel-up" ? -distance : distance, now);
+                activity = true;
+                repaint = true;
+                forceRepaint = true;
+                return true;
+            }
+            if (event.kind === "press") {
+                const editorFrame = this.#editorPointerFrame;
+                if (event.button === 2 && editorFrame !== undefined
+                    && event.row >= editorFrame.rowStart && event.row <= editorFrame.rowEnd) {
+                    this.#stopSelectionAutoScroll();
+                    if (this.#viewport.clearSelection())
+                        repaint = true;
+                    this.#editor.pasteClipboard();
+                    this.#dockPointerSuppressed = true;
+                    repaint = true;
+                    return true;
+                }
+                if (event.button !== 0)
+                    return false;
+                this.#stopSelectionAutoScroll();
+                if (this.#viewport.clearSelection())
+                    repaint = true;
+                if (overBottom) {
+                    this.#viewport.scrollToEnd(now);
+                    activity = true;
+                    repaint = true;
+                    return true;
+                }
+                if (overSticky && hits.sticky !== null) {
+                    this.#viewport.scrollTo(hits.sticky.target, now);
+                    activity = true;
+                    repaint = true;
+                    return true;
+                }
+                if (overRail && hits.rail !== null) {
+                    const trackRow = event.row - hits.rail.rowStart;
+                    const geometry = hits.rail.geometry;
+                    if (trackRow >= geometry.thumbTop && trackRow < geometry.thumbTop + geometry.thumbHeight) {
+                        this.#dragGrabOffset = trackRow - geometry.thumbTop;
+                        this.#viewport.setRailDragging(true);
+                    }
+                    else {
+                        this.#viewport.scrollTo(scrollForTrackPage(geometry, trackRow, frame.scrollTop, hits.viewportHeight), now);
+                    }
+                    activity = true;
+                    repaint = true;
+                    return true;
+                }
+                if (editorFrame !== undefined && event.row >= editorFrame.rowStart && event.row <= editorFrame.rowEnd) {
+                    const handled = this.#editor.handlePointer({
+                        kind: "press",
+                        button: event.button,
+                        column: event.column,
+                        row: event.row - editorFrame.rowStart + 1,
+                    });
+                    if (!handled)
+                        this.#dockPointerSuppressed = true;
+                    this.#editorPointerSelecting = handled;
+                    repaint = true;
+                    return true;
+                }
+                if (event.row > hits.viewportHeight) {
+                    this.#dockPointerSuppressed = true;
+                    return true;
+                }
+                if (event.row >= 1 && event.row <= hits.viewportHeight && event.column <= frame.contentWidth) {
+                    this.#viewport.pressSelection(event.column, event.row, now);
+                    repaint = true;
+                    return true;
+                }
+                return false;
+            }
+            if (event.kind === "release") {
+                if (this.#editor.ownsPointer() && this.#editorPointerFrame !== undefined) {
+                    const wasEditorSelecting = this.#editorPointerSelecting;
+                    this.#editor.handlePointer({
+                        kind: "release",
+                        button: event.button,
+                        column: event.column,
+                        row: event.row - this.#editorPointerFrame.rowStart + 1,
+                    });
+                    this.#editorPointerSelecting = false;
+                    forceRepaint ||= wasEditorSelecting;
+                    repaint = true;
+                    return true;
+                }
+                if (this.#viewport.releaseSelection()) {
+                    this.#stopSelectionAutoScroll();
+                    // Restore OSC 8 links only after the held-button selection paint has
+                    // ended, then overwrite any terminal-cached hover cells immediately.
+                    forceRepaint = true;
+                    repaint = true;
+                    return true;
+                }
+                if (this.#dragGrabOffset !== null) {
+                    this.#dragGrabOffset = null;
+                    this.#viewport.setRailDragging(false);
+                    repaint = true;
+                    return true;
+                }
+                if (this.#dockPointerSuppressed) {
+                    this.#dockPointerSuppressed = false;
+                    return true;
+                }
+            }
+            return false;
+        });
+        if (activity)
+            this.#scheduleActivityExpiry();
+        if (repaint)
+            this.#requestRender(forceRepaint);
+        return routed;
+    }
+    #updateSelectionAutoScroll(column, row, viewportHeight) {
+        const beyondEdge = row <= 1 || row > viewportHeight;
+        if (!beyondEdge) {
+            this.#stopSelectionAutoScroll();
+            return;
+        }
+        this.#selectionAutoScrollPointer = { column, row };
+        if (this.#selectionAutoScrollTimer !== undefined)
+            return;
+        this.#selectionAutoScrollTimer = setTimeout(() => this.#selectionAutoScrollTick(), SELECTION_AUTO_SCROLL_INTERVAL_MS);
+        this.#selectionAutoScrollTimer.unref?.();
+    }
+    #selectionAutoScrollTick() {
+        this.#selectionAutoScrollTimer = undefined;
+        const pointer = this.#selectionAutoScrollPointer;
+        if (pointer === undefined || !this.#viewport.selectionActive) {
+            this.#stopSelectionAutoScroll();
+            return;
+        }
+        const before = this.#viewport.scrollTop;
+        const rowsPerTick = scrollbarSelectionRows(this.#config.scrollbarSpeed);
+        for (let row = 0; row < rowsPerTick; row += 1) {
+            const previous = this.#viewport.scrollTop;
+            this.#viewport.extendSelection(pointer.column, pointer.row);
+            if (this.#viewport.scrollTop === previous)
+                break;
+        }
+        if (this.#viewport.scrollTop === before) {
+            this.#stopSelectionAutoScroll();
+            return;
+        }
+        this.#requestRender();
+        this.#scheduleActivityExpiry();
+        this.#selectionAutoScrollTimer = setTimeout(() => this.#selectionAutoScrollTick(), SELECTION_AUTO_SCROLL_INTERVAL_MS);
+        this.#selectionAutoScrollTimer.unref?.();
+    }
+    #stopSelectionAutoScroll() {
+        if (this.#selectionAutoScrollTimer !== undefined)
+            clearTimeout(this.#selectionAutoScrollTimer);
+        this.#selectionAutoScrollTimer = undefined;
+        this.#selectionAutoScrollPointer = undefined;
+    }
+    #clearActivityTimer() {
+        if (this.#activityTimer !== undefined)
+            clearTimeout(this.#activityTimer);
+        this.#activityTimer = undefined;
+    }
+    #scheduleActivityExpiry() {
+        this.#clearActivityTimer();
+        this.#activityTimer = setTimeout(() => {
+            this.#activityTimer = undefined;
+            this.#requestRender();
+        }, 925);
+        this.#activityTimer.unref?.();
+    }
+}
+const SELECTION_AUTO_SCROLL_INTERVAL_MS = 30;
+const EDITOR_LINK_DELETION_INPUTS = new Set(["\b", "\u007f", "\u001b[3~"]);
+const SHIFT_UP_INPUTS = new Set(["\u001b[1;2A"]);
+const SHIFT_DOWN_INPUTS = new Set(["\u001b[1;2B"]);

package/dist/integrations/pi/session-ui/system-clipboard.d.ts

@@ -0,0 +1,11 @@
+import type { PiShellClipboardContent } from "../components/index.js";
+/** Load the native adapter during shell startup so the first paste is warm. */
+export declare function preloadSystemClipboard(): void;
+/**
+ * Reads plain text through platform clipboard commands without importing Pi's
+ * private clipboard module. Failures are deliberately non-fatal: a denied or
+ * unavailable clipboard simply makes the paste action a no-op.
+ */
+export declare function readSystemClipboardContent(): Promise<PiShellClipboardContent | null>;
+export declare function readSystemClipboardText(): Promise<string | null>;
+export declare function writeSystemClipboardText(text: string): Promise<void>;

package/dist/integrations/pi/session-ui/system-clipboard.js

@@ -0,0 +1,101 @@
+import { execFile } from "node:child_process";
+const MAX_CLIPBOARD_BYTES = 16 * 1024 * 1024;
+let nativeClipboardPromise;
+let pendingClipboardWrite = Promise.resolve();
+/** Load the native adapter during shell startup so the first paste is warm. */
+export function preloadSystemClipboard() {
+    if (process.platform === "win32" || process.platform === "darwin")
+        void nativeClipboard();
+}
+/**
+ * Reads plain text through platform clipboard commands without importing Pi's
+ * private clipboard module. Failures are deliberately non-fatal: a denied or
+ * unavailable clipboard simply makes the paste action a no-op.
+ */
+export async function readSystemClipboardContent() {
+    await pendingClipboardWrite;
+    const native = await nativeClipboard();
+    if (native !== null) {
+        try {
+            if (process.platform === "win32" && native.availableFormats().some(isFileDropFormat)) {
+                const files = await readSystemClipboardText();
+                if (files !== null)
+                    return { kind: "text", text: files };
+            }
+            if (native.hasImage()) {
+                const data = await native.getImageBase64();
+                if (data.length > 0)
+                    return { kind: "image", data, mimeType: "image/png" };
+            }
+        }
+        catch {
+            // Fall through to text and platform readers.
+        }
+    }
+    const text = await readSystemClipboardText();
+    return text === null ? null : { kind: "text", text };
+}
+export async function readSystemClipboardText() {
+    // Ctrl+C/Ctrl+X and Ctrl+V can arrive in adjacent input turns. Serialize the
+    // read behind our native write so paste never observes the previous value.
+    await pendingClipboardWrite;
+    if (process.platform === "win32" || process.platform === "darwin") {
+        const native = await nativeClipboard();
+        if (native !== null) {
+            try {
+                const text = await native.getText();
+                if (text.length > 0)
+                    return text;
+            }
+            catch {
+                // Fall through to the platform command.
+            }
+        }
+    }
+    if (process.platform === "win32") {
+        const script = [
+            "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8",
+            "$t=Get-Clipboard -Raw -ErrorAction SilentlyContinue",
+            "if ($null -ne $t -and $t.Length -gt 0) {[Console]::Out.Write($t)} else {$f=Get-Clipboard -Format FileDropList -ErrorAction SilentlyContinue; if ($f) {[Console]::Out.Write(($f | ForEach-Object {$_.FullName}) -join [Environment]::NewLine)}}",
+        ].join("; ");
+        return execClipboard("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script]);
+    }
+    if (process.platform === "darwin")
+        return execClipboard("pbpaste", []);
+    return (await execClipboard("wl-paste", ["--no-newline", "--type", "text"]))
+        ?? execClipboard("xclip", ["-selection", "clipboard", "-o"]);
+}
+export function writeSystemClipboardText(text) {
+    const write = async () => {
+        const native = await nativeClipboard();
+        if (native !== null) {
+            try {
+                await native.setText(text);
+                return;
+            }
+            catch {
+                // The caller still emits its terminal clipboard fallback.
+            }
+        }
+    };
+    const operation = pendingClipboardWrite.then(write, write);
+    pendingClipboardWrite = operation.catch(() => { });
+    return operation;
+}
+function nativeClipboard() {
+    nativeClipboardPromise ??= import("@mariozechner/clipboard").catch(() => null);
+    return nativeClipboardPromise;
+}
+function isFileDropFormat(format) {
+    return /(?:filedrop|hdrop|shell idlist)/iu.test(format);
+}
+function execClipboard(command, args) {
+    return new Promise(resolve => {
+        execFile(command, args, {
+            encoding: "utf8",
+            maxBuffer: MAX_CLIPBOARD_BYTES,
+            timeout: 5_000,
+            windowsHide: true,
+        }, (error, stdout) => resolve(error || stdout.length === 0 ? null : stdout));
+    });
+}

package/dist/integrations/pi/tui-runtime/adapter.d.ts

@@ -1,4 +1,4 @@
-import type { PiTuiComponentPort, PiTuiInputListener, PiTuiOverlayHandle, PiTuiOverlayOptions, PiTuiRuntimeAdapterOptions, PiTuiRuntimeState, PiTuiScrollState, PiTuiStopOptions, PiTuiViewport } from "./contracts.js";
+import type { PiTuiComponentPort, PiTuiInputListener, PiTuiOverlayHandle, PiTuiOverlayOptions, PiTuiPreInputListener, PiTuiRuntimeAdapterOptions, PiTuiRuntimeState, PiTuiScrollState, PiTuiStopOptions, PiTuiViewport } from "./contracts.js";
 export type PiTuiRuntimeErrorStage = "construction" | "start" | "input-drain" | "restoration";
 export declare class PiTuiRuntimeError extends Error {
     readonly stage: PiTuiRuntimeErrorStage;
@@ -26,6 +26,7 @@ export declare class PiTuiRuntimeAdapter {
      * the transparent and pinned paths never call it.
      */
     writeControl(data: string): void;
+    addPreInputListener(listener: PiTuiPreInputListener): () => void;
     addInputListener(listener: PiTuiInputListener): () => void;
     switchMode(mode: "regular" | "fullscreen"): boolean;
     setHardwareCursor(enabled: boolean): void;

package/dist/integrations/pi/tui-runtime/adapter.js

@@ -81,6 +81,7 @@ class OverlayHandleBridge {
 }
 export class PiTuiRuntimeAdapter {
     #terminal;
+    #tuiTerminal;
     #tui;
     #root;
     #layoutRoot;
@@ -92,12 +93,14 @@ export class PiTuiRuntimeAdapter {
     #scrollViews = new Map();
     #overlayDisposers = new Set();
     #inputListeners = new Map();
+    #preInputListeners = new Set();
     #state = "idle";
     #stopPromise;
     #rootDisposed = false;
     constructor(options) {
         this.#root = options.root;
         this.#terminal = options.terminal ?? new ProcessTerminal();
+        this.#tuiTerminal = preInputTerminal(this.#terminal, data => this.#routePreInput(data));
         this.#layoutRoot = options.layoutRoot;
         this.#logDirectory = options.logDirectory;
         this.#rootBridge = new ComponentBridge(options.root);
@@ -239,6 +242,12 @@ export class PiTuiRuntimeAdapter {
         this.#assertRunning("control sequence");
         this.#terminal.write(data);
     }
+    addPreInputListener(listener) {
+        if (this.#preInputListeners.has(listener))
+            throw new TypeError("Pi TUI pre-input listener is already registered");
+        this.#preInputListeners.add(listener);
+        return () => this.#preInputListeners.delete(listener);
+    }
     addInputListener(listener) {
         this.#assertRunning("input listener");
         if (this.#inputListeners.has(listener))
@@ -313,6 +322,7 @@ export class PiTuiRuntimeAdapter {
             return this.#stopPromise;
         if (this.#state === "idle") {
             this.#state = "stopped";
+            this.#preInputListeners.clear();
             this.#disposeRoot();
             return Promise.resolve();
         }
@@ -352,8 +362,21 @@ export class PiTuiRuntimeAdapter {
     }
     #createTui(mode, hardwareCursor) {
         return mode === "fullscreen"
-            ? new TuiAltScreen(this.#terminal, hardwareCursor, this.#logDirectory, this.#tuiOptions)
-            : new TuiMainScreen(this.#terminal, hardwareCursor, this.#logDirectory);
+            ? new TuiAltScreen(this.#tuiTerminal, hardwareCursor, this.#logDirectory, this.#tuiOptions)
+            : new TuiMainScreen(this.#tuiTerminal, hardwareCursor, this.#logDirectory);
+    }
+    #routePreInput(data) {
+        let current = data;
+        for (const listener of this.#preInputListeners) {
+            if (current.length === 0)
+                break;
+            const result = listener(current);
+            if (result?.data !== undefined)
+                current = result.data;
+            else if (result?.consume === true)
+                current = "";
+        }
+        return current;
     }
     #mountTui(tui) {
         tui.addChild(this.#rootBridge);
@@ -458,11 +481,37 @@ export class PiTuiRuntimeAdapter {
         for (const remove of this.#inputListeners.values())
             remove();
         this.#inputListeners.clear();
+        this.#preInputListeners.clear();
         for (const dispose of [...this.#overlayDisposers])
             dispose();
         this.#disposeRoot();
     }
 }
+function preInputTerminal(terminal, route) {
+    return {
+        get columns() { return terminal.columns; },
+        get rows() { return terminal.rows; },
+        get kittyProtocolActive() { return terminal.kittyProtocolActive; },
+        start(onInput, onResize) {
+            terminal.start(data => {
+                const routed = route(data);
+                if (routed.length > 0)
+                    onInput(routed);
+            }, onResize);
+        },
+        stop: () => terminal.stop(),
+        drainInput: (maxMs, idleMs) => terminal.drainInput(maxMs, idleMs),
+        write: data => terminal.write(data),
+        moveBy: lines => terminal.moveBy(lines),
+        hideCursor: () => terminal.hideCursor(),
+        showCursor: () => terminal.showCursor(),
+        clearLine: () => terminal.clearLine(),
+        clearFromCursor: () => terminal.clearFromCursor(),
+        clearScreen: () => terminal.clearScreen(),
+        setTitle: title => terminal.setTitle(title),
+        setProgress: active => terminal.setProgress(active),
+    };
+}
 function toOverlayOptions(options) {
     if (options === undefined)
         return undefined;

package/dist/integrations/pi/tui-runtime/contracts.d.ts

@@ -1,3 +1,4 @@
+import type { PresentationComponentPort } from "../../../contracts/presentation/index.js";
 export type PiTuiRuntimeState = "idle" | "running" | "stopping" | "stopped" | "failed";
 export interface PiTuiViewport {
     readonly columns: number;
@@ -9,13 +10,8 @@ export interface PiTuiScrollState {
     readonly followingEnd: boolean;
     readonly scrollbarVisible: boolean;
 }
-export interface PiTuiComponentPort {
-    render(width: number): readonly string[];
-    invalidate(): void;
-    handleInput?(data: string): void;
+export interface PiTuiComponentPort extends PresentationComponentPort {
     readonly wantsKeyRelease?: boolean;
-    setFocused?(focused: boolean): void;
-    dispose?(): void;
 }
 export interface PiTuiTerminalPort {
     start(onInput: (data: string) => void, onResize: () => void): void;
@@ -71,6 +67,8 @@ export interface PiTuiInputListenerResult {
     readonly data?: string;
 }
 export type PiTuiInputListener = (data: string) => PiTuiInputListenerResult | undefined;
+/** Runs at the terminal bridge before Pi TUI receives physical input. */
+export type PiTuiPreInputListener = PiTuiInputListener;
 export interface PiTuiLayoutEntry {
     readonly node: PiTuiLayoutNode;
     readonly basis?: number | "auto";

package/dist/native/darwin-arm64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "unsupported",
-  "builtAt": "2026-08-26T06:22:58.678Z",
+  "builtAt": "2026-08-28T10:16:08.776Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "7524bf568992517f50ed53196c861c5edeba0d7275633bb4735ab45bd5963a28",

package/dist/native/linux-x64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-26T06:22:53.598Z",
+  "builtAt": "2026-08-28T10:16:08.593Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "ee8a00eaaf79c707459bbbfb52518e9739314967049fbe5fa625f36ce33db9ee",

package/dist/native/win32-x64/manifest.json

@@ -5,11 +5,11 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-26T06:23:46.974Z",
+  "builtAt": "2026-08-28T10:16:41.229Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "7b6350b01d875ee3d0db81a1ed5126df5e4a796b93c9ea146e9f24d1f1ab5a2e",
-    "size": 172544
+    "sha256": "8daa77c737ea8f96eb022fce63a25a4fce3e5d15c409201712a7f36853c8e8e4",
+    "size": 177664
   },
   "provenance": {
     "language": "Rust",