@oh-my-pi/pi-tui 18.4.8 → 18.4.9

package/src/tools/bash-interactive.ts

@@ -1,6 +1,11 @@
 import type * as XtermModule from "@oh-my-pi/pi-utils/vterm";
 import type { Terminal as XtermTerminalType } from "@oh-my-pi/pi-utils/vterm";
+import type { TspSpan } from "@oh-my-pi/pi-wire";
 import type { Component } from "../tui";
+import { ansi, col, row, span, text } from "../native/describe";
+import { Memo } from "../native/memo";
+import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node";
+import { actionBar, actionButton } from "../native/overlay";
 import { extractPrintableText, matchesKey, parseKey, parseKittySequence } from "../keys";
 import { padding, truncateToWidth, visibleWidth } from "../utils";
 import type { Theme } from "../theme/theme";
@@ -15,6 +20,10 @@ export interface BashInteractiveTerminalBackend {
 
 // The capture sink owns final output; this caps only the live display backlog.
 const MAX_LIVE_WRITE_QUEUE_CHUNKS = 512;
+// Cells the native full sheet's insets take from the pane width.
+const NATIVE_SHEET_INSET_COLS = 8;
+// Action id of the native Force kill button (mirrors Esc).
+const KILL_ACTION = "kill";
 
 function normalizeInputForPty(data: string, applicationCursorKeysMode: boolean): string {
 	const kitty = parseKittySequence(data);
@@ -78,6 +87,8 @@ function normalizeInputForPty(data: string, applicationCursorKeysMode: boolean):
 }
 /** Interactive terminal overlay driven by an external PTY controller. */
 export class BashInteractiveOverlayComponent implements Component {
+	/** Native sheet: a full-pane glass overlay titled Console. */
+	readonly nativeOverlay = { role: "omp.overlay.console", size: "full", head: "Console" } as const;
 	#terminal: XtermTerminalType;
 	#state: "running" | "complete" | "timed_out" | "killed" = "running";
 	#exitCode: number | undefined;
@@ -94,6 +105,9 @@ export class BashInteractiveOverlayComponent implements Component {
 	#writeOffset = 0;
 	#flushResolvers: Array<() => void> = [];
 	#writing = false;
+	/** Bumped whenever the virtual terminal processed a chunk, so `describe` knows the screen changed. */
+	#screenVersion = 0;
+	readonly #native = new Memo();
 
 	constructor(
 		command: string,
@@ -160,6 +174,7 @@ export class BashInteractiveOverlayComponent implements Component {
 		const data = this.#writeQueue[this.#writeOffset]!;
 		this.#terminal.write(data, () => {
 			this.#writing = false;
+			this.#screenVersion += 1;
 			this.#writeOffset += 1;
 			if (this.#writeOffset >= this.#writeQueue.length) {
 				this.#writeQueue = [];
@@ -206,7 +221,7 @@ export class BashInteractiveOverlayComponent implements Component {
 
 	handleInput(data: string): void {
 		if (this.#state === "running" && (matchesKey(data, "escape") || matchesKey(data, "esc"))) {
-			this.#onDismiss();
+			this.#forceKill();
 			return;
 		}
 		if (this.#state !== "running") {
@@ -218,6 +233,73 @@ export class BashInteractiveOverlayComponent implements Component {
 		}
 		this.#onInput(normalizedInput);
 	}
+
+	/** The Force kill button runs the Esc path. */
+	handleNativeEvent(event: NativeUiEvent): void {
+		if (event.type === "action" && event.act === KILL_ACTION) this.#forceKill();
+	}
+
+	#forceKill(): void {
+		if (this.#state === "running") this.#onDismiss();
+	}
+
+	#syncPtySize(cols: number, rows: number): void {
+		if (cols === this.#lastCols && rows === this.#lastRows) return;
+		this.#lastCols = cols;
+		this.#lastRows = rows;
+		try {
+			this.#backend.resize(cols, rows);
+		} catch {
+			// Session may have ended
+		}
+	}
+
+	#maxContentRows(): number {
+		const maxOverlayRows = Math.max(5, Math.floor(this.#getTerminalRows() * 0.8));
+		return Math.max(1, maxOverlayRows - 4);
+	}
+
+	#stateSpan(): TspSpan {
+		if (this.#state === "running") return span("running", "warning");
+		if (this.#state === "timed_out") return span("timed out", "warning");
+		if (this.#state === "killed") return span("killed", "warning");
+		if (this.#exitCode === 0) return span("exit 0", "success");
+		if (this.#exitCode === undefined) return span("exited", "warning");
+		return span(`exit ${this.#exitCode}`, "error");
+	}
+
+	/**
+	 * Native view: the command with its state badge, the PTY screen as an
+	 * `ansi` node (SGR kept, fixed to the PTY grid), and a footer with the
+	 * Force kill action while running.
+	 */
+	describe(cx: DescribeContext): NativeNode {
+		const cols = Math.max(20, cx.cols - NATIVE_SHEET_INSET_COLS);
+		const rows = this.#maxContentRows();
+		this.#syncPtySize(cols, rows);
+		this.#terminal.resize(cols, rows);
+		const deps = [this.#screenVersion, cols, rows, this.#state, this.#exitCode];
+		return this.#native.get(deps, () => {
+			const viewportY = this.#terminal.buffer.active.viewportY;
+			const screen = readTerminalRows(this.#terminal, viewportY, rows).map(line => styleTerminalRow(line, ""));
+			const head = row(
+				[
+					text([span(replaceTabs(this.#command), "muted")], { wrap: "none", truncate: "end" }),
+					text([span("[", "dim"), this.#stateSpan(), span("]", "dim")]),
+				],
+				{ gap: "sm", align: "baseline", justify: "between" },
+			);
+			const footer =
+				this.#state === "running"
+					? actionBar([
+							text([span("Input forwarded to PTY", "dim")]),
+							null,
+							actionButton("Force kill", KILL_ACTION, { keys: "escape", tone: "error" }),
+						])
+					: actionBar([text([span("Session finished", "dim")])]);
+			return col([head, ansi(screen.join("\n"), { cols }), footer], { gap: "sm" });
+		});
+	}
 	#stateText(): string {
 		if (this.#state === "running") return this.#uiTheme.fg("warning", "running");
 		if (this.#state === "timed_out") return this.#uiTheme.fg("warning", "timed out");
@@ -237,21 +319,8 @@ export class BashInteractiveOverlayComponent implements Component {
 	render(width: number): readonly string[] {
 		const safeWidth = Math.max(20, width);
 		const innerWidth = Math.max(1, safeWidth - 2);
-		const maxOverlayRows = Math.max(5, Math.floor(this.#getTerminalRows() * 0.8));
-		const chromeRows = 4;
-		const maxContentRows = Math.max(1, maxOverlayRows - chromeRows);
-		// Propagate terminal resize to PTY session
-		const currentCols = innerWidth;
-		const currentRows = maxContentRows;
-		if (currentCols !== this.#lastCols || currentRows !== this.#lastRows) {
-			this.#lastCols = currentCols;
-			this.#lastRows = currentRows;
-			try {
-				this.#backend.resize(currentCols, currentRows);
-			} catch {
-				// Session may have ended
-			}
-		}
+		const maxContentRows = this.#maxContentRows();
+		this.#syncPtySize(innerWidth, maxContentRows);
 		const statusIcon =
 			this.#state === "running"
 				? formatStatusIcon("running", this.#uiTheme)

package/src/tools/output-meta.ts

@@ -25,6 +25,8 @@ export interface TruncationMeta {
 	elidedLines?: number;
 	/** Artifact ID if full output was saved */
 	artifactId?: string;
+	/** Bytes the artifact cap dropped from the saved file's middle; the artifact is then a head/tail sample. */
+	artifactElidedBytes?: number;
 	/** Next offset for pagination (head truncation only) */
 	nextOffset?: number;
 	/**
@@ -62,7 +64,7 @@ export interface LimitsMeta {
 	resultLimit?: { reached: number; suggestion?: number };
 	headLimit?: { reached: number; suggestion: number };
 	/** `unit` may be absent in sessions persisted before it was recorded. */
-	columnTruncated?: { maxColumn: number; unit?: "bytes" | "chars"; artifactId?: string };
+	columnTruncated?: { maxColumn: number; unit?: "bytes" | "chars"; artifactId?: string; artifactElidedBytes?: number };
 }
 
 /**
@@ -130,8 +132,14 @@ export function formatGroupedDiagnosticMessages(messages: string[]): string {
 	return lines.join("\n");
 }
 
-/** Format a recoverable output artifact link. */
-export function formatFullOutputReference(artifactId: string): string {
+/**
+ * Format a recoverable output artifact link. An artifact the size cap cut
+ * (`artifactElidedBytes > 0`) is labeled as the head/tail sample it holds.
+ */
+export function formatFullOutputReference(artifactId: string, artifactElidedBytes?: number): string {
+	if (artifactElidedBytes !== undefined && artifactElidedBytes > 0) {
+		return `Read artifact://${artifactId} for a head/tail sample of the output; ${formatBytes(artifactElidedBytes)} from its middle was not saved`;
+	}
 	return `Read artifact://${artifactId} for full output`;
 }
 
@@ -206,7 +214,7 @@ export function formatTruncationMetaNotice(truncation: TruncationMeta, source?:
 			? undefined
 			: source?.type === "report"
 				? `Read artifact://${truncation.artifactId} for full report (${source.value})`
-				: formatFullOutputReference(truncation.artifactId);
+				: formatFullOutputReference(truncation.artifactId, truncation.artifactElidedBytes);
 
 	if (truncation.direction === "middle") {
 		const head = truncation.headRange;
@@ -322,7 +330,7 @@ export function formatOutputNotice(meta: OutputMeta | undefined): string {
 		// stops matching the persisted "… 768 chars" text.
 		let columnNotice = `Some lines truncated to ${c.maxColumn} ${c.unit ?? "chars"}`;
 		if (c.artifactId != null) {
-			columnNotice += `. ${formatFullOutputReference(c.artifactId)}`;
+			columnNotice += `. ${formatFullOutputReference(c.artifactId, c.artifactElidedBytes)}`;
 		}
 		parts.push(columnNotice);
 	}

package/src/tools/streaming-output.ts

@@ -14,14 +14,15 @@ export const DEFAULT_MAX_BYTES = 50 * 1024;
 export const DEFAULT_MAX_COLUMN = 512;
 
 /**
- * Default artifact-on-disk cap for {@link OutputSink}.
- *
- * `0` means unbounded: by default, `artifact://<id>` references preserve the
- * complete raw stream instead of a capped head/tail sample.
+ * Default artifact-on-disk cap for {@link OutputSink}: 16 MiB, split into a
+ * {@link ARTIFACT_DEFAULT_HEAD_BYTES} head and a rolling tail. `0` means
+ * unbounded (the complete raw stream is preserved).
  */
-export const ARTIFACT_DEFAULT_MAX_BYTES = 0;
+export const ARTIFACT_DEFAULT_MAX_BYTES = 16 * 1024 * 1024; // 16 MiB
 /** Default head budget; the remainder becomes the rolling tail window. */
 export const ARTIFACT_DEFAULT_HEAD_BYTES = 3 * 1024 * 1024; // 3 MiB
+/** Upper bound on how far the rolling artifact tail may outgrow its budget between trims. */
+const ARTIFACT_TAIL_MAX_SLACK_BYTES = 4 * 1024 * 1024;
 
 const NL = "\n";
 const CR = "\r";
@@ -54,6 +55,11 @@ export interface OutputSummary {
 	columnMax?: number;
 	/** Artifact ID for internal URL access (artifact://<id>) when truncated */
 	artifactId?: string;
+	/**
+	 * Bytes the artifact cap dropped from the middle of the saved file. When
+	 * set, `artifact://<id>` holds a head/tail sample, not the full output.
+	 */
+	artifactElidedBytes?: number;
 	/** Full raw output was not completely saved; artifactId is unavailable. */
 	artifactError?: OutputArtifactError;
 }
@@ -86,17 +92,18 @@ export interface OutputSinkOptions {
 	/** Minimum ms between onChunk calls. 0 = every chunk (default). */
 	chunkThrottleMs?: number;
 	/**
-	 * Optional cap on bytes written to the artifact-on-disk file. When the cap
-	 * is hit, the head window is preserved verbatim and subsequent output feeds
-	 * a rolling tail window; on close, the sink writes a single
+	 * Cap on bytes written to the artifact-on-disk file. When the cap is hit,
+	 * the head window is preserved verbatim and subsequent output feeds a
+	 * rolling tail window; on close, the sink writes a single
 	 * `[ARTIFACT TRUNCATED: …]` notice between them. Default
-	 * {@link ARTIFACT_DEFAULT_MAX_BYTES} (unbounded).
+	 * {@link ARTIFACT_DEFAULT_MAX_BYTES} (16 MiB); `0` = unbounded.
 	 */
 	artifactMaxBytes?: number;
 	/**
 	 * Bytes reserved for the head window of the capped artifact file. The
 	 * tail window receives `artifactMaxBytes - artifactHeadBytes`. Default
-	 * {@link ARTIFACT_DEFAULT_HEAD_BYTES}; clamped to `[0, artifactMaxBytes]`.
+	 * {@link ARTIFACT_DEFAULT_HEAD_BYTES}, but at most half of
+	 * `artifactMaxBytes`; clamped to `[0, artifactMaxBytes]`.
 	 */
 	artifactHeadBytes?: number;
 }
@@ -912,20 +919,24 @@ export class OutputSink {
 	readonly #chunkThrottleMs: number;
 	readonly #maxColumns: number;
 
-	// Optional artifact-on-disk cap. When `#artifactMaxBytes > 0` the file sink
-	// owns a head budget + a rolling tail buffer; once the head is closed,
-	// subsequent chunks are diverted into `#artifactTailRing` (bounded by
-	// `#artifactTailBudget`). On `dump()` the tail is flushed back to the sink
-	// behind a `[ARTIFACT TRUNCATED: …]` notice. The default cap is disabled so
-	// advertised `artifact://<id>` captures are lossless.
+	// Artifact-on-disk cap. When `#artifactMaxBytes > 0` the file sink owns a
+	// head budget + a rolling tail buffer; once the head is closed, subsequent
+	// chunks are diverted into `#artifactTailRing` (trimmed back to
+	// `#artifactTailBudget` whenever it outgrows the budget by
+	// `#artifactTailSlack`). On `dump()` the tail is flushed back to the sink
+	// behind a `[ARTIFACT TRUNCATED: …]` notice. `0` disables the cap.
 	readonly #artifactMaxBytes: number;
 	readonly #artifactHeadBudget: number;
 	readonly #artifactTailBudget: number;
+	/** Overshoot tolerated before trimming, so trimming costs amortized O(1) per byte instead of O(budget) per chunk. */
+	readonly #artifactTailSlack: number;
 	#artifactHeadBytesWritten = 0;
 	#artifactHeadClosed = false;
 	#artifactTailRing = "";
 	#artifactTailRingBytes = 0;
 	#artifactTailIncomingBytes = 0;
+	/** Bytes the cap dropped from the artifact middle, recorded when the tail is flushed. */
+	#artifactElidedBytes = 0;
 	constructor(options?: OutputSinkOptions) {
 		const {
 			artifactPath,
@@ -936,7 +947,7 @@ export class OutputSink {
 			onChunk,
 			chunkThrottleMs = 0,
 			artifactMaxBytes = ARTIFACT_DEFAULT_MAX_BYTES,
-			artifactHeadBytes = ARTIFACT_DEFAULT_HEAD_BYTES,
+			artifactHeadBytes,
 		} = options ?? {};
 		this.#artifactPath = artifactPath;
 		this.#artifactId = artifactId;
@@ -946,8 +957,13 @@ export class OutputSink {
 		this.#onChunk = onChunk;
 		this.#chunkThrottleMs = chunkThrottleMs;
 		this.#artifactMaxBytes = Math.max(0, artifactMaxBytes);
-		this.#artifactHeadBudget = Math.max(0, Math.min(artifactHeadBytes, this.#artifactMaxBytes));
+		// The default head yields to the rolling tail on small caps: it takes at
+		// most half, so the most recent output is always kept.
+		const headBytesRequested =
+			artifactHeadBytes ?? Math.min(ARTIFACT_DEFAULT_HEAD_BYTES, Math.floor(this.#artifactMaxBytes / 2));
+		this.#artifactHeadBudget = Math.max(0, Math.min(headBytesRequested, this.#artifactMaxBytes));
 		this.#artifactTailBudget = Math.max(0, this.#artifactMaxBytes - this.#artifactHeadBudget);
+		this.#artifactTailSlack = Math.min(this.#artifactTailBudget, ARTIFACT_TAIL_MAX_SLACK_BYTES);
 	}
 
 	/**
@@ -1251,11 +1267,14 @@ export class OutputSink {
 		}
 		this.#artifactTailRing += chunk;
 		this.#artifactTailRingBytes += chunkBytes;
-		if (this.#artifactTailRingBytes > budget) {
-			const { text, bytes } = truncateTailBytes(this.#artifactTailRing, budget);
-			this.#artifactTailRing = text;
-			this.#artifactTailRingBytes = bytes;
-		}
+		if (this.#artifactTailRingBytes > budget + this.#artifactTailSlack) this.#trimArtifactTail();
+	}
+
+	#trimArtifactTail(): void {
+		if (this.#artifactTailRingBytes <= this.#artifactTailBudget) return;
+		const { text, bytes } = truncateTailBytes(this.#artifactTailRing, this.#artifactTailBudget);
+		this.#artifactTailRing = text;
+		this.#artifactTailRingBytes = bytes;
 	}
 
 	#recordArtifactError(operation: OutputArtifactError): void {
@@ -1413,11 +1432,13 @@ export class OutputSink {
 	#flushArtifactTailIfCapped(): void {
 		if (!this.#file || this.#artifactError) return;
 		if (this.#artifactMaxBytes === 0) return;
+		this.#trimArtifactTail();
 		const tailBytes = this.#artifactTailRingBytes;
 		const droppedBytes = Math.max(0, this.#artifactTailIncomingBytes - tailBytes);
 		if (tailBytes === 0 && droppedBytes === 0) return;
 
 		if (droppedBytes > 0) {
+			this.#artifactElidedBytes = droppedBytes;
 			const headWritten = this.#artifactHeadBytesWritten;
 			const totalCapped = headWritten + this.#artifactTailIncomingBytes;
 			const headSep = headWritten > 0 ? "\n" : "";
@@ -1505,6 +1526,10 @@ export class OutputSink {
 			columnTruncatedLines: this.#columnTruncatedLines > 0 ? this.#columnTruncatedLines : undefined,
 			columnMax: this.#columnTruncatedLines > 0 ? this.#maxColumns : undefined,
 			artifactId: this.#artifactError ? undefined : this.#file?.artifactId,
+			artifactElidedBytes:
+				this.#artifactError || !this.#file?.artifactId || this.#artifactElidedBytes === 0
+					? undefined
+					: this.#artifactElidedBytes,
 			artifactError: this.#artifactError,
 		};
 	}

package/src/tui.ts

@@ -1002,6 +1002,11 @@ export class TUI extends Container {
 		options?: OverlayOptions;
 		preFocus: Component | null;
 		hidden: boolean;
+		/**
+		 * A sheet the user clicked away from (see {@link TUI.#focusFromPointer}):
+		 * it stays up but no longer holds the keys, until focus moves back into it.
+		 */
+		released: boolean;
 	}[] = [];
 
 	constructor(terminal: Terminal, showHardwareCursor?: boolean, options?: TUIOptions) {
@@ -1120,12 +1125,14 @@ export class TUI extends Container {
 	}
 
 	setFocus(component: Component | null): void {
-		const topVisibleOverlay = this.#getTopmostVisibleOverlay();
-		if (topVisibleOverlay && !isOverlayFocusTarget(topVisibleOverlay.component, component)) {
+		const holder = this.#getKeyHolderOverlay();
+		if (holder && !isOverlayFocusTarget(holder.component, component)) {
 			const currentFocus = this.#focusedComponent;
-			component = isOverlayFocusTarget(topVisibleOverlay.component, currentFocus)
-				? currentFocus
-				: topVisibleOverlay.component;
+			component = isOverlayFocusTarget(holder.component, currentFocus) ? currentFocus : holder.component;
+		}
+		// Focus moving back into a released sheet makes it hold the keys again.
+		for (const entry of this.overlayStack) {
+			if (entry.released && isOverlayFocusTarget(entry.component, component)) entry.released = false;
 		}
 
 		const previousFocusedComponent = this.#focusedComponent;
@@ -1176,7 +1183,7 @@ export class TUI extends Container {
 	 */
 	showOverlay(component: Component, options?: OverlayOptions): OverlayHandle {
 		component.setIgnoreTight?.(true);
-		const entry = { component, options, preFocus: this.#focusedComponent, hidden: false };
+		const entry = { component, options, preFocus: this.#focusedComponent, hidden: false, released: false };
 		this.overlayStack.push(entry);
 		// Only focus if overlay is actually visible
 		if (this.#isOverlayVisible(entry)) {
@@ -1194,8 +1201,7 @@ export class TUI extends Container {
 					this.overlayStack.splice(index, 1);
 					// Restore focus if this overlay or one of its owned targets had focus
 					if (isOverlayFocusTarget(component, this.#focusedComponent)) {
-						const topVisible = this.#getTopmostVisibleOverlay();
-						this.setFocus(topVisible?.component ?? entry.preFocus);
+						this.setFocus(this.#getKeyHolderOverlay()?.component ?? entry.preFocus);
 					}
 					if (this.overlayStack.length === 0) {
 						this.terminal.hideCursor();
@@ -1209,10 +1215,9 @@ export class TUI extends Container {
 				entry.hidden = hidden;
 				// Update focus when hiding/showing
 				if (hidden) {
-					// If this overlay or one of its owned targets had focus, move focus to next visible or preFocus
+					// If this overlay or one of its owned targets had focus, move focus to the next one holding keys or preFocus
 					if (isOverlayFocusTarget(component, this.#focusedComponent)) {
-						const topVisible = this.#getTopmostVisibleOverlay();
-						this.setFocus(topVisible?.component ?? entry.preFocus);
+						this.setFocus(this.#getKeyHolderOverlay()?.component ?? entry.preFocus);
 					}
 				} else {
 					// Restore focus to this overlay when showing (if it's actually visible)
@@ -1230,9 +1235,8 @@ export class TUI extends Container {
 	hideOverlay(): void {
 		const overlay = this.overlayStack.pop();
 		if (!overlay) return;
-		// Find topmost visible overlay, or fall back to preFocus
-		const topVisible = this.#getTopmostVisibleOverlay();
-		this.setFocus(topVisible?.component ?? overlay.preFocus);
+		// Find the topmost visible overlay holding keys, or fall back to preFocus
+		this.setFocus(this.#getKeyHolderOverlay()?.component ?? overlay.preFocus);
 		if (this.overlayStack.length === 0) {
 			this.terminal.hideCursor();
 			this.#recordHardwareCursorHidden();
@@ -1312,6 +1316,39 @@ export class TUI extends Container {
 		return undefined;
 	}
 
+	/** The topmost visible overlay that holds the keys: not a sheet the user clicked away from. */
+	#getKeyHolderOverlay(): (typeof this.overlayStack)[number] | undefined {
+		for (let i = this.overlayStack.length - 1; i >= 0; i--) {
+			const entry = this.overlayStack[i];
+			if (!entry.released && this.#isOverlayVisible(entry)) return entry;
+		}
+		return undefined;
+	}
+
+	/**
+	 * Moves keyboard focus where the user clicked (the terminal's `focus` event,
+	 * see {@link NativeHost.focusFromPointer}). A click inside an overlay gives it
+	 * the keys unless they are already inside it. A click on `field` under the
+	 * overlays focuses it only when every visible overlay is a `sheet` (a panel
+	 * beside the content, like `/settings` docked in Tern): those stay up but
+	 * stop holding the keys until focus moves back into one of them.
+	 */
+	#focusFromPointer(
+		owners: readonly Component[],
+		field: Component | null,
+		sheet: (overlay: Component) => boolean,
+	): void {
+		const visible = this.overlayStack.filter(entry => this.#isOverlayVisible(entry));
+		const overlay = visible.findLast(entry => owners.some(owner => isOverlayFocusTarget(entry.component, owner)));
+		if (overlay) {
+			if (!isOverlayFocusTarget(overlay.component, this.#focusedComponent)) this.setFocus(overlay.component);
+			return;
+		}
+		if (!field || field === this.#focusedComponent || !visible.every(entry => sheet(entry.component))) return;
+		for (const entry of visible) entry.released = true;
+		this.setFocus(field);
+	}
+
 	override invalidate(): void {
 		super.invalidate();
 		for (const overlay of this.overlayStack) overlay.component.invalidate?.();
@@ -1616,6 +1653,7 @@ export class TUI extends Container {
 				return visible;
 			},
 			focused: () => this.#focusedComponent,
+			focusFromPointer: (owners, field, sheet) => this.#focusFromPointer(owners, field, sheet),
 			requestRender: () => this.requestRender(),
 			appearanceChanged: () => {
 				this.terminal.refreshAppearance?.();