@timurproko/a1 0.2.7-dev.1252 → 0.2.7-dev.1264

package/dist/app/session-shell/system-clipboard.js

@@ -5,11 +5,6 @@ import { assertSourceBytes } from "./image-source.js";
 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
@@ -38,7 +33,7 @@ export async function readSystemClipboardContent(signal, strict = false) {
     const text = await readSystemClipboardText(signal, strict);
     return text === null ? null : { kind: "text", text };
 }
-export async function readSystemClipboardImage(reader) {
+async function readSystemClipboardImage(reader) {
     if (!reader.hasImage())
         return null;
     if (reader.getImageBinary !== undefined) {
@@ -74,7 +69,7 @@ export async function readSystemClipboardImage(reader) {
     }
     return null;
 }
-export async function readSystemClipboardText(signal, strict = false) {
+async function readSystemClipboardText(signal, strict = false) {
     // Concurrency: 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;

package/dist/app/session-shell/transcript-document.d.ts

@@ -1,6 +1,7 @@
+import type { OwnedUiShellComponents, OwnedUiShellTranscriptComponentPort } from "../../contracts/owned-ui/index.js";
 import type { OwnedUiSessionViewModel } from "../../contracts/owned-ui/index.js";
+import type { ThemeSource } from "../../contracts/presentation/index.js";
 import type { TranscriptPromptAnchor } from "../../ui/components/transcript-viewport.js";
-import type { PiShellTranscriptComponentPort } from "../../integrations/pi/components/shell-shared-facade.js";
 type TranscriptBlock = OwnedUiSessionViewModel["transcript"][number];
 export interface TranscriptDocumentLayout {
     readonly rows: readonly string[];
@@ -13,7 +14,7 @@ export interface TranscriptDocumentLayout {
  */
 export type TranscriptInvalidation = "editor-padding" | "diagnostics" | "workflow-status" | "extension-header" | "viewport-config" | "extension-renderers" | "block-presentation" | "tools-expanded" | "repaint";
 /** What the document reads from the shell around it on every uncached layout. */
-export interface TranscriptDocumentChrome {
+interface TranscriptDocumentChrome {
     diagnostics(): OwnedUiSessionViewModel["diagnostics"];
     /** The extension header's rows when one is set, else the built-in header's rows for this layout. */
     headerRows(width: number): readonly string[];
@@ -23,11 +24,13 @@ export interface TranscriptDocumentChrome {
     hasExtensionHeader(): boolean;
     thinkingVisible(): boolean;
 }
-export interface TranscriptDocumentOptions {
+interface TranscriptDocumentOptions {
+    readonly theme: ThemeSource;
+    readonly components: Pick<OwnedUiShellComponents, "info" | "transcript">;
     readonly customViewport: boolean;
     readonly cwd: string;
     /** Creates the component for a newly seen block; its change callback should call `blockChanged`. */
-    mount(block: TranscriptBlock): PiShellTranscriptComponentPort;
+    mount(block: TranscriptBlock): OwnedUiShellTranscriptComponentPort;
     readonly chrome: TranscriptDocumentChrome;
 }
 /**
@@ -40,8 +43,8 @@ export declare class TranscriptDocument {
     /** Block component renders since construction, for rendering evidence. */
     get renderCount(): number;
     get lastId(): string | undefined;
-    component(id: string): PiShellTranscriptComponentPort | undefined;
-    components(): IterableIterator<PiShellTranscriptComponentPort>;
+    component(id: string): OwnedUiShellTranscriptComponentPort | undefined;
+    components(): IterableIterator<OwnedUiShellTranscriptComponentPort>;
     anchorOf(id: string): number | undefined;
     /**
      * Applies one block: its component is created or updated in place and the order grows
@@ -52,7 +55,7 @@ export declare class TranscriptDocument {
     /** Replaces the whole transcript with the view's blocks, keeping anchored workflow output in place. */
     sync(blocks: OwnedUiSessionViewModel["transcript"]): void;
     /** Appends workflow output anchored after the transcript's first `anchor` blocks. */
-    appendAnchored(id: string, component: PiShellTranscriptComponentPort, anchor: number): void;
+    appendAnchored(id: string, component: OwnedUiShellTranscriptComponentPort, anchor: number): void;
     /** Disposes every anchored workflow output and drops it from the order. */
     removeAnchored(): void;
     /** One block's component drew something new: drop its rows and every layout that contains them. */
@@ -73,5 +76,5 @@ export declare function parseReleaseUpdateDiagnostic(message: string): {
     changelogUrl: string | null;
 } | null;
 /** Web URLs use link blue; file targets retain A1's cyan interactive accent. */
-export declare function nativeTranscriptLinkColor(text: string, target: string): string;
+export declare function transcriptLinkColor(theme: ThemeSource): (text: string, target: string) => string;
 export {};

package/dist/app/session-shell/transcript-document.js

@@ -1,8 +1,5 @@
 import { acceptsTranscriptUpdate } from "../../contracts/owned-ui/index.js";
 import { nativeHyperlinkStyle } from "../../ui/components/spans.js";
-import { createPiShellChangelog, createPiShellCollapsedChangelog, renderPiShellPackageUpdateNotice, renderPiShellReleaseUpdateNotice, } from "../../integrations/pi/components/shell-presenters-info.js";
-import { isPiPromptStyleCompaction, renderPiShellStartupDiagnostic, renderPiShellTranscriptBlock, } from "../../integrations/pi/components/shell-presenters-transcript.js";
-import { piTheme } from "../../integrations/pi/components/upstream/theme/theme.js";
 const LAYOUT_ONLY = new Set(["editor-padding", "diagnostics", "workflow-status", "extension-header"]);
 const WORKFLOW_STATUS_PREFIX = "workflow-status-";
 /**
@@ -19,8 +16,10 @@ export class TranscriptDocument {
     // Performance: document layouts are shared by wheel, rail, jump, and selection frames.
     #layouts = new Map();
     #renders = 0;
+    #linkColor;
     constructor(options) {
         this.#options = options;
+        this.#linkColor = transcriptLinkColor(options.theme);
     }
     /** Block component renders since construction, for rendering evidence. */
     get renderCount() {
@@ -171,7 +170,7 @@ export class TranscriptDocument {
             // bare A1 presents them in its prompt-adjacent notice dock instead.
             .filter(diagnostic => diagnostic.code === "engine-startup"
             || !customViewport && diagnostic.code === "project-trust")
-            .flatMap(diagnostic => renderPiShellStartupDiagnostic(diagnostic, width));
+            .flatMap(diagnostic => this.#options.components.transcript.renderStartupDiagnostic(diagnostic, width));
         const resourceRows = [...chrome.resourceRows(width)];
         if (resourceRows.at(-1) === "")
             resourceRows.pop();
@@ -191,7 +190,7 @@ export class TranscriptDocument {
             if (!thinkingVisible && block?.kind === "thinking")
                 continue;
             const promptLike = block !== undefined
-                && (block.kind === "user" || customViewport && isPiPromptStyleCompaction(block));
+                && (block.kind === "user" || customViewport && this.#options.components.transcript.isPromptStyleCompaction(block));
             // Invariant: the custom viewport has already removed its rail gutter from this width.
             // Prompt-like and ordinary blocks therefore share one right content edge.
             const blockWidth = width;
@@ -240,11 +239,11 @@ export class TranscriptDocument {
             .filter(diagnostic => !customViewport && diagnostic.code === "release-update")
             .flatMap(diagnostic => {
             const release = parseReleaseUpdateDiagnostic(diagnostic.message);
-            return release === null ? [] : renderPiShellReleaseUpdateNotice(release, width);
+            return release === null ? [] : this.#options.components.info.releaseUpdateNotice(release, width);
         }));
         rows.push(...diagnostics
             .filter(diagnostic => diagnostic.code === "package-updates")
-            .flatMap(diagnostic => renderPiShellPackageUpdateNotice(diagnostic.message.split("\n").filter(line => line.startsWith("- ")).map(line => line.slice(2)), width)));
+            .flatMap(diagnostic => this.#options.components.info.packageUpdateNotice(diagnostic.message.split("\n").filter(line => line.startsWith("- ")).map(line => line.slice(2)), width)));
         rows.push(...diagnostics
             .filter(diagnostic => diagnostic.code === "changelog-collapsed" || diagnostic.code === "changelog-expanded")
             // Rationale: bare A1 translates either startup diagnostic into transient dock chrome;
@@ -252,8 +251,8 @@ export class TranscriptDocument {
             .flatMap(diagnostic => customViewport
             ? []
             : diagnostic.code === "changelog-collapsed"
-                ? createPiShellCollapsedChangelog().render(width)
-                : createPiShellChangelog(diagnostic.message).render(width)));
+                ? this.#options.components.info.collapsedChangelog().render(width)
+                : this.#options.components.info.changelog(diagnostic.message).render(width)));
         rows.push(...diagnostics
             .filter(diagnostic => diagnostic.code !== "engine-startup" && diagnostic.code !== "project-trust"
             && diagnostic.code !== "release-update" && diagnostic.code !== "release-update-installed"
@@ -261,7 +260,7 @@ export class TranscriptDocument {
             && diagnostic.code !== "package-updates" && diagnostic.code !== "changelog-collapsed"
             && diagnostic.code !== "changelog-expanded")
             .slice(-3)
-            .flatMap(diagnostic => renderPiShellTranscriptBlock({
+            .flatMap(diagnostic => this.#options.components.transcript.renderBlock({
             id: `diagnostic-${diagnostic.sequence}`,
             kind: diagnostic.severity === "error" ? "error" : "system",
             status: "finalized",
@@ -280,7 +279,7 @@ export class TranscriptDocument {
             const block = this.#blocks.get(id);
             if (block === undefined || (!thinkingVisible && block.kind === "thinking"))
                 continue;
-            if (rows.length > 0 && (block.kind === "user" || this.#options.customViewport && isPiPromptStyleCompaction(block)))
+            if (rows.length > 0 && (block.kind === "user" || this.#options.customViewport && this.#options.components.transcript.isPromptStyleCompaction(block)))
                 rows.push("");
             rows.push(...this.#blockRows(id, block, width).map(sanitizeExitTranscriptRow));
         }
@@ -298,7 +297,7 @@ export class TranscriptDocument {
             const rows = component.render(width);
             if (!this.#options.customViewport || block?.kind === "user")
                 return rows;
-            return rows.map(row => nativeHyperlinkStyle(row, nativeTranscriptLinkColor));
+            return rows.map(row => nativeHyperlinkStyle(row, this.#linkColor));
         };
         if (block === undefined || block.status !== "finalized")
             return render();
@@ -336,6 +335,6 @@ function sanitizeExitTranscriptRow(row) {
     return row.replace(KITTY_IMAGE_CONTROL, "").replace(ITERM_IMAGE_CONTROL, "");
 }
 /** Web URLs use link blue; file targets retain A1's cyan interactive accent. */
-export function nativeTranscriptLinkColor(text, target) {
-    return piTheme().fg(/^file:/iu.test(target) ? "accent" : "mdLink", text);
+export function transcriptLinkColor(theme) {
+    return (text, target) => theme.current().fg(/^file:/iu.test(target) ? "accent" : "mdLink", text);
 }

package/dist/app/session-shell/viewport-layout.d.ts

@@ -1,5 +1,5 @@
+import type { OwnedUiShellComponentPort } from "../../contracts/owned-ui/index.js";
 import type { TranscriptPromptAnchor, TranscriptViewportFrameInput } from "../../ui/components/transcript-viewport.js";
-import type { PiShellComponentPort } from "../../integrations/pi/components/shell-shared-facade.js";
 import type { ShellLayout, ShellLayoutPorts } from "./shell-layout.js";
 interface VisibleViewportSnapshot {
     readonly width: number;
@@ -8,7 +8,7 @@ interface VisibleViewportSnapshot {
     readonly transientSignature: string;
     readonly promptAnchors: readonly TranscriptPromptAnchor[];
     readonly dockLength: number;
-    readonly inputSurface: PiShellComponentPort;
+    readonly inputSurface: OwnedUiShellComponentPort;
     readonly viewportRevision: number;
     readonly selectionRevision: number;
     readonly pointerPosition: TranscriptViewportFrameInput["pointerPosition"];

package/dist/app/session-shell/viewport-pointer.d.ts

@@ -0,0 +1,83 @@
+import type { OwnedUiShellEditorPort, OwnedUiViewportSettings } from "../../contracts/owned-ui/index.js";
+import type { TerminalPointerSurface } from "../../contracts/presentation/index.js";
+import { type RoutedMouseInput } from "../../ui/components/mouse.js";
+import type { SelectionCopySnapshot } from "../../ui/components/selection-copy.js";
+import type { TranscriptViewport, TranscriptViewportFrame } from "../../ui/components/transcript-viewport.js";
+/** One-based, inclusive terminal cells of a clickable viewport-tail control. */
+export interface TailControlRegion {
+    readonly rowStart: number;
+    readonly rowEnd: number;
+    readonly columnStart: number;
+    readonly columnEnd: number;
+}
+export type TailControl = TailControlRegion & {
+    readonly activate: () => void;
+};
+export declare function withinTailControl(region: TailControlRegion, column: number, row: number): boolean;
+export interface ViewportPointerPorts {
+    readonly viewport: TranscriptViewport;
+    readonly editor: OwnedUiShellEditorPort;
+    config(): OwnedUiViewportSettings;
+    copyOnSelect(): boolean;
+    /** False while replacement input or overlay bounds have not been painted yet. */
+    inputGeometryReady(): boolean;
+    /** The topmost overlay or input surface under a cell. */
+    modalAt(column: number, row: number): TerminalPointerSurface | undefined;
+    /** The editor rows of the most recent composition. */
+    editorFrame(): {
+        readonly rowStart: number;
+        readonly rowEnd: number;
+    } | undefined;
+    tailControl(): TailControl | undefined;
+    clearTailControl(): void;
+    requestRender(): void;
+    requestHyperlinkCleanup(rows?: readonly number[]): void;
+    updateSelectionAutoScroll(column: number, row: number, viewportHeight: number, frameHeight: number): void;
+    stopSelectionAutoScroll(): void;
+    /** A right-click on the editor pastes the clipboard. */
+    pasteFromPointer(): void;
+}
+/** How one input chunk's mouse reports changed the viewport. */
+export interface ViewportPointerOutcome {
+    repaint: boolean;
+    forceRepaint: boolean;
+    activity: boolean;
+    completedCopy: SelectionCopySnapshot | undefined;
+}
+interface PointerCall {
+    readonly allowWheel: boolean;
+    readonly now: number;
+    readonly editorActive: boolean;
+}
+/**
+ * The pointer gestures of the session viewport: which surface a gesture is latched to, the
+ * suppression of a gesture begun on the dock or a control, the editor click that waits for drag
+ * or release, the rail drag offset, the pointer position and the hovered link. Each report is
+ * routed in the same order of checks, and its effect is reported as an outcome.
+ */
+export declare class ViewportPointerGestures {
+    #private;
+    constructor(ports: ViewportPointerPorts);
+    get position(): {
+        readonly column: number;
+        readonly row: number;
+    } | undefined;
+    get editorSelecting(): boolean;
+    /** A gesture is latched to a surface or a selection is being dragged. */
+    get held(): boolean;
+    /** No pointer position or hovered link is remembered. */
+    get idle(): boolean;
+    /** Forget every latch. */
+    clear(): void;
+    /** Swallow the rest of a held gesture until its release. */
+    drain(): void;
+    /** Before the first paint, a left press and its motion and release belong to no surface. */
+    routeUnpainted(data: string): RoutedMouseInput;
+    route(data: string, frame: TranscriptViewportFrame, call: PointerCall): {
+        readonly routed: RoutedMouseInput;
+        readonly outcome: ViewportPointerOutcome;
+    };
+    /** A newly composed frame may move a link away from a stationary pointer. */
+    refreshHover(frame: TranscriptViewportFrame): void;
+}
+export {};

package/dist/app/session-shell/viewport-pointer.js

@@ -0,0 +1,361 @@
+import { routeMouseInput } from "../../ui/components/mouse.js";
+import { scrollForThumbRow, scrollForTrackPage, scrollbarWheelRows } from "../../ui/components/scrollbar.js";
+import { readVisibleHyperlinks } from "../../ui/components/visible-hyperlinks.js";
+export function withinTailControl(region, column, row) {
+    return row >= region.rowStart && row <= region.rowEnd && column >= region.columnStart && column <= region.columnEnd;
+}
+/**
+ * The pointer gestures of the session viewport: which surface a gesture is latched to, the
+ * suppression of a gesture begun on the dock or a control, the editor click that waits for drag
+ * or release, the rail drag offset, the pointer position and the hovered link. Each report is
+ * routed in the same order of checks, and its effect is reported as an outcome.
+ */
+export class ViewportPointerGestures {
+    #ports;
+    #dragGrabOffset = null;
+    #owner;
+    // Invariant: a right-click editor gesture remains owned by the dock.
+    #dockSuppressed = false;
+    // Invariant: a gesture begun on an explicit control remains owned by that control.
+    #tailSuppressed = false;
+    // Invariant: editor selection remains true only while its left button is held.
+    #editorSelecting = false;
+    // Invariant: no-drag editor presses replay on release; distinct motion promotes frame selection.
+    #pendingEditorClick;
+    #position;
+    #hoveredHyperlinkKey;
+    constructor(ports) {
+        this.#ports = ports;
+    }
+    get position() {
+        return this.#position;
+    }
+    get editorSelecting() {
+        return this.#editorSelecting;
+    }
+    /** A gesture is latched to a surface or a selection is being dragged. */
+    get held() {
+        return this.#owner !== undefined || this.#ports.viewport.selectionActive || this.#editorSelecting;
+    }
+    /** No pointer position or hovered link is remembered. */
+    get idle() {
+        return this.#position === undefined && this.#hoveredHyperlinkKey === undefined;
+    }
+    /** Forget every latch. */
+    clear() {
+        this.#dragGrabOffset = null;
+        this.#dockSuppressed = false;
+        this.#tailSuppressed = false;
+        this.#editorSelecting = false;
+        this.#pendingEditorClick = undefined;
+        this.#position = undefined;
+        this.#hoveredHyperlinkKey = undefined;
+        this.#owner = undefined;
+    }
+    /** Swallow the rest of a held gesture until its release. */
+    drain() {
+        this.#owner = "drain";
+    }
+    /** Before the first paint, a left press and its motion and release belong to no surface. */
+    routeUnpainted(data) {
+        // Invariant: a not-yet-painted A1 screen is not Pi's selection surface.
+        return routeMouseInput(data, event => {
+            if (event.kind === "press" && event.button === 0)
+                this.#tailSuppressed = true;
+            if (event.kind === "release")
+                this.#tailSuppressed = false;
+            return event.kind === "motion" || event.kind === "release" || (event.kind === "press" && event.button === 0);
+        });
+    }
+    route(data, frame, call) {
+        const outcome = { repaint: false, forceRepaint: false, activity: false, completedCopy: undefined };
+        const routed = routeMouseInput(data, (event, report) => this.#report(event, report, frame, call, outcome));
+        return { routed, outcome };
+    }
+    /** A newly composed frame may move a link away from a stationary pointer. */
+    refreshHover(frame) {
+        const pointer = this.#position;
+        if (pointer === undefined || this.#ports.viewport.selectionActive || this.#editorSelecting)
+            return;
+        const next = hyperlinkKeyAt(frame, pointer.column, pointer.row);
+        if (this.#hoveredHyperlinkKey !== undefined && next !== this.#hoveredHyperlinkKey) {
+            // Platform: Windows Terminal can leave its solid native-hover underline behind
+            // when a following viewport moves the link away from a stationary pointer.
+            this.#ports.requestHyperlinkCleanup([pointer.row]);
+            this.#ports.requestRender();
+        }
+        this.#hoveredHyperlinkKey = next;
+    }
+    #report(event, report, frame, call, outcome) {
+        const viewport = this.#ports.viewport;
+        const hits = frame.hits;
+        const overModal = this.#ports.modalAt(event.column, event.row);
+        const wheel = event.kind === "wheel-up" || event.kind === "wheel-down";
+        // Invariant: latch each gesture to one surface.
+        if (this.#owner === "drain" || !this.#ports.inputGeometryReady()) {
+            if (event.kind === "release")
+                this.#owner = undefined;
+            else if (event.kind === "press")
+                this.#owner = "drain";
+            return true;
+        }
+        const owner = !wheel && this.#owner !== undefined ? this.#owner : overModal;
+        if (owner !== undefined && owner !== "viewport") {
+            if (event.kind === "press")
+                this.#owner = owner;
+            if (event.kind === "release")
+                this.#owner = undefined;
+            if (event.kind === "press" && viewport.clearSelection())
+                outcome.repaint = true;
+            viewport.setRailHovered(false);
+            viewport.setStickyHovered(false);
+            this.#position = undefined;
+            owner.component.handleInput?.(report);
+            outcome.repaint = true;
+            return true;
+        }
+        if (event.kind === "press")
+            this.#owner = "viewport";
+        if (event.kind === "release")
+            this.#owner = undefined;
+        const tailControl = this.#ports.tailControl();
+        const target = {
+            frame,
+            overRail: overModal === undefined && hits.rail !== null
+                && event.column === hits.rail.column
+                && event.row >= hits.rail.rowStart
+                && event.row < hits.rail.rowStart + hits.rail.trackHeight,
+            overSticky: overModal === undefined && hits.sticky !== null && event.row === hits.sticky.row && event.column <= hits.sticky.width,
+            overBottom: overModal === undefined && hits.bottom !== null && event.row === hits.bottom.row
+                && event.column >= hits.bottom.columnStart && event.column <= hits.bottom.columnEnd,
+            tailControl,
+            overTailControl: overModal === undefined && tailControl !== undefined
+                && withinTailControl(tailControl, event.column, event.row),
+        };
+        this.#track(event, target, outcome);
+        switch (event.kind) {
+            case "motion": return this.#motion(event, target, call, outcome);
+            case "wheel-up":
+            case "wheel-down": return this.#wheel(event, frame, call, outcome);
+            case "press": return this.#press(event, target, call, outcome);
+            case "release": return this.#release(event, call, outcome);
+        }
+    }
+    // Rationale: every report updates the pointer position, the hover of the bottom and tail controls, and the hovered link.
+    #track(event, target, outcome) {
+        const hits = target.frame.hits;
+        const tailControl = target.tailControl;
+        const previousPointer = this.#position;
+        const wasOverBottom = hits.bottom !== null && previousPointer !== undefined
+            && previousPointer.row === hits.bottom.row
+            && previousPointer.column >= hits.bottom.columnStart && previousPointer.column <= hits.bottom.columnEnd;
+        // Invariant: every report updates the pointer position.
+        this.#position = { column: event.column, row: event.row };
+        outcome.repaint ||= wasOverBottom !== target.overBottom;
+        const wasOverTailControl = tailControl !== undefined && previousPointer !== undefined
+            && withinTailControl(tailControl, previousPointer.column, previousPointer.row);
+        outcome.repaint ||= wasOverTailControl !== target.overTailControl;
+        if (!this.#ports.viewport.selectionActive && !this.#editorSelecting) {
+            const nextHyperlink = hyperlinkKeyAt(target.frame, event.column, event.row);
+            if (this.#hoveredHyperlinkKey !== undefined && nextHyperlink !== this.#hoveredHyperlinkKey) {
+                // Platform: overwrite Windows Terminal's cached native-hover underline exactly once.
+                this.#ports.requestHyperlinkCleanup(previousPointer === undefined ? undefined : [previousPointer.row]);
+                outcome.repaint = true;
+            }
+            this.#hoveredHyperlinkKey = nextHyperlink;
+        }
+    }
+    #motion(event, target, call, outcome) {
+        const viewport = this.#ports.viewport;
+        const { frame } = target;
+        const hits = frame.hits;
+        viewport.setRailHovered(target.overRail);
+        viewport.setStickyHovered(target.overSticky);
+        outcome.repaint = true;
+        const editorFrame = this.#ports.editorFrame();
+        if (call.editorActive && this.#editorSelecting && editorFrame !== undefined) {
+            this.#ports.editor.handlePointer({
+                kind: "motion",
+                button: event.button,
+                column: event.column,
+                row: event.row - editorFrame.rowStart + 1,
+            });
+            return true;
+        }
+        if (this.#dockSuppressed || this.#tailSuppressed)
+            return true;
+        const pendingEditorClick = this.#pendingEditorClick;
+        if (pendingEditorClick !== undefined) {
+            if (event.column === pendingEditorClick.column && event.row === pendingEditorClick.row)
+                return true;
+            this.#pendingEditorClick = undefined;
+            const activeEditorFrame = call.editorActive ? editorFrame : undefined;
+            if (activeEditorFrame !== undefined && this.#ports.editor.handlePointer({ kind: "press", button: 0, column: pendingEditorClick.column, row: pendingEditorClick.row - activeEditorFrame.rowStart + 1 })) {
+                this.#editorSelecting = true;
+                this.#ports.editor.handlePointer({ kind: "motion", button: event.button, column: event.column, row: event.row - activeEditorFrame.rowStart + 1 });
+                return true;
+            }
+            viewport.pressSelection(pendingEditorClick.column, pendingEditorClick.row, call.now, { continueMultiClick: false });
+            viewport.extendSelection(event.column, event.row, call.now, false);
+            this.#ports.updateSelectionAutoScroll(event.column, event.row, hits.viewportHeight, frame.rows.length);
+            outcome.activity = true;
+            return true;
+        }
+        if (viewport.selectionActive) {
+            viewport.extendSelection(event.column, event.row, call.now, false);
+            this.#ports.updateSelectionAutoScroll(event.column, event.row, hits.viewportHeight, frame.rows.length);
+            outcome.activity = true;
+            return true;
+        }
+        if (this.#dragGrabOffset !== null && hits.rail !== null) {
+            const scroll = scrollForThumbRow(hits.rail.geometry, event.row - hits.rail.rowStart - this.#dragGrabOffset);
+            viewport.scrollTo(scroll, call.now);
+            outcome.activity = true;
+            return true;
+        }
+        return target.overRail || target.overSticky || target.overBottom || target.overTailControl;
+    }
+    #wheel(event, frame, call, outcome) {
+        if (!call.allowWheel || event.row < 1 || event.row > frame.hits.viewportHeight)
+            return false;
+        const distance = scrollbarWheelRows(this.#ports.config().scrollbarSpeed);
+        this.#ports.viewport.scrollBy(event.kind === "wheel-up" ? -distance : distance, call.now);
+        outcome.activity = true;
+        outcome.repaint = true;
+        outcome.forceRepaint = true;
+        return true;
+    }
+    #press(event, target, call, outcome) {
+        const viewport = this.#ports.viewport;
+        const { frame } = target;
+        const hits = frame.hits;
+        const editorFrame = call.editorActive ? this.#ports.editorFrame() : undefined;
+        if (event.button === 2 && editorFrame !== undefined
+            && event.row >= editorFrame.rowStart && event.row <= editorFrame.rowEnd) {
+            this.#ports.stopSelectionAutoScroll();
+            if (viewport.clearSelection())
+                outcome.repaint = true;
+            this.#ports.pasteFromPointer();
+            this.#dockSuppressed = true;
+            outcome.repaint = true;
+            return true;
+        }
+        if (event.button !== 0)
+            return false;
+        this.#dockSuppressed = false;
+        this.#tailSuppressed = false;
+        this.#pendingEditorClick = undefined;
+        this.#ports.stopSelectionAutoScroll();
+        if (viewport.clearSelection())
+            outcome.repaint = true;
+        if (target.overTailControl && target.tailControl !== undefined) {
+            this.#ports.clearTailControl();
+            target.tailControl.activate();
+            this.#tailSuppressed = true;
+            outcome.repaint = true;
+            return true;
+        }
+        if (target.overBottom) {
+            viewport.scrollToEnd(call.now);
+            this.#tailSuppressed = true;
+            outcome.activity = true;
+            outcome.repaint = true;
+            return true;
+        }
+        if (target.overSticky && hits.sticky !== null) {
+            viewport.scrollTo(hits.sticky.target, call.now);
+            this.#tailSuppressed = true;
+            outcome.activity = true;
+            outcome.repaint = true;
+            return true;
+        }
+        if (target.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;
+                viewport.setRailDragging(true);
+            }
+            else {
+                viewport.scrollTo(scrollForTrackPage(geometry, trackRow, frame.scrollTop, hits.viewportHeight), call.now);
+                this.#tailSuppressed = true;
+            }
+            outcome.activity = true;
+            outcome.repaint = true;
+            return true;
+        }
+        if (event.row >= 1 && event.row <= frame.rows.length && event.column <= frame.descriptor.width) {
+            if (editorFrame !== undefined && event.row >= editorFrame.rowStart && event.row <= editorFrame.rowEnd) {
+                // Invariant: no-drag clicks remain editor-owned; first motion latches an editor drag.
+                this.#pendingEditorClick = { column: event.column, row: event.row };
+            }
+            else {
+                viewport.pressSelection(event.column, event.row, call.now);
+            }
+            outcome.repaint = true;
+            return true;
+        }
+        this.#tailSuppressed = true;
+        return true;
+    }
+    #release(event, call, outcome) {
+        const viewport = this.#ports.viewport;
+        const editorFrame = this.#ports.editorFrame();
+        if (call.editorActive && this.#editorSelecting && editorFrame !== undefined) {
+            this.#ports.editor.handlePointer({
+                kind: "release",
+                button: event.button,
+                column: event.column,
+                row: event.row - editorFrame.rowStart + 1,
+            });
+            this.#editorSelecting = false;
+            outcome.forceRepaint = true;
+            outcome.repaint = true;
+            return true;
+        }
+        const pendingEditorClick = this.#pendingEditorClick;
+        if (pendingEditorClick !== undefined) {
+            this.#pendingEditorClick = undefined;
+            if (editorFrame !== undefined) {
+                const editorRow = pendingEditorClick.row - editorFrame.rowStart + 1;
+                this.#ports.editor.handlePointer({ kind: "press", button: 0, column: pendingEditorClick.column, row: editorRow });
+                this.#ports.editor.handlePointer({ kind: "release", button: 0, column: pendingEditorClick.column, row: editorRow });
+            }
+            outcome.forceRepaint = true;
+            outcome.repaint = true;
+            return true;
+        }
+        if (viewport.releaseSelection()) {
+            this.#ports.stopSelectionAutoScroll();
+            if (this.#ports.copyOnSelect())
+                outcome.completedCopy = viewport.captureSelectedText() ?? undefined;
+            // Platform: restore OSC 8 links only after the held-button selection paint has
+            // ended, then overwrite any terminal-cached hover cells immediately.
+            outcome.forceRepaint = true;
+            outcome.repaint = true;
+            return true;
+        }
+        if (this.#dragGrabOffset !== null) {
+            this.#dragGrabOffset = null;
+            viewport.setRailDragging(false);
+            outcome.repaint = true;
+            return true;
+        }
+        if (this.#dockSuppressed) {
+            this.#dockSuppressed = false;
+            return true;
+        }
+        if (this.#tailSuppressed) {
+            this.#tailSuppressed = false;
+            return true;
+        }
+        return false;
+    }
+}
+function hyperlinkKeyAt(frame, column, row) {
+    if (row < 1 || row > frame.rows.length || column < 1)
+        return undefined;
+    const range = readVisibleHyperlinks(frame.rows[row - 1] ?? "").ranges
+        .find(candidate => column - 1 >= candidate.from && column - 1 < candidate.to);
+    return range === undefined ? undefined : JSON.stringify([row, range]);
+}