@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.512

package/dist/app/session-shell/response-copy-transport.js

@@ -0,0 +1,217 @@
+import { fork } from "node:child_process";
+import { fstatSync } from "node:fs";
+import { HelperPool } from "./helper-pool.js";
+import { COPY_CHUNK_UNITS, COPY_CLEANUP_MS, MAX_COPY_BYTES, MAX_COPY_CONTROL_BYTES } from "./response-copy-protocol.js";
+/** Never substitute a remote host's native clipboard for the terminal user's clipboard. */
+export function responseCopyDestination(env) {
+    return env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY || env.TMUX || env.STY || env.WSL_DISTRO_NAME
+        ? "terminal" : "native";
+}
+/** Node documents synchronous POSIX TTY and Windows pipe writes; do not put clipboard traffic there. */
+export function hasAsyncClipboardOutput(platform = process.platform, stdout = process.stdout) {
+    if (stdout.isTTY)
+        return platform === "win32";
+    if (platform === "win32")
+        return false;
+    try {
+        const stat = fstatSync(stdout.fd ?? -1);
+        return stat.isFIFO() || stat.isSocket();
+    }
+    catch {
+        return false;
+    }
+}
+/** Isolates preparation and native clipboard access; only the owner may submit terminal controls. */
+export function createResponseCopyExecutor(options = {}) {
+    const pool = new HelperPool({ fork: () => forkCopyHelper(options.helper), stop: stopCopyHelper, ...(options.spareIdleMs === undefined ? {} : { idleMs: options.spareIdleMs }) });
+    const execute = (snapshot, phase) => {
+        const controller = new AbortController();
+        let active;
+        const run = async () => {
+            const destination = options.writeText === undefined ? options.destination ?? responseCopyDestination(process.env) : "prepare";
+            const execute = async (mode) => {
+                if (controller.signal.aborted)
+                    return { kind: "result", result: { outcome: "canceled" } };
+                if (mode === "terminal" && options.terminal === undefined) {
+                    return { kind: "result", result: { outcome: "failed", failure: "unsafe" } };
+                }
+                active = startHelper(snapshot, mode, options.terminal?.maxBytes ?? MAX_COPY_CONTROL_BYTES, phase, options.helper, pool);
+                if (controller.signal.aborted)
+                    active.cancel();
+                return active.result;
+            };
+            let outcome = await execute(destination);
+            // Concurrency: helper results settle only after exit; fallback cannot race an older native write.
+            if (!controller.signal.aborted && destination === "native" && outcome.result.failure === "unavailable" && options.terminal !== undefined) {
+                outcome = await execute("terminal");
+            }
+            if (controller.signal.aborted)
+                return { outcome: "canceled" };
+            if (destination === "prepare" && outcome.result.outcome === "delivered") {
+                if (outcome.text === undefined)
+                    return { outcome: "failed", failure: "transport" };
+                phase("submitting", outcome.bytes ?? 0, "injected");
+                await options.writeText(outcome.text, controller.signal);
+            }
+            if (outcome.result.outcome === "submitted-unverified") {
+                const control = "control" in outcome ? outcome.control : undefined;
+                if (typeof control !== "string" || !/^\u001b\]52;c;[A-Za-z0-9+/]*={0,2}\u0007$/u.test(control)
+                    || Buffer.byteLength(control) > Math.min(MAX_COPY_CONTROL_BYTES, options.terminal === undefined ? 0 : options.terminal.maxBytes ?? MAX_COPY_CONTROL_BYTES)) {
+                    return { outcome: "failed", failure: "transport" };
+                }
+                phase("submitting", control.length, "terminal");
+                await options.terminal.submit(control, controller.signal);
+            }
+            return controller.signal.aborted ? { outcome: "canceled" } : outcome.result;
+        };
+        const result = run().catch(() => ({ outcome: controller.signal.aborted ? "canceled" : "failed", failure: "transport" }));
+        return { result, stopped: result.then(() => { }), cancel: () => { controller.abort(); active?.cancel(); } };
+    };
+    // Rationale: `Object.assign` would copy the getter's value once; the accessor must read the pool each time.
+    return Object.defineProperties(execute, {
+        warm: { value: () => pool.warm() },
+        dispose: { value: () => pool.dispose() },
+        warmed: { get: () => pool.warmed },
+    });
+}
+/** Forks one copy helper: bounded IPC only, no clipboard payload in argv or temp files, no inherited terminal descriptors. */
+function forkCopyHelper(helper) {
+    const source = new URL(import.meta.url).pathname.endsWith(".ts");
+    const entry = helper ?? new URL(source ? "./response-copy-helper.ts" : "./response-copy-helper.js", import.meta.url);
+    const forkOptions = {
+        execArgv: entry.pathname.endsWith(".ts") ? ["--import", "tsx"] : [],
+        stdio: ["ignore", "ignore", "ignore", "ipc"], windowsHide: true,
+        serialization: "json",
+    };
+    return fork(entry, [], forkOptions);
+}
+function stopCopyHelper(child) {
+    child.kill("SIGKILL");
+    child.unref();
+    child.channel?.unref();
+}
+function* sourceMessages(snapshot, mode, controlLimit) {
+    yield { kind: "begin", selection: snapshot.selection, rows: snapshot.rows.length, mode, controlLimit,
+        ...(snapshot.literal === undefined ? {} : { literal: snapshot.literal }) };
+    for (const row of snapshot.rows) {
+        for (let offset = 0; offset < Math.max(1, row.text.length); offset += COPY_CHUNK_UNITS) {
+            yield { kind: "row", text: row.text.slice(offset, offset + COPY_CHUNK_UNITS), end: offset + COPY_CHUNK_UNITS >= row.text.length,
+                ...(row.prompt === undefined ? {} : { prompt: row.prompt }) };
+        }
+    }
+    yield { kind: "finish" };
+}
+function startHelper(snapshot, mode, controlLimit, phase, helper, pool) {
+    // Performance: a warm spare skips fork and module load on the copy's own critical path.
+    const spare = pool.take();
+    const child = spare?.child ?? forkCopyHelper(helper);
+    let iterator = sourceMessages(snapshot, mode, controlLimit);
+    let outcome;
+    let stopping = false;
+    let prepared = [], preparedBytes = 0, expectedBytes;
+    const observedPhases = new Set();
+    let cleanup;
+    const stop = (discard) => {
+        if (stopping)
+            return;
+        stopping = true;
+        if (discard)
+            prepared = [];
+        iterator = undefined;
+        child.kill("SIGKILL");
+        // Concurrency: a kernel-stuck child is quarantined by the coordinator, not allowed to pin UI shutdown.
+        cleanup = setTimeout(() => { child.unref(); child.channel?.unref(); }, COPY_CLEANUP_MS);
+        cleanup.unref();
+    };
+    const cancel = () => stop(true);
+    // Invariant: reaping keeps a complete result's prepared text; discarding it would write "" to the clipboard.
+    const reap = () => stop(false);
+    const result = new Promise(resolve => {
+        let settled = false;
+        const settle = () => {
+            if (settled)
+                return;
+            settled = true;
+            const value = outcome ?? { kind: "result", result: { outcome: "failed", failure: "transport" } };
+            if (mode === "prepare" && value.result.outcome === "delivered") {
+                resolve(expectedBytes === preparedBytes ? { ...value, text: prepared.join(""), bytes: preparedBytes }
+                    : { kind: "result", result: { outcome: "failed", failure: "transport" } });
+            }
+            else
+                resolve(value);
+            prepared = [];
+        };
+        const advance = () => {
+            const next = iterator?.next();
+            if (next === undefined || next.done) {
+                cancel();
+                return;
+            }
+            child.send(next.value, error => { if (error)
+                cancel(); });
+        };
+        child.on("message", value => {
+            const message = value;
+            if (stopping)
+                return;
+            if (message?.kind === "ready") {
+                advance();
+            }
+            else if (message?.kind === "data") {
+                if (mode !== "prepare" || expectedBytes === undefined || typeof message.text !== "string" || message.text.length > COPY_CHUNK_UNITS) {
+                    cancel();
+                    return;
+                }
+                preparedBytes += Buffer.byteLength(message.text);
+                if (preparedBytes > MAX_COPY_BYTES) {
+                    cancel();
+                    return;
+                }
+                prepared.push(message.text);
+                child.send({ kind: "next" }, error => { if (error)
+                    cancel(); });
+            }
+            else if (message?.kind === "phase" && ["extracted", "encoded", "submitting"].includes(message.phase)
+                && Number.isSafeInteger(message.bytes) && message.bytes >= 0) {
+                if (observedPhases.has(message.phase)) {
+                    cancel();
+                    return;
+                }
+                observedPhases.add(message.phase);
+                if (message.phase === "extracted")
+                    expectedBytes = message.bytes;
+                phase(message.phase, message.bytes, mode === "prepare" ? "injected" : mode);
+            }
+            else if (message?.kind === "result" && ["delivered", "submitted-unverified", "failed"].includes(message.result?.outcome)) {
+                outcome = message;
+                iterator = undefined;
+                // Concurrency: a result is not an exit fence; bound a helper that sends a result but never exits.
+                cleanup = setTimeout(reap, COPY_CLEANUP_MS);
+                cleanup.unref();
+            }
+            else
+                cancel();
+        });
+        child.once("error", cancel);
+        child.once("exit", () => {
+            iterator = undefined;
+            if (cleanup !== undefined)
+                clearTimeout(cleanup);
+            child.removeAllListeners("message");
+            settle();
+            // Performance: the next copy finds a spare that was forked while nothing waited on it.
+            pool.replenish();
+        });
+        // Platform: spawn failure has no exit event, but has a close event and no live executor to fence.
+        child.once("close", () => {
+            iterator = undefined;
+            if (cleanup !== undefined)
+                clearTimeout(cleanup);
+            settle();
+        });
+        // Protocol: a spare already announced itself while pooled, so its first request is sent now rather than on "ready".
+        if (spare?.ready)
+            advance();
+    });
+    return { result, cancel };
+}

package/dist/app/session-shell/session-shell-root.d.ts

@@ -0,0 +1,265 @@
+import type { OwnedUiPromptSuggestionGeneratorPort, OwnedUiSessionViewModel, OwnedUiViewportSettings, OwnedUiViewportSettingsPort, OwnedUiQuitOutroSettingsPort, SuggestionDecision, SuggestionDiagnosticObserver } from "../../contracts/owned-ui/index.js";
+import type { PiTuiPointerSurface } from "../../integrations/pi/tui-runtime/contracts.js";
+import type { UiRouteHost } from "../../ui/apps/contracts.js";
+import type { TranscriptViewportFrame, TranscriptViewportFrameDescriptor } from "../../ui/components/transcript-viewport.js";
+import type { PiEngineAdapter } from "../../integrations/pi/engine/adapter.js";
+import type { PiWorkflowMessage, PiWorkflowResult } from "../../integrations/pi/engine/workflows.js";
+import { type PiShellClipboardContent, type PiShellComponentPort, type PiShellEditorPort, type PiShellExtensionRendererResolver, type PiShellHeaderOptions, type PiShellHeaderPort, type PiShellImageAssetResolver, type PiShellLoadedResourcesPort, type PiShellResourceEntry, type PiShellTranscriptComponentPort } from "../../integrations/pi/components/shell-shared-facade.js";
+import { type PiTuiInputCoordinationScheduler, type PiTuiInputSurfaceKind } from "../../integrations/pi/tui-runtime/input-presentation-coordinator.js";
+import type { PiTuiComponentPort, PiTuiInputDiagnosticsEvent, PiTuiLayoutNode, PiTuiTerminalPort } from "../../integrations/pi/tui-runtime/contracts.js";
+import { type PreparedPrompt } from "./prompt-chips.js";
+import type { PastePreparationClientOptions } from "./paste-preparation-client.js";
+import { type SessionViewportInputResult } from "./session-viewport-controller.js";
+import type { ResponseCopyExecutor } from "./response-copy-transport.js";
+import type { ResponseCopyEvent } from "./response-copy-protocol.js";
+import type { PasteEvent, PasteSource } from "./paste-protocol.js";
+import type { StreamPresentationScheduler } from "./stream-presentation-coalescer.js";
+export type OwnedUiBackendPort = PiEngineAdapter;
+export type OwnedUiTerminalPort = PiTuiTerminalPort;
+type OwnedUiStartupOptions = PiShellHeaderOptions;
+export interface OwnedUiClipboardPort {
+    readText(signal?: AbortSignal): Promise<string | null>;
+    readImage?(signal?: AbortSignal): Promise<{
+        readonly data: string;
+        readonly mimeType: string;
+    } | null>;
+    writeText?(text: string, signal?: AbortSignal): Promise<void>;
+}
+/** The engine session the shell presents and the composition's decisions about it. */
+export interface OwnedUiShellEngineOptions {
+    readonly backend: OwnedUiBackendPort;
+    readonly cwd: string;
+    /**
+     * Declared A1-owned routes. A route this host claims resolves to its app;
+     * every other route continues to the pinned workflow table unchanged.
+     */
+    readonly routeHost?: UiRouteHost;
+    /** Bare A1 selects the owned bounded viewport; comparison profiles stay pinned. */
+    readonly sessionLayout?: "pinned" | "custom-viewport";
+}
+/** Terminal, startup, viewport, and presentation-cadence seams; production leaves most at their defaults. */
+export interface OwnedUiShellPresentationOptions {
+    readonly terminal?: OwnedUiTerminalPort;
+    readonly startup?: OwnedUiStartupOptions;
+    /** Live profile-local settings, supplied only to the bare-A1 composition. */
+    readonly viewportSettings?: OwnedUiViewportSettingsPort;
+    /** Deterministic scheduling seam for presentation-cadence tests. */
+    readonly stream?: {
+        readonly intervalMs?: number;
+        readonly scheduler?: StreamPresentationScheduler;
+    };
+    /**
+     * Minimum time the reload box stays visible so a fast reload still reads as one.
+     * Production uses the default hold; tests inject `now`/`sleep` for determinism.
+     */
+    readonly reload?: {
+        readonly minVisibleMs?: number;
+        readonly now?: () => number;
+        readonly sleep?: (ms: number) => Promise<void>;
+    };
+    /**
+     * Quit outro settings and seams, supplied only to the bare-A1 composition.
+     * `interactive` states whether the terminal can show the animation; production
+     * passes stdout's TTY state, tests opt in explicitly.
+     */
+    readonly quitOutro?: OwnedUiQuitOutroSettingsPort & {
+        readonly interactive: boolean;
+        readonly now?: () => number;
+        readonly sleep?: (ms: number) => Promise<void>;
+        readonly seed?: number;
+    };
+    readonly input?: {
+        readonly scheduler?: PiTuiInputCoordinationScheduler;
+        readonly onEvent?: (event: PiTuiInputDiagnosticsEvent) => void;
+        readonly now?: () => number;
+        /** Evidence-only baseline seam; production leaves coordination enabled. */
+        readonly coordination?: boolean;
+        /** Evidence-only baseline seam; production leaves dock reuse enabled. */
+        readonly viewportReuse?: boolean;
+    };
+}
+/** Persistent prompt history: its store, its bound, the editor that recalls it, and the image sidecar. */
+export interface OwnedUiShellHistoryOptions {
+    readonly store: import("../../contracts/owned-ui/index.js").PromptHistoryPort;
+    readonly limit: number;
+    readonly editor: import("../../integrations/pi/components/index.js").HistoryEditorConstructor;
+    /** Optional per-profile filesystem sidecar for image chip payloads. When present, submit
+     * writes each referenced attachment and recall reads them back to rehydrate live chips.
+     * When absent, image chips silently strip on recall, matching the missing-sidecar path. */
+    readonly imageSidecar?: import("../../contracts/owned-ui/index.js").PromptHistoryImageSidecarPort;
+}
+/** Contextual prompt suggestions: the generator, the enablement setting, and an optional evidence seam. */
+export interface OwnedUiShellSuggestionOptions {
+    readonly diagnostics?: SuggestionDiagnosticObserver;
+    readonly generator: OwnedUiPromptSuggestionGeneratorPort;
+    readonly enabled: () => boolean;
+    readonly onChange: (listener: (enabled: boolean) => void) => () => void;
+}
+/** Clipboard seams and payload-free diagnostics; comparison profiles ignore the diagnostics. */
+export interface OwnedUiShellDiagnosticOptions {
+    /** Optional platform seam; production uses A1's system clipboard adapter. */
+    readonly clipboard?: OwnedUiClipboardPort;
+    /** Owned response-copy transport and payload-free diagnostic seams. */
+    readonly responseCopy?: {
+        readonly execute?: ResponseCopyExecutor;
+        readonly onEvent?: (event: ResponseCopyEvent) => void;
+    };
+    /** Bounded, payload-free clipboard acquisition/preparation observations. */
+    readonly paste?: (event: PasteEvent) => void;
+    /** Test seams for isolated paste preparation: an in-process starter, or the forked helper's entry. */
+    readonly pastePreparation?: Omit<PastePreparationClientOptions, "onEvent" | "spareIdleMs">;
+}
+/** What composes an owned session shell, grouped by the collaborator that provides each part. */
+export interface OwnedUiSessionShellOptions {
+    readonly engine: OwnedUiShellEngineOptions;
+    readonly presentation?: OwnedUiShellPresentationOptions;
+    readonly history?: OwnedUiShellHistoryOptions;
+    readonly suggestions?: OwnedUiShellSuggestionOptions;
+    readonly diagnostics?: OwnedUiShellDiagnosticOptions;
+}
+/** Composes backend session state into the owned transcript, viewport, editor, and dock presentation. */
+export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
+    #private;
+    readonly editor: PiShellEditorPort;
+    readonly header: PiShellHeaderPort;
+    readonly resources: PiShellLoadedResourcesPort;
+    constructor(view: OwnedUiSessionViewModel, cwd: string, handlers: {
+        readonly getColumns: () => number;
+        readonly getRows: () => number;
+        readonly requestRender: (force?: boolean) => void;
+        readonly onViewportFrame?: (frame: TranscriptViewportFrame) => void;
+        readonly requestHyperlinkCleanup?: (rows?: readonly number[]) => void;
+        readonly enableDockInputReuse?: boolean;
+        readonly persistentHistory?: boolean;
+        readonly historyEditor?: import("../../integrations/pi/components/index.js").HistoryEditorConstructor;
+        readonly onSubmit: (text: string) => void;
+        readonly onPasteRejected?: (error: unknown) => void;
+        readonly onInterrupt: () => void;
+        readonly onClear?: () => void;
+        readonly onExit: () => void;
+        readonly onModelSelect: () => void;
+        readonly onModelCycle?: (direction: "forward" | "backward") => void;
+        readonly onThinkingCycle: () => void;
+        readonly onThinkingToggle?: () => void;
+        readonly onMessageCopy?: () => void;
+        readonly onFollowUp?: () => void;
+        readonly onDequeue?: () => void;
+        readonly onEditorChange?: (text: string) => void;
+        readonly onPromptSuggestionAccepted?: (text: string) => void;
+        readonly onInputSurfaceChanged?: () => void;
+        readonly onCopyText?: (text: string) => void;
+        readonly readClipboardContent?: (signal?: AbortSignal) => Promise<PiShellClipboardContent | null>;
+        readonly captureClipboardPaste?: () => PasteSource;
+        readonly pasteDiagnostics?: (event: PasteEvent) => void;
+        readonly pastePreparation?: Omit<PastePreparationClientOptions, "onEvent">;
+    }, startup?: PiShellHeaderOptions, agentDir?: string, extensionRenderers?: PiShellExtensionRendererResolver, sessionLayout?: "pinned" | "custom-viewport", imageAssets?: PiShellImageAssetResolver);
+    setEditorPaddingX(padding: number): void;
+    setAutocompleteMaxVisible(maxVisible: number): void;
+    setOutputPad(padding: 0 | 1): void;
+    setHideThinkingBlock(hidden: boolean): void;
+    setMermaidRenderingMode(mode: "off" | "final" | "streaming"): void;
+    setImagePresentation(showImages: boolean, imageWidthCells: number): void;
+    prepareHistoryText(text: string): string;
+    rehydrateHistoryText(text: string, resolveImage: (id: string) => import("../../contracts/owned-ui/index.js").PromptHistoryImageSidecarAttachment | null): string;
+    imageChipAttachmentsFromEditor(text: string): {
+        readonly id: string;
+        readonly tag: string;
+        readonly image: {
+            readonly type: "image";
+            readonly data: string;
+            readonly mimeType: string;
+        };
+    }[];
+    preparePromptSubmission(text: string): PreparedPrompt;
+    hasPendingPastes(text: string): boolean;
+    waitForPromptPastes(text: string, signal: AbortSignal): Promise<PreparedPrompt>;
+    resetPendingPastes(): void;
+    /** Forks the spare paste helper so the first paste of the session takes a live child. */
+    warmPastePreparation(): void;
+    disposePendingPastes(): Promise<void>;
+    promptSuggestionPrepareBlockReason(): SuggestionDecision;
+    canPreparePromptSuggestion(): boolean;
+    promptSuggestionPresentationBlockReason(): SuggestionDecision;
+    canPresentPromptSuggestion(): boolean;
+    setPromptSuggestion(text: string | null): void;
+    update(view: OwnedUiSessionViewModel): void;
+    /**
+     * Applies one block: its component is created or updated in place and the order grows
+     * only when the block is new. A streamed chunk costs one component update rather than a
+     * walk of the whole transcript.
+     */
+    applyTranscriptBlock(block: OwnedUiSessionViewModel["transcript"][number]): void;
+    render(width: number): readonly string[];
+    viewportFrameDescriptor(): TranscriptViewportFrameDescriptor | null;
+    /** Read-only, payload-free evidence; observing a pending frame must never render or repair it. */
+    viewportPresentationEvidence(): {
+        candidate: boolean;
+        candidateRevision: number | null;
+        currentRevision: number;
+        composedRevision: number | null;
+        currentPointer: {
+            readonly column: number;
+            readonly row: number;
+        } | null;
+        composedPointer: {
+            readonly column: number;
+            readonly row: number;
+        } | null;
+        frameId: number | null;
+        bottom: {
+            readonly row: number;
+            readonly columnStart: number;
+            readonly columnEnd: number;
+        } | null;
+        followingEnd: boolean;
+        scrollTop: number;
+        maxScroll: number;
+        cause: "initial" | "steady" | "dock-input" | "follow-shift" | "detached" | "geometry-change" | null;
+    };
+    /** Visible non-selectable Steering, alignment, and Working rows, for rendering evidence. */
+    viewportTransientTailRowCount(): number;
+    hasActiveSelection(): boolean;
+    setViewportConfig(config: OwnedUiViewportSettings): void;
+    resumeViewportFollowing(): void;
+    noteCompletedAssistantMessage(): void;
+    /** A new session binding owns new mounts even when it reuses semantic invocation ids. */
+    resetTranscript(): void;
+    resetViewport(): void;
+    clearViewportPointerState(): void;
+    setViewportOverlaySurfaces(surfaces: readonly PiTuiPointerSurface[] | null): void;
+    viewportInputGeometryReady(width: number, height: number): boolean;
+    handleViewportPreInput(data: string, allowWheel?: boolean, now?: number, editorActive?: boolean): SessionViewportInputResult;
+    layoutRoot(): PiTuiLayoutNode;
+    transcriptComponent(id: string): PiShellTranscriptComponentPort | undefined;
+    exitTranscript(width: number): string;
+    appendWorkflowStatus(message: string): void;
+    appendWorkflowMessage(message: PiWorkflowMessage): void;
+    appendWorkflowResult(result: PiWorkflowResult): void;
+    appendDaxnuts(): void;
+    toggleThinkingVisibility(): void;
+    get toolsExpanded(): boolean;
+    setToolsExpanded(expanded: boolean): void;
+    setExtensionWidget(key: string, component: PiShellComponentPort | null, placement: "aboveEditor" | "belowEditor"): void;
+    setExtensionHeader(component: PiShellComponentPort | null): void;
+    setExtensionFooter(component: PiShellComponentPort | null): void;
+    setExtensionStatus(key: string, text: string | undefined): void;
+    setExtensionWorking(message: string | undefined, visible?: boolean): void;
+    resetWorkflowPresentation(): void;
+    resetExtensionUi(): void;
+    addExtensionNotification(message: string, type: "info" | "warning" | "error"): void;
+    extensionFooterData(): unknown;
+    usesDefaultInputSurface(): boolean;
+    inputCoordinationSurface(): PiTuiInputSurfaceKind;
+    viewportCompositionEvidence(): {
+        readonly full: number;
+        readonly dockOnly: number;
+    };
+    transcriptRenderCount(): number;
+    setInputSurface(component: PiShellComponentPort | null, disposePrevious?: boolean, coordination?: Exclude<PiTuiInputSurfaceKind, "editor">): void;
+    handleInput(data: string): void;
+    invalidate(): void;
+    setFocused(focused: boolean): void;
+    dispose(): void;
+}
+export declare function shellResourceEntries(backend: OwnedUiBackendPort): readonly PiShellResourceEntry[];
+export {};