@timurproko/a1 0.1.1-dev.1 → 0.1.1-dev.10

package/README.md

@@ -1,20 +1,11 @@
 # A1
 
-A1 is a terminal-native agent launcher for Windows, Linux, and macOS. Bare `a1` runs the A1-owned Pi-compatible UI, while explicit fallback profiles can launch untouched Pi directly. A1 also manages release selection, process ownership, and updates.
-
 ## Install
 
-Requirements:
-
-- Node.js 22.19 through 24.x
-- npm 11
-
 ```sh
 npm install --global @timurproko/a1@latest
 ```
 
-The package installs only the `a1` command.
-
 ## Commands
 
 ```sh
@@ -26,45 +17,19 @@ a1 update       # update to npm latest
 a1 update:next  # update to npm next
 ```
 
-Bare `a1` owns its Pi-compatible TUI composition and uses the public Pi engine, components, and terminal APIs. It does not insert a PTY or terminal-byte relay. Default visuals and workflows track the pinned vanilla Pi baseline; A1-specific visual customization and structured tabs remain disabled.
-
-`a1 pi` is the untouched upstream fallback and comparison oracle. Use it to distinguish A1-owned UI problems from upstream Pi, profile, provider, or terminal problems. The `a1 ui` subcommand was removed and is not a compatibility alias; run bare `a1` for the owned UI.
-
-`a1 sandbox` is unchanged: it launches vanilla Pi with isolated Pi configuration and resources. “Sandbox” does not mean operating-system, filesystem, process, network, or credential security isolation. See [`docs/features/launch-profiles.md`](docs/features/launch-profiles.md) for first-run directories, independent `/login`, trust behavior, extension placement, and recovery.
-
 ## Develop
 
 ```sh
-npm ci
-npm run build
-npm start
+npm ci              # install exact locked dependencies
+npm run build       # compile TypeScript and the process guardian into dist
+npm start           # build and launch an isolated development instance
+npm run test:fast   # typecheck + fast suite, no build needed
+npm test            # same as test:fast
+npm run test:full   # complete non-physical suite
 ```
 
-`npm start` gives each invocation isolated A1 development state and an isolated development Pi profile. Use `npm start -- --print-environment` to inspect the selected paths without launching the UI.
-
-A1 control state uses `%APPDATA%\\A1` and `%LOCALAPPDATA%\\A1` on Windows, and the `a1` directory under XDG config/data/runtime roots on Unix. Override it only with declared `A1_*` variables such as `A1_CONFIG_DIR`, `A1_DATA_DIR`, `A1_RUNTIME_DIR`, `A1_DATABASE_PATH`, and `A1_ENDPOINT`. Pi profile roots remain `~/.a1/agent`, `~/.pi/agent`, and `~/.a1/sandbox`. This is a no-migration identity hard cut; see [`docs/architecture/toolchain.md`](docs/architecture/toolchain.md#identity-hard-cut-and-cleanup) before removing obsolete control state.
-
-Run the non-desktop gates with:
+## Release
 
 ```sh
-npm run typecheck
-npm run check:architecture
-npm run check:deprecated
-npm test
-npm run test:release
+npm run release:next   # publish current develop tip to npm next via trusted CI workflows
 ```
-
-Automated physical-terminal interaction must never run on an active workstation. Future physical certification may run only on dedicated disposable workers or VMs with exclusive test desktops.
-
-## Releases
-
-An exact manually accepted `-dev.N` candidate may publish under npm tag `next` after applicable non-desktop gates pass. Such a preview is explicitly uncertified, cannot move `latest`, and cannot claim stable terminal parity or platform support. Stable claims require deferred physical and cross-platform certification against the exact package.
-
-Trusted preview publication uses `.github/workflows/publish-next.yml` and npm provenance. Local release mechanics are documented in [`docs/architecture/toolchain.md`](docs/architecture/toolchain.md).
-
-## Architecture
-
-- [`docs/architecture/boundaries.md`](docs/architecture/boundaries.md)
-- [`docs/architecture/toolchain.md`](docs/architecture/toolchain.md)
-- [`docs/manual-transparent-checkpoint.md`](docs/manual-transparent-checkpoint.md)
-- [`docs/features/launch-profiles.md`](docs/features/launch-profiles.md)

package/bin/guardian.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+const { fileURLToPath } = await import("node:url");
+const { resolve } = await import("node:path");
+const { runLaunchGuardian } = await import("../dist/src/foundation/launch-guardian/index.js");
+
+const releaseRoot = process.env.A1_RELEASE_ROOT ?? fileURLToPath(new URL("..", import.meta.url));
+const profileId = process.env.A1_LAUNCH_PROFILE ?? "a1";
+
+runLaunchGuardian({
+  profileId,
+  releaseRoot,
+  uiEntry: resolve(releaseRoot, "bin", "ui.js"),
+  environment: process.env,
+  cwd: process.cwd(),
+}).then(
+  code => { process.exitCode = code; },
+  error => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  },
+);

package/bin/{a1-ui.js → ui.js}

@@ -3,17 +3,13 @@
 const { runSelectedInteractiveRuntime } = await import("../dist/src/features/launch/index.js");
 
 runSelectedInteractiveRuntime(process.env.A1_LAUNCH_PROFILE ?? "a1", {
-  ownedUi: async () => {
-    const [{ runOwnedUi }, { composeOwnedUiApplication }] = await Promise.all([
+  ownedUi: async (profileId, ownedSurfaces) => {
+    const [{ runOwnedUi }, { composeOwnedUi }] = await Promise.all([
       import("../dist/src/features/owned-ui/index.js"),
       import("../dist/src/composition/index.js"),
     ]);
-    const application = await composeOwnedUiApplication({ cwd: process.cwd() });
-    return await runOwnedUi({ application });
-  },
-  transparent: async profileId => {
-    const { runSelectedTransparentRuntime } = await import("../dist/src/composition/transparent-runtime.js");
-    return await runSelectedTransparentRuntime(profileId);
+    const { application, settings } = await composeOwnedUi({ cwd: process.cwd(), profileId, ownedSurfaces });
+    return await runOwnedUi({ application, ...(settings === null ? {} : { settings }) });
   },
 }).then(
   code => { process.exitCode = code; },

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

@@ -0,0 +1,20 @@
+{
+  "schema": "a1-process-guardian-artifact-v1",
+  "protocolVersion": 1,
+  "crateVersion": "0.1.0-dev",
+  "platform": "darwin",
+  "architecture": "arm64",
+  "capability": "unsupported",
+  "builtAt": "2026-08-23T09:02:26.759Z",
+  "artifact": {
+    "filename": "process-guardian",
+    "sha256": "7524bf568992517f50ed53196c861c5edeba0d7275633bb4735ab45bd5963a28",
+    "size": 356368
+  },
+  "provenance": {
+    "language": "Rust",
+    "cargoLock": "native/process-guardian/Cargo.lock",
+    "sourceRoot": "native/process-guardian",
+    "signatureStatus": "ci-attestation-required"
+  }
+}

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

@@ -0,0 +1,20 @@
+{
+  "schema": "a1-process-guardian-artifact-v1",
+  "protocolVersion": 1,
+  "crateVersion": "0.1.0-dev",
+  "platform": "linux",
+  "architecture": "x64",
+  "capability": "supported",
+  "builtAt": "2026-08-23T09:02:48.237Z",
+  "artifact": {
+    "filename": "process-guardian",
+    "sha256": "29e22fe29de2828982bc67ef418c4adcaab1490281477b7bea592ec6fe621bcd",
+    "size": 415696
+  },
+  "provenance": {
+    "language": "Rust",
+    "cargoLock": "native/process-guardian/Cargo.lock",
+    "sourceRoot": "native/process-guardian",
+    "signatureStatus": "ci-attestation-required"
+  }
+}

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

@@ -0,0 +1,20 @@
+{
+  "schema": "a1-process-guardian-artifact-v1",
+  "protocolVersion": 1,
+  "crateVersion": "0.1.0-dev",
+  "platform": "win32",
+  "architecture": "x64",
+  "capability": "supported",
+  "builtAt": "2026-08-23T09:02:55.602Z",
+  "artifact": {
+    "filename": "process-guardian.exe",
+    "sha256": "0487a97a0676a7cdbe7b5328b38d555a568ea54eaa26fadb2e9e62e18cf3211b",
+    "size": 172544
+  },
+  "provenance": {
+    "language": "Rust",
+    "cargoLock": "native/process-guardian/Cargo.lock",
+    "sourceRoot": "native/process-guardian",
+    "signatureStatus": "ci-attestation-required"
+  }
+}

package/dist/src/composition/index.d.ts

@@ -1,6 +1,8 @@
 import { type AgentEnginePort } from "../foundation/agent-engine-contracts/index.js";
 import { type PiEngineAdapter } from "../foundation/pi-engine-adapter/index.js";
 import { type OwnedUiApplicationPort, type PresentationComponentPort, type PresentationRuntimePort, type PresentationTerminalPort } from "../foundation/presentation-contracts/index.js";
+import { OwnedUiSettingsSession } from "../foundation/owned-ui-settings/index.js";
+import type { UiRouteHost } from "../foundation/pi-owned-ui-integration/index.js";
 export interface ProcessCompositionOptions {
     readonly cwd?: string;
     readonly sessionId?: string;
@@ -12,11 +14,35 @@ export interface OwnedUiCompositionOptions {
     readonly cwd?: string;
     readonly terminal?: PresentationTerminalPort;
     readonly createPiAdapter?: () => Promise<PiEngineAdapter>;
+    /**
+     * A1 profile whose settings this session reads and writes. Omitted keeps the
+     * session settings-free, which is what the pinned comparison paths use.
+     */
+    readonly profileId?: string;
+    /**
+     * Whether A1's own surfaces are reachable. Withheld for the rendering parity
+     * comparison, which measures this composition against pinned Pi and so must
+     * present Pi's interface and nothing of A1's own. It is the same composition
+     * either way: a parity run built beside the product would measure itself.
+     */
+    readonly ownedSurfaces?: "on" | "off";
+}
+export interface OwnedUiComposition {
+    readonly application: OwnedUiApplicationPort;
+    /** Present when a profile was supplied, so the caller can resolve settings before start. */
+    readonly settings: OwnedUiSettingsSession | null;
 }
 export declare function composeOwnedUiApplication(options?: OwnedUiCompositionOptions): Promise<OwnedUiApplicationPort>;
+export declare function composeOwnedUi(options?: OwnedUiCompositionOptions): Promise<OwnedUiComposition>;
 export interface ProcessComposition {
     readonly engine: AgentEnginePort;
     createPresentation(root: PresentationComponentPort, terminal: PresentationTerminalPort): PresentationRuntimePort;
     dispose(): Promise<void>;
 }
 export declare function composeProcess(options?: ProcessCompositionOptions): Promise<ProcessComposition>;
+/**
+ * Registers the A1-owned screens and adapts the app host to the shell's route
+ * seam. The shell mounts whatever surface it is handed and forwards keys; it
+ * never learns what an app is.
+ */
+export declare function createOwnedRouteHost(settings: OwnedUiSettingsSession): UiRouteHost;

package/dist/src/composition/index.js

@@ -3,6 +3,12 @@ import { createPiEngineAdapter } from "../foundation/pi-engine-adapter/index.js"
 import { createPiPresentationRuntime, createPiTerminalBridge } from "../foundation/pi-tui-runtime-adapter/index.js";
 import { assertPresentationComponent, assertPresentationRuntime, } from "../foundation/presentation-contracts/index.js";
 import { OwnedUiSessionShell } from "../foundation/pi-owned-ui-integration/index.js";
+import { OwnedUiSettingsSession, OwnedUiSettingsStore } from "../foundation/owned-ui-settings/index.js";
+import { UiAppHost, UiAppRegistry } from "../foundation/ui-apps/index.js";
+import { applyConfiguredPiTheme, getAvailablePiThemes, piTheme } from "../foundation/pi-component-adapter/index.js";
+import { faint } from "../foundation/ui-components/index.js";
+import { SETTINGS_APP_ID, SETTINGS_ROUTE, SettingsApp } from "../features/owned-ui/index.js";
+import { resolveProductPaths } from "../foundation/lifecycle/index.js";
 const CAPABILITIES = {
     contractVersion: AGENT_ENGINE_CONTRACT_VERSION,
     commands: ["prompt", "steer", "follow-up", "abort", "retry", "compact", "bash", "replace-session"],
@@ -10,20 +16,37 @@ const CAPABILITIES = {
     snapshots: { supported: true, maxBytes: 1024 * 1024 },
 };
 export async function composeOwnedUiApplication(options = {}) {
+    return (await composeOwnedUi(options)).application;
+}
+export async function composeOwnedUi(options = {}) {
     const cwd = options.cwd ?? process.cwd();
-    const adapter = options.createPiAdapter ? await options.createPiAdapter() : await createPiEngineAdapter({ cwd });
+    const adapter = options.createPiAdapter
+        ? await options.createPiAdapter()
+        : await createPiEngineAdapter({ cwd, availableThemes: () => getAvailablePiThemes().map(theme => theme.name) });
+    const settings = options.profileId === undefined
+        ? null
+        : new OwnedUiSettingsSession({
+            store: new OwnedUiSettingsStore({ configDir: resolveProductPaths().configDir, profileId: options.profileId }),
+            agentProvider: () => adapter.settingsPort(),
+        });
+    // Before anything is drawn, so every surface uses the configured theme rather
+    // than the one guessed from the terminal's background.
+    applyConfiguredPiTheme(adapter.configuredTheme());
+    const routeHost = settings === null || options.ownedSurfaces === "off" ? null : createOwnedRouteHost(settings);
     const shell = new OwnedUiSessionShell({
         backend: adapter,
         cwd,
         ...(options.terminal === undefined ? {} : { terminal: createPiTerminalBridge(options.terminal) }),
+        ...(routeHost === null ? {} : { routeHost }),
     });
-    return {
+    const application = {
         get disposed() { return adapter.disposed; },
         start: () => shell.start(),
         flush: () => adapter.flushEvents(),
         waitUntilStopped: () => shell.waitUntilStopped(),
         dispose: () => shell.dispose(),
     };
+    return { application, settings };
 }
 export async function composeProcess(options = {}) {
     let engine = options.engine;
@@ -164,3 +187,72 @@ function toMessage(block) {
     const role = block.kind === "user" ? "user" : block.kind === "system" ? "system" : block.kind === "tool-call" || block.kind === "tool-result" ? "tool" : "assistant";
     return { id: block.id, role, status: block.status === "live" ? "streaming" : "final", content: [{ kind: "text", text: block.text }] };
 }
+/**
+ * Registers the A1-owned screens and adapts the app host to the shell's route
+ * seam. The shell mounts whatever surface it is handed and forwards keys; it
+ * never learns what an app is.
+ */
+export function createOwnedRouteHost(settings) {
+    const registry = new UiAppRegistry();
+    registry.register({ id: SETTINGS_APP_ID, route: SETTINGS_ROUTE, create: () => new SettingsApp(settings) });
+    return {
+        claims: route => registry.forRoute(route) !== null,
+        open: route => {
+            const registration = registry.forRoute(route);
+            if (registration === null)
+                return null;
+            let size = { width: 80, height: 24 };
+            let frame = [];
+            let closed = false;
+            let onRender = () => undefined;
+            let onExit = () => undefined;
+            const host = new UiAppHost({
+                registry,
+                closeOnInterrupt: true,
+                theme: pinnedTheme(),
+                surface: {
+                    size: () => size,
+                    requestRender: () => onRender(),
+                    exit: () => onExit(),
+                    present: lines => {
+                        if (lines === null)
+                            closed = true;
+                        else
+                            frame = lines;
+                    },
+                },
+            });
+            host.open(registration.id);
+            const surface = {
+                id: registration.id,
+                render: (width, height) => {
+                    size = { width, height };
+                    host.render();
+                    return frame.length === height ? frame : [...frame.slice(0, height), ...Array(Math.max(0, height - frame.length)).fill("")];
+                },
+                handleInput: data => host.handleInput(data).consumed,
+                handleMouse: event => host.handleMouse(event).consumed,
+                isClosed: () => closed || !host.isPresenting,
+                close: () => host.close(),
+                onRenderRequested: listener => { onRender = listener; },
+                onExitRequested: listener => { onExit = listener; },
+            };
+            return surface;
+        },
+    };
+}
+/** Maps A1 UI tokens onto the pinned Pi theme so owned screens match the shell. */
+function pinnedTheme() {
+    return {
+        fg: (token, text) => piTheme().fg(token, text),
+        bold: (text) => piTheme().bold(text),
+        // Unpainted, so a list reads against the terminal the reader actually has
+        // rather than against the background the configured theme was built for.
+        plain: (text) => text,
+        // Quiet, and quieter again: the terminal's own faint attribute over the
+        // dimmest colour the theme has.
+        disabled: (text) => faint(piTheme().fg("dim", text)),
+        highlight: (text) => `${text}`,
+        panel: (text) => `${text}`,
+    };
+}

package/dist/src/features/launch/initialize-profile.js

@@ -38,7 +38,7 @@ async function ensureSafeDirectoryChain(root) {
         current = parent;
     }
     for (const path of missing.reverse())
-        await mkdir(path, { mode: 0o700 });
+        await createOwnedDirectory(path, "profile path");
 }
 async function ensureOwnedDirectory(path) {
     const metadata = await lstat(path).catch(error => {
@@ -51,7 +51,28 @@ async function ensureOwnedDirectory(path) {
             throw new Error(`profile resource path is not an owned directory: ${path}`);
         return;
     }
-    await mkdir(path, { mode: 0o700 });
+    await createOwnedDirectory(path, "profile resource path");
+}
+/**
+ * Creates a directory, treating "it already exists" as another launch having won
+ * the race rather than as a failure — but still refusing what it finds if that is
+ * not an owned directory.
+ */
+async function createOwnedDirectory(path, subject) {
+    try {
+        await mkdir(path, { mode: 0o700 });
+        return;
+    }
+    catch (error) {
+        if (!isAlreadyThere(error))
+            throw error;
+    }
+    const metadata = await lstat(path);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink())
+        throw new Error(`${subject} is not an owned directory: ${path}`);
+}
+function isAlreadyThere(error) {
+    return typeof error === "object" && error !== null && error.code === "EEXIST";
 }
 function isMissing(error) {
     return error instanceof Error && "code" in error && error.code === "ENOENT";

package/dist/src/features/launch/profiles.d.ts

@@ -7,6 +7,6 @@ export interface LaunchProfileContract {
     readonly productSurface: "agent" | "vanilla-baseline" | "isolated-profile";
     readonly configurationRootPolicy: ConfigurationRootPolicy;
     readonly projectTrust: ProjectTrustPolicy;
-    readonly terminalCapability: "owned-ui" | "transparent";
+    readonly terminalCapability: "owned-ui";
 }
 export declare function launchProfileContract(id: LaunchProfileId): LaunchProfileContract;

package/dist/src/features/launch/profiles.js

@@ -11,14 +11,14 @@ const contracts = Object.freeze({
         productSurface: "vanilla-baseline",
         configurationRootPolicy: "pi-default",
         projectTrust: "pi-default",
-        terminalCapability: "transparent",
+        terminalCapability: "owned-ui",
     }),
     sandbox: Object.freeze({
         id: "sandbox",
         productSurface: "isolated-profile",
         configurationRootPolicy: "sandbox-profile",
         projectTrust: "ignore",
-        terminalCapability: "transparent",
+        terminalCapability: "owned-ui",
     }),
 });
 export function launchProfileContract(id) {

package/dist/src/features/launch/runtime-selection.d.ts

@@ -1,14 +1,19 @@
 import { type LaunchProfileId } from "../../foundation/lifecycle/index.js";
-export type TransparentInteractiveProfileId = Exclude<LaunchProfileId, "a1">;
-export type InteractiveRuntimeSelection = {
+/**
+ * Every interactive command is the same composition. What differs is the
+ * configuration root each one reads and whether A1's own screens are reachable:
+ * bare `a1` is the product, while `a1 pi` and `a1 sandbox` present pinned Pi's
+ * interface and nothing of A1's own, against Pi's own profile and against an
+ * isolated one.
+ */
+export type OwnedUiProfileId = LaunchProfileId;
+export interface InteractiveRuntimeSelection {
     readonly kind: "owned-ui";
-} | {
-    readonly kind: "transparent";
-    readonly profileId: TransparentInteractiveProfileId;
-};
+    readonly profileId: OwnedUiProfileId;
+    readonly ownedSurfaces: "on" | "off";
+}
 export interface InteractiveRuntimeRunners {
-    readonly ownedUi: () => Promise<number>;
-    readonly transparent: (profileId: TransparentInteractiveProfileId) => Promise<number>;
+    readonly ownedUi: (profileId: OwnedUiProfileId, ownedSurfaces: "on" | "off") => Promise<number>;
 }
 export declare function selectInteractiveRuntime(profileId: string): InteractiveRuntimeSelection;
 export declare function runSelectedInteractiveRuntime(profileId: string, runners: InteractiveRuntimeRunners): Promise<number>;

package/dist/src/features/launch/runtime-selection.js

@@ -1,13 +1,13 @@
 import { assertLaunchProfileId } from "../../foundation/lifecycle/index.js";
 export function selectInteractiveRuntime(profileId) {
     assertLaunchProfileId(profileId);
-    return profileId === "a1"
-        ? Object.freeze({ kind: "owned-ui" })
-        : Object.freeze({ kind: "transparent", profileId });
+    return Object.freeze({
+        kind: "owned-ui",
+        profileId,
+        ownedSurfaces: profileId === "a1" ? "on" : "off",
+    });
 }
 export async function runSelectedInteractiveRuntime(profileId, runners) {
     const selection = selectInteractiveRuntime(profileId);
-    return selection.kind === "owned-ui"
-        ? await runners.ownedUi()
-        : await runners.transparent(selection.profileId);
+    return await runners.ownedUi(selection.profileId, selection.ownedSurfaces);
 }

package/dist/src/features/owned-ui/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./customization.js";
 export * from "./diagnostics.js";
 export * from "./run.js";
+export * from "./settings-app.js";

package/dist/src/features/owned-ui/index.js

@@ -1,3 +1,4 @@
 export * from "./customization.js";
 export * from "./diagnostics.js";
 export * from "./run.js";
+export * from "./settings-app.js";

package/dist/src/features/owned-ui/run.d.ts

@@ -1,5 +1,11 @@
 import type { OwnedUiApplicationPort } from "../../foundation/presentation-contracts/index.js";
+import type { OwnedUiSettingsSession } from "../../foundation/owned-ui-settings/index.js";
 export interface OwnedUiRunOptions {
     readonly application: OwnedUiApplicationPort;
+    /**
+     * Resolved once before the application starts, so every surface reads the same
+     * values for the life of the session. Omitted when the caller runs without settings.
+     */
+    readonly settings?: OwnedUiSettingsSession;
 }
 export declare function runOwnedUi(options: OwnedUiRunOptions): Promise<number>;

package/dist/src/features/owned-ui/run.js

@@ -1,6 +1,8 @@
 export async function runOwnedUi(options) {
-    const { application } = options;
+    const { application, settings } = options;
     try {
+        if (settings)
+            await settings.load();
         application.start();
         await application.flush();
         if (!application.disposed)

package/dist/src/features/owned-ui/settings-app.d.ts

@@ -0,0 +1,22 @@
+import type { AppHostServices, UiApp } from "../../foundation/ui-apps/index.js";
+import { ShortcutRegistry, type PaneInputResult, type PaneMouseEvent, type PaneRect } from "../../foundation/ui-components/index.js";
+import type { OwnedUiSettingsSession } from "../../foundation/owned-ui-settings/index.js";
+export declare const SETTINGS_APP_ID = "settings";
+export declare const SETTINGS_ROUTE = "settings";
+type Action = "move-up" | "move-down" | "block-up" | "block-down" | "first" | "last" | "page-up" | "page-down" | "previous-value" | "next-value" | "activate" | "open-filter" | "close" | "part-previous" | "part-next" | "part-change";
+export declare const SETTINGS_SHORTCUTS: ShortcutRegistry<Action>;
+/**
+ * The settings screen. Rows, sticky headers, scrolling, and the keymap come from
+ * the shared component layer; what belongs to settings is which sections exist,
+ * how a value is shown, and where an accepted change is routed.
+ */
+export declare class SettingsApp implements UiApp {
+    #private;
+    readonly id = "settings";
+    constructor(session: OwnedUiSettingsSession);
+    onActivate(host: AppHostServices): void;
+    render(rect: PaneRect, host: AppHostServices): readonly string[];
+    onInput(data: string, host: AppHostServices): PaneInputResult;
+    onMouse(event: PaneMouseEvent, _host: AppHostServices): PaneInputResult;
+}
+export {};