restty 0.1.35 → 0.2.0

package/dist/surface/{pane-app-manager.d.ts → panes/managed-pane-types.d.ts}

@@ -1,17 +1,16 @@
-import { type ResttyPaneStyleOptions, type ResttyPaneStylesOptions, type ResttyPaneContextMenuOptions, type ResttyPaneManager, type ResttyPaneShortcutsOptions, type ResttyPaneWithApp } from "./panes-types";
-import type { ResttyAppOptions, ResttyAppSession } from "../runtime/types";
-import { type ResttyPaneSearchUiCloseOptions, type ResttyPaneSearchUiOpenOptions, type ResttyPaneSearchUiOptions, type ResttyPaneSearchUiStyleOptions } from "./pane-search-ui";
+import type { ResttyPaneContextMenuOptions, ResttyPaneManager, ResttyPaneShortcutsOptions, ResttyPaneStyleOptions, ResttyPaneStylesOptions, ResttyPaneWithManagedRuntime } from "./types";
+import type { ResttyRuntimeServicesConfig, ResttyTerminalConfig } from "../../runtime/core/config";
+import type { ResttyRuntimeSession } from "../../runtime/core/resources";
+import type { ResttyPaneSearchUiCloseOptions, ResttyPaneSearchUiOpenOptions, ResttyPaneSearchUiOptions, ResttyPaneSearchUiStyleOptions } from "../search-ui";
 /**
- * A pane created by the app pane manager, extending the base pane
- * with DOM elements needed by the terminal app.
+ * A pane created by the managed-pane manager, extending the base pane
+ * with DOM elements needed by the terminal runtime.
  */
-export type ResttyManagedAppPane = ResttyPaneWithApp & {
+export type ResttyManagedPane = ResttyPaneWithManagedRuntime & {
     /** The canvas element used for terminal rendering. */
     canvas: HTMLCanvasElement;
     /** Hidden textarea for IME composition input. */
     imeInput: HTMLTextAreaElement;
-    /** Pre element for terminal debug / accessibility output. */
-    termDebugEl: HTMLPreElement;
 };
 /**
  * Default CSS class names for pane DOM elements.
@@ -20,7 +19,6 @@ export type ResttyPaneDomDefaults = {
     paneClassName?: string;
     canvasClassName?: string;
     imeInputClassName?: string;
-    termDebugClassName?: string;
 };
 /** Style options for managed panes (alias for ResttyPaneStyleOptions). */
 export type ResttyManagedPaneStyleOptions = ResttyPaneStyleOptions;
@@ -30,9 +28,18 @@ export type ResttyManagedPaneStylesOptions = ResttyPaneStylesOptions;
 export type ResttyManagedPaneSearchUiStyleOptions = ResttyPaneSearchUiStyleOptions;
 /** Built-in pane search UI configuration. */
 export type ResttyManagedPaneSearchUiOptions = ResttyPaneSearchUiOptions;
-/** App options minus the DOM/session fields that the pane manager provides. */
-export type ResttyPaneAppOptionsInput = Omit<ResttyAppOptions, "canvas" | "imeInput" | "session">;
-export type ResttyAppPaneManager = ResttyPaneManager<ResttyManagedAppPane> & {
+/** Pane context passed to per-pane config factories. */
+export type ResttyPaneRuntimeContext = {
+    id: number;
+    sourcePane: ResttyManagedPane | null;
+    canvas: HTMLCanvasElement;
+    imeInput: HTMLTextAreaElement;
+};
+/** Static or factory terminal behavior config for one pane. */
+export type ResttyTerminalConfigInput = ResttyTerminalConfig | ((context: ResttyPaneRuntimeContext) => ResttyTerminalConfig);
+/** Static or factory runtime services config for one pane. */
+export type ResttyRuntimeServicesConfigInput = ResttyRuntimeServicesConfig | ((context: ResttyPaneRuntimeContext) => ResttyRuntimeServicesConfig);
+export type ResttyManagedPaneManager = ResttyPaneManager<ResttyManagedPane> & {
     openPaneSearch: (id: number, options?: ResttyPaneSearchUiOpenOptions) => void;
     closePaneSearch: (id: number, options?: ResttyPaneSearchUiCloseOptions) => void;
     togglePaneSearch: (id: number, options?: ResttyPaneSearchUiOpenOptions & ResttyPaneSearchUiCloseOptions) => void;
@@ -47,32 +54,28 @@ export type ResttyDefaultPaneContextMenuOptions = {
     /** Whether the default context menu is enabled (default true). */
     enabled?: boolean;
     /** Guard predicate; return false to suppress the menu for a given event. */
-    canOpen?: (event: MouseEvent, pane: ResttyManagedAppPane) => boolean;
+    canOpen?: (event: MouseEvent, pane: ResttyPaneWithRuntime) => boolean;
     /** Override the modifier key label shown in shortcut hints. */
     modKeyLabel?: string;
     /** Provide the PTY WebSocket URL for the connect/disconnect menu item. */
     getPtyUrl?: () => string | null | undefined;
 };
 /**
- * Options for creating an app-level pane manager that wires up DOM
- * elements, the terminal app, and the shared session automatically.
+ * Options for creating a managed-pane manager that wires up DOM
+ * elements, the terminal runtime, and the shared session automatically.
  */
-export type CreateResttyAppPaneManagerOptions = {
+export type CreateResttyManagedPaneManagerOptions = {
     /** Root element that will contain all pane DOM trees. */
     root: HTMLElement;
     /** Shared session for WASM/WebGPU resources (defaults to the global session). */
-    session?: ResttyAppSession;
-    /** Per-pane app options, static object or factory receiving pane context. */
-    appOptions?: ResttyPaneAppOptionsInput | ((context: {
-        id: number;
-        sourcePane: ResttyManagedAppPane | null;
-        canvas: HTMLCanvasElement;
-        imeInput: HTMLTextAreaElement;
-        termDebugEl: HTMLPreElement;
-    }) => ResttyPaneAppOptionsInput);
+    session?: ResttyRuntimeSession;
+    /** Per-pane terminal behavior config, static object or factory. */
+    terminal?: ResttyTerminalConfigInput;
+    /** Per-pane runtime services config, static object or factory. */
+    services?: ResttyRuntimeServicesConfigInput;
     /** Override default CSS class names for pane DOM elements. */
     paneDom?: ResttyPaneDomDefaults;
-    /** Automatically call app.init() after pane creation (default true). */
+    /** Automatically call runtime.lifecycle.init() after pane creation (default true). */
     autoInit?: boolean;
     /** Minimum pane size in pixels during split-resize (default 96). */
     minPaneSize?: number;
@@ -83,22 +86,17 @@ export type CreateResttyAppPaneManagerOptions = {
     /** Enable or configure keyboard shortcuts for splitting. */
     shortcuts?: boolean | ResttyPaneShortcutsOptions;
     /** Custom context menu implementation (overrides defaultContextMenu). */
-    contextMenu?: ResttyPaneContextMenuOptions<ResttyManagedAppPane> | null;
+    contextMenu?: ResttyPaneContextMenuOptions<ResttyManagedPane> | null;
     /** Enable or configure the built-in default context menu. */
     defaultContextMenu?: boolean | ResttyDefaultPaneContextMenuOptions;
     /** Called after a new pane is created. */
-    onPaneCreated?: (pane: ResttyManagedAppPane) => void;
+    onPaneCreated?: (pane: ResttyManagedPane) => void;
     /** Called after a pane is closed. */
-    onPaneClosed?: (pane: ResttyManagedAppPane) => void;
+    onPaneClosed?: (pane: ResttyManagedPane) => void;
     /** Called after a pane is split. */
-    onPaneSplit?: (sourcePane: ResttyManagedAppPane, createdPane: ResttyManagedAppPane, direction: "vertical" | "horizontal") => void;
+    onPaneSplit?: (sourcePane: ResttyManagedPane, createdPane: ResttyManagedPane, direction: "vertical" | "horizontal") => void;
     /** Called when the active pane changes (or becomes null). */
-    onActivePaneChange?: (pane: ResttyManagedAppPane | null) => void;
+    onActivePaneChange?: (pane: ResttyManagedPane | null) => void;
     /** Called when the layout changes (splits, closes, resizes). */
     onLayoutChanged?: () => void;
 };
-/**
- * Create an app-aware pane manager that automatically constructs
- * canvas, IME input, and terminal app instances for each pane.
- */
-export declare function createResttyAppPaneManager(options: CreateResttyAppPaneManagerOptions): ResttyAppPaneManager;

package/dist/surface/panes/manager.d.ts

@@ -1,2 +1,2 @@
-import type { CreateResttyPaneManagerOptions, ResttyPaneDefinition, ResttyPaneManager } from "../panes-types";
+import type { CreateResttyPaneManagerOptions, ResttyPaneDefinition, ResttyPaneManager } from "./types";
 export declare function createResttyPaneManager<TPane extends ResttyPaneDefinition>(options: CreateResttyPaneManagerOptions<TPane>): ResttyPaneManager<TPane>;

package/dist/surface/panes/pane-interactions.d.ts

@@ -1,5 +1,5 @@
-import type { PaneContextMenuController } from "../panes-context-menu";
-import type { ResttyPaneContextMenuOptions, ResttyPaneDefinition, ResttyPaneManager } from "../panes-types";
+import type { PaneContextMenuController } from "./context-menu";
+import type { ResttyPaneContextMenuOptions, ResttyPaneDefinition, ResttyPaneManager } from "./types";
 export declare function createPaneInteractions<TPane extends ResttyPaneDefinition>(options: {
     contextMenu: ResttyPaneContextMenuOptions<TPane> | null | undefined;
     contextMenuController: PaneContextMenuController<TPane> | null;

package/dist/surface/{panes-styles.d.ts → panes/styles.d.ts}

@@ -1,4 +1,4 @@
-import type { ResttyPaneStyleOptions } from "./panes-types";
+import type { ResttyPaneStyleOptions } from "./types";
 /** Default style options for pane layout and appearance. */
 export declare const DEFAULT_RESTTY_PANE_STYLE_OPTIONS: Required<ResttyPaneStyleOptions>;
 /** Validates and normalizes pane style options, clamping numeric values to safe ranges and applying defaults. */

package/dist/surface/{panes-types.d.ts → panes/types.d.ts}

@@ -1,4 +1,4 @@
-import type { ResttyApp } from "../runtime/types";
+import type { ResttyRuntime, ResttyRuntimeInteractionApi, ResttyRuntimeIoApi, ResttyRuntimeRenderApi, ResttyRuntimeSearchApi, ResttyRuntimeTerminalApi } from "../runtime/core/api";
 /**
  * Direction for splitting a pane.
  * - vertical: split left/right
@@ -65,6 +65,8 @@ export type ResttyPaneStyleOptions = {
     activePaneOpacity?: number;
     /** Duration in ms for opacity transitions between active/inactive states. */
     opacityTransitionMs?: number;
+    /** CSS color for the visible split divider. */
+    dividerColor?: string;
     /** Divider/gutter thickness in CSS pixels. */
     dividerThicknessPx?: number;
 };
@@ -150,20 +152,59 @@ export type ResttyPaneManager<TPane extends ResttyPaneDefinition> = {
     destroy: () => void;
 };
 /**
- * Pane definition extended with a ResttyApp instance and pause control.
+ * Pane definition extended with a ResttyRuntime instance and pause control.
  */
-export type ResttyPaneWithApp = ResttyPaneDefinition & {
-    /** The terminal app running inside this pane. */
-    app: ResttyApp;
+export type ResttyPaneWithRuntime = ResttyPaneDefinition & {
+    /** The terminal runtime running inside this pane. */
+    runtime: ResttyRuntime;
     /** Whether the pane's renderer is currently paused. */
     paused?: boolean;
     /** Pause or resume this pane's renderer. */
     setPaused?: (value: boolean) => void;
 };
+export type ResttyPaneWithRuntimeActions = ResttyPaneWithRuntime & {
+    setRenderer: ResttyRuntimeTerminalApi["setRenderer"];
+    setPaused: ResttyRuntimeTerminalApi["setPaused"];
+    setFontSize: ResttyRuntimeTerminalApi["setFontSize"];
+    setLigatures: ResttyRuntimeTerminalApi["setLigatures"];
+    setFontHinting: ResttyRuntimeTerminalApi["setFontHinting"];
+    setFontHintTarget: ResttyRuntimeTerminalApi["setFontHintTarget"];
+    setFonts: ResttyRuntimeTerminalApi["setFonts"];
+    applyTheme: ResttyRuntimeTerminalApi["applyTheme"];
+    resetTheme: ResttyRuntimeTerminalApi["resetTheme"];
+    sendInput: ResttyRuntimeIoApi["sendInput"];
+    sendKeyInput: ResttyRuntimeIoApi["sendKeyInput"];
+    copySelectionToClipboard: () => Promise<boolean>;
+    pasteFromClipboard: () => Promise<boolean>;
+    clearScreen: () => void;
+    connectPty: (url?: string) => void;
+    disconnectPty: () => void;
+    isPtyConnected: () => boolean;
+    togglePause: () => void;
+    setMouseMode: ResttyRuntimeInteractionApi["setMouseMode"];
+    getMouseStatus: ResttyRuntimeInteractionApi["getMouseStatus"];
+    selectWordAtClientPoint: ResttyRuntimeInteractionApi["selectWordAtClientPoint"];
+    setSearchQuery: ResttyRuntimeSearchApi["setQuery"];
+    clearSearch: ResttyRuntimeSearchApi["clear"];
+    searchNext: ResttyRuntimeSearchApi["next"];
+    searchPrevious: ResttyRuntimeSearchApi["previous"];
+    getSearchState: ResttyRuntimeSearchApi["getState"];
+    resize: ResttyRuntimeInteractionApi["resize"];
+    focus: ResttyRuntimeInteractionApi["focus"];
+    blur: ResttyRuntimeInteractionApi["blur"];
+    updateSize: ResttyRuntimeInteractionApi["updateSize"];
+    getBackend: ResttyRuntimeRenderApi["getBackend"];
+    setShaderStages: ResttyRuntimeRenderApi["setShaderStages"];
+    getShaderStages: ResttyRuntimeRenderApi["getShaderStages"];
+};
+export type ResttyPaneWithManagedRuntime = ResttyPaneWithRuntimeActions & {
+    initRuntime: () => Promise<void>;
+    destroyRuntime: () => void;
+};
 /**
- * Options for building the default set of context menu items for a pane with an app.
+ * Options for building the default set of context menu items for a pane with a runtime.
  */
-export type CreateDefaultResttyPaneContextMenuItemsOptions<TPane extends ResttyPaneWithApp> = {
+export type CreateDefaultResttyPaneContextMenuItemsOptions<TPane extends ResttyPaneWithRuntimeActions> = {
     /** The pane the context menu was opened on. */
     pane: TPane;
     /** Subset of the pane manager API needed for split/close actions. */

package/dist/surface/panes/window-events.d.ts

@@ -1,4 +1,4 @@
-import type { ResttyPaneShortcutsOptions, ResttyPaneSplitDirection } from "../panes-types";
+import type { ResttyPaneShortcutsOptions, ResttyPaneSplitDirection } from "./types";
 export declare function attachPaneManagerWindowEvents(options: {
     contextMenuController?: {
         isOpen: () => boolean;

package/dist/surface/{restty-plugin-types.d.ts → plugins/context.types.d.ts}

@@ -1,87 +1,8 @@
-import type { ResttyPaneSplitDirection } from "./panes-types";
-import type { ResttyShaderStage } from "../runtime/types";
-import type { ResttyPaneHandle } from "./restty-pane-handle";
-import type { Restty } from "./restty";
-/** Current Restty plugin API version. */
-export declare const RESTTY_PLUGIN_API_VERSION = 1;
-/** Plugin API version requirements. */
-export type ResttyPluginApiRange = {
-    min: number;
-    max?: number;
-};
-/** Optional compatibility requirements declared by plugins. */
-export type ResttyPluginRequires = {
-    pluginApi?: number | ResttyPluginApiRange;
-};
-/** Diagnostics snapshot for a plugin. */
-export type ResttyPluginInfo = {
-    id: string;
-    version: string | null;
-    apiVersion: number | null;
-    requires: ResttyPluginRequires | null;
-    active: boolean;
-    activatedAt: number | null;
-    lastError: string | null;
-    listeners: number;
-    inputInterceptors: number;
-    outputInterceptors: number;
-    lifecycleHooks: number;
-    renderHooks: number;
-    renderStages: number;
-};
-/** Declarative plugin manifest entry for registry-based loading. */
-export type ResttyPluginManifestEntry = {
-    id: string;
-    enabled?: boolean;
-    options?: unknown;
-};
-/** Provider entry for plugin registry lookups. */
-export type ResttyPluginRegistryEntry = ResttyPlugin | (() => ResttyPlugin | Promise<ResttyPlugin>);
-/** Registry shape accepted by loadPlugins. */
-export type ResttyPluginRegistry = ReadonlyMap<string, ResttyPluginRegistryEntry> | Record<string, ResttyPluginRegistryEntry>;
-/** Status for manifest-driven plugin load attempts. */
-export type ResttyPluginLoadStatus = "loaded" | "skipped" | "missing" | "failed";
-/** Result row returned by loadPlugins. */
-export type ResttyPluginLoadResult = {
-    id: string;
-    status: ResttyPluginLoadStatus;
-    error: string | null;
-};
-/** Event payloads emitted by the Restty plugin host. */
-export type ResttyPluginEvents = {
-    "plugin:activated": {
-        pluginId: string;
-    };
-    "plugin:deactivated": {
-        pluginId: string;
-    };
-    "pane:created": {
-        paneId: number;
-    };
-    "pane:closed": {
-        paneId: number;
-    };
-    "pane:split": {
-        sourcePaneId: number;
-        createdPaneId: number;
-        direction: ResttyPaneSplitDirection;
-    };
-    "pane:active-changed": {
-        paneId: number | null;
-    };
-    "layout:changed": {};
-    "pane:resized": {
-        paneId: number;
-        cols: number;
-        rows: number;
-    };
-    "pane:focused": {
-        paneId: number;
-    };
-    "pane:blurred": {
-        paneId: number;
-    };
-};
+import type { ResttyShaderStage } from "../../runtime/core/models";
+import type { ResttyManagedPaneSearchUiStyleOptions, ResttyManagedPaneStyleOptions } from "../panes/managed-pane-types";
+import type { ResttyPaneSplitDirection } from "../panes/types";
+import type { ResttyPaneApi, ResttyPaneHandle } from "../restty/pane-handle";
+import type { ResttyPluginEvents, ResttyPluginRequires } from "./types";
 /** A disposable resource returned by plugin APIs. */
 export type ResttyPluginDisposable = {
     dispose: () => void;
@@ -139,14 +60,37 @@ export type ResttyRenderStageHandle = {
     setEnabled: (value: boolean) => void;
     dispose: () => void;
 };
-/** Context object provided to each plugin on activation. */
-export type ResttyPluginContext = {
-    restty: Restty;
-    options: unknown;
+export type ResttyPluginHostApi = Omit<ResttyPaneApi, "id"> & {
     panes: () => ResttyPaneHandle[];
     pane: (id: number) => ResttyPaneHandle | null;
     activePane: () => ResttyPaneHandle | null;
     focusedPane: () => ResttyPaneHandle | null;
+    forEachPane: (visitor: (pane: ResttyPaneHandle) => void) => void;
+    createInitialPane: (options?: {
+        focus?: boolean;
+    }) => ResttyPaneHandle;
+    splitActivePane: (direction: ResttyPaneSplitDirection) => ResttyPaneHandle | null;
+    splitPane: (id: number, direction: ResttyPaneSplitDirection) => ResttyPaneHandle | null;
+    closePane: (id: number) => boolean;
+    getPaneStyleOptions: () => Readonly<Required<ResttyManagedPaneStyleOptions>>;
+    setPaneStyleOptions: (options: ResttyManagedPaneStyleOptions) => void;
+    getSearchUiStyleOptions: () => Readonly<Required<ResttyManagedPaneSearchUiStyleOptions>>;
+    setSearchUiStyleOptions: (options: ResttyManagedPaneSearchUiStyleOptions) => void;
+    setActivePane: (id: number, options?: {
+        focus?: boolean;
+    }) => void;
+    markPaneFocused: (id: number, options?: {
+        focus?: boolean;
+    }) => void;
+    requestLayoutSync: () => void;
+    hideContextMenu: () => void;
+    addShaderStage: (stage: ResttyShaderStage) => ResttyRenderStageHandle;
+    removeShaderStage: (id: string) => boolean;
+};
+/** Context object provided to each plugin on activation. */
+export type ResttyPluginContext = {
+    restty: ResttyPluginHostApi;
+    options: unknown;
     on: <E extends keyof ResttyPluginEvents>(event: E, listener: (payload: ResttyPluginEvents[E]) => void) => ResttyPluginDisposable;
     addInputInterceptor: (interceptor: ResttyInputInterceptor, options?: ResttyInterceptorOptions) => ResttyPluginDisposable;
     addOutputInterceptor: (interceptor: ResttyOutputInterceptor, options?: ResttyInterceptorOptions) => ResttyPluginDisposable;

package/dist/surface/{restty/plugin-dispatcher.d.ts → plugins/dispatcher.d.ts}

@@ -1,16 +1,7 @@
-import { type ResttyLifecycleHookPayload, type ResttyPluginContext, type ResttyPluginEvents, type ResttyRenderHookPayload, type ResttyRenderStageHandle } from "../restty-plugin-types";
-import { type ResttyPluginRuntime } from "../restty-plugin-runtime";
-import type { ResttyShaderStage } from "../../runtime/types";
-import type { ResttyPaneHandle } from "../restty-pane-handle";
-import type { Restty } from "../restty";
-export type ResttyPluginHostDeps = {
-    restty: Restty;
-    panes: () => ResttyPaneHandle[];
-    pane: (id: number) => ResttyPaneHandle | null;
-    activePane: () => ResttyPaneHandle | null;
-    focusedPane: () => ResttyPaneHandle | null;
-    addRenderStage: (stage: ResttyShaderStage, ownerPluginId: string | null) => ResttyRenderStageHandle;
-};
+import { type ResttyLifecycleHookPayload, type ResttyPluginContext, type ResttyRenderHookPayload } from "./context.types";
+import type { ResttyPluginEvents } from "./types";
+import { type ResttyPluginRuntime } from "./runtime";
+import type { ResttyPluginHostDeps } from "./dispatcher.types";
 export declare class ResttyPluginDispatcher {
     private readonly deps;
     private readonly pluginListeners;

package/dist/surface/plugins/dispatcher.types.d.ts

@@ -0,0 +1,6 @@
+import type { ResttyShaderStage } from "../../runtime/core/models";
+import type { ResttyPluginHostApi, ResttyRenderStageHandle } from "./context.types";
+export type ResttyPluginHostDeps = {
+    restty: ResttyPluginHostApi;
+    addRenderStage: (stage: ResttyShaderStage, ownerPluginId: string | null) => ResttyRenderStageHandle;
+};

package/dist/surface/{restty/plugin-ops.d.ts → plugins/host.d.ts}

@@ -1,6 +1,7 @@
-import { type ResttyLifecycleHookPayload, type ResttyPlugin, type ResttyPluginEvents, type ResttyPluginInfo, type ResttyPluginLoadResult, type ResttyPluginManifestEntry, type ResttyPluginRegistry, type ResttyRenderHookPayload } from "../restty-plugin-types";
-import { type ResttyPluginHostDeps } from "./plugin-dispatcher";
-export declare class ResttyPluginOps {
+import { type ResttyPluginEvents, type ResttyPluginInfo, type ResttyPluginLoadResult, type ResttyPluginManifestEntry, type ResttyPluginRegistry } from "./types";
+import type { ResttyLifecycleHookPayload, ResttyPlugin, ResttyRenderHookPayload } from "./context.types";
+import type { ResttyPluginHostDeps } from "./dispatcher.types";
+export declare class ResttyPluginHost {
     private readonly pluginRuntimes;
     private readonly pluginDiagnostics;
     private readonly dispatcher;

package/dist/surface/plugins/runtime.d.ts

@@ -0,0 +1,18 @@
+import type { ResttyPluginEvents, ResttyPluginInfo } from "./types";
+import type { PluginDiagnosticMap, PluginListenersMap, PluginRuntimeMap, RegisterPluginInterceptorOptions, ResttyInterceptorSeq, ResttyPluginDiagnostic, ResttyPluginRuntime, ResttyPluginRuntimeDisposerKind, ResttyRegisteredInterceptor } from "./runtime.types";
+export declare function registerPluginInterceptor<T extends (payload: unknown) => unknown>(bucket: Array<ResttyRegisteredInterceptor<T>>, pluginId: string, interceptor: T, options: RegisterPluginInterceptorOptions, seq: ResttyInterceptorSeq): {
+    dispose: () => void;
+    nextId: number;
+    nextOrder: number;
+};
+export declare function applyPluginInterceptors<TPayload extends {
+    text: string;
+}>(bucket: Array<ResttyRegisteredInterceptor<(payload: TPayload) => string | null | void>>, kind: "input" | "output", payload: TPayload): string | null;
+export declare function runPluginHooks<TPayload>(bucket: Array<ResttyRegisteredInterceptor<(payload: TPayload) => void>>, kind: "lifecycle" | "render", payload: TPayload): void;
+export declare function attachRuntimeDisposer(runtime: ResttyPluginRuntime, kind: ResttyPluginRuntimeDisposerKind, dispose: () => void): () => void;
+export declare function teardownPluginRuntime(runtime: ResttyPluginRuntime): void;
+export declare function setPluginLoadError(pluginDiagnostics: PluginDiagnosticMap, pluginId: string, message: string): void;
+export declare function patchPluginDiagnostic(pluginDiagnostics: PluginDiagnosticMap, pluginId: string, patch: Partial<Pick<ResttyPluginDiagnostic, "active" | "activatedAt" | "lastError">>): void;
+export declare function buildPluginInfo(pluginId: string, pluginDiagnostics: PluginDiagnosticMap, pluginRuntimes: PluginRuntimeMap): ResttyPluginInfo | null;
+export declare function onPluginEvent<E extends keyof ResttyPluginEvents>(pluginListeners: PluginListenersMap, event: E, listener: (payload: ResttyPluginEvents[E]) => void): () => void;
+export declare function emitPluginEvent<E extends keyof ResttyPluginEvents>(pluginListeners: PluginListenersMap, event: E, payload: ResttyPluginEvents[E]): void;

package/dist/surface/plugins/runtime.types.d.ts

@@ -0,0 +1,47 @@
+import type { ResttyShaderStage } from "../../runtime/core/models";
+import type { ResttyInterceptorOptions, ResttyPlugin } from "./context.types";
+import type { ResttyPluginEvents, ResttyPluginInfo, ResttyPluginRequires } from "./types";
+export type ResttyPluginRuntimeDisposerKind = "event" | "input-interceptor" | "output-interceptor" | "lifecycle-hook" | "render-hook" | "render-stage";
+export type ResttyPluginRuntimeDisposer = {
+    kind: ResttyPluginRuntimeDisposerKind;
+    active: boolean;
+    dispose: () => void;
+};
+export type ResttyPluginRuntime = {
+    plugin: ResttyPlugin;
+    cleanup: (() => void) | null;
+    activatedAt: number;
+    options: unknown;
+    disposers: Array<ResttyPluginRuntimeDisposer>;
+};
+export type ResttyPluginDiagnostic = {
+    id: string;
+    version: string | null;
+    apiVersion: number | null;
+    requires: ResttyPluginRequires | null;
+    active: boolean;
+    activatedAt: number | null;
+    lastError: string | null;
+};
+export type ResttyRegisteredInterceptor<T extends (payload: unknown) => unknown> = {
+    id: number;
+    pluginId: string;
+    priority: number;
+    order: number;
+    interceptor: T;
+};
+export type ResttyManagedShaderStage = {
+    id: string;
+    stage: ResttyShaderStage;
+    order: number;
+    ownerPluginId: string | null;
+};
+export type ResttyInterceptorSeq = {
+    nextId: number;
+    nextOrder: number;
+};
+export type PluginListenersMap = Map<keyof ResttyPluginEvents, Set<(payload: unknown) => void>>;
+export type PluginDiagnosticMap = Map<string, ResttyPluginDiagnostic>;
+export type PluginRuntimeMap = Map<string, ResttyPluginRuntime>;
+export type BuildPluginInfoResult = ResttyPluginInfo | null;
+export type RegisterPluginInterceptorOptions = ResttyInterceptorOptions | undefined;

package/dist/surface/plugins/types.d.ts

@@ -0,0 +1,83 @@
+import type { ResttyPaneSplitDirection } from "../panes/types";
+import type { ResttyPlugin } from "./context.types";
+export type { ResttyPluginDisposable, ResttyPluginCleanup, ResttyInputInterceptorPayload, ResttyOutputInterceptorPayload, ResttyInputInterceptor, ResttyOutputInterceptor, ResttyLifecycleHookPayload, ResttyLifecycleHook, ResttyRenderHookPayload, ResttyRenderHook, ResttyInterceptorOptions, ResttyRenderStageHandle, ResttyPluginHostApi, ResttyPluginContext, ResttyPlugin, } from "./context.types";
+/** Current Restty plugin API version. */
+export declare const RESTTY_PLUGIN_API_VERSION = 1;
+/** Plugin API version requirements. */
+export type ResttyPluginApiRange = {
+    min: number;
+    max?: number;
+};
+/** Optional compatibility requirements declared by plugins. */
+export type ResttyPluginRequires = {
+    pluginApi?: number | ResttyPluginApiRange;
+};
+/** Diagnostics snapshot for a plugin. */
+export type ResttyPluginInfo = {
+    id: string;
+    version: string | null;
+    apiVersion: number | null;
+    requires: ResttyPluginRequires | null;
+    active: boolean;
+    activatedAt: number | null;
+    lastError: string | null;
+    listeners: number;
+    inputInterceptors: number;
+    outputInterceptors: number;
+    lifecycleHooks: number;
+    renderHooks: number;
+    renderStages: number;
+};
+/** Declarative plugin manifest entry for registry-based loading. */
+export type ResttyPluginManifestEntry = {
+    id: string;
+    enabled?: boolean;
+    options?: unknown;
+};
+/** Provider entry for plugin registry lookups. */
+export type ResttyPluginRegistryEntry = ResttyPlugin | (() => ResttyPlugin | Promise<ResttyPlugin>);
+/** Registry shape accepted by loadPlugins. */
+export type ResttyPluginRegistry = ReadonlyMap<string, ResttyPluginRegistryEntry> | Record<string, ResttyPluginRegistryEntry>;
+/** Status for manifest-driven plugin load attempts. */
+export type ResttyPluginLoadStatus = "loaded" | "skipped" | "missing" | "failed";
+/** Result row returned by loadPlugins. */
+export type ResttyPluginLoadResult = {
+    id: string;
+    status: ResttyPluginLoadStatus;
+    error: string | null;
+};
+/** Event payloads emitted by the Restty plugin host. */
+export type ResttyPluginEvents = {
+    "plugin:activated": {
+        pluginId: string;
+    };
+    "plugin:deactivated": {
+        pluginId: string;
+    };
+    "pane:created": {
+        paneId: number;
+    };
+    "pane:closed": {
+        paneId: number;
+    };
+    "pane:split": {
+        sourcePaneId: number;
+        createdPaneId: number;
+        direction: ResttyPaneSplitDirection;
+    };
+    "pane:active-changed": {
+        paneId: number | null;
+    };
+    "layout:changed": {};
+    "pane:resized": {
+        paneId: number;
+        cols: number;
+        rows: number;
+    };
+    "pane:focused": {
+        paneId: number;
+    };
+    "pane:blurred": {
+        paneId: number;
+    };
+};

package/dist/surface/restty/active-pane-api.d.ts

@@ -1,31 +1,41 @@
-import type { InputHandler, MouseMode } from "../../input";
-import type { GhosttyTheme } from "../../theme";
-import type { ResttyPaneHandle } from "../restty-pane-handle";
-import type { ResttyPaneSearchUiCloseOptions, ResttyPaneSearchUiOpenOptions } from "../pane-search-ui";
-import type { ResttyManagedPaneSearchUiStyleOptions } from "../pane-app-manager";
-export declare abstract class ResttyActivePaneApi {
+import type { ResttyPaneApi, ResttyPaneHandle } from "./pane-handle";
+export type ResttyActivePaneSurfaceApi = Omit<ResttyPaneApi, "id" | "resize" | "focus" | "blur">;
+export declare abstract class ResttyActivePaneApi implements ResttyActivePaneSurfaceApi {
     protected abstract requireActivePaneHandle(): ResttyPaneHandle;
-    isPtyConnected(): boolean;
-    setRenderer(value: "auto" | "webgpu" | "webgl2"): void;
-    setPaused(value: boolean): void;
+    isPtyConnected(): ReturnType<ResttyPaneApi["isPtyConnected"]>;
+    setRenderer(value: Parameters<ResttyPaneApi["setRenderer"]>[0]): void;
+    setPaused(value: Parameters<ResttyPaneApi["setPaused"]>[0]): void;
     togglePause(): void;
-    setFontSize(value: number): void;
-    applyTheme(theme: GhosttyTheme, sourceLabel?: string): void;
+    setFontSize(value: Parameters<ResttyPaneApi["setFontSize"]>[0]): void;
+    setLigatures(value: Parameters<ResttyPaneApi["setLigatures"]>[0]): void;
+    setFontHinting(value: Parameters<ResttyPaneApi["setFontHinting"]>[0]): void;
+    setFontHintTarget(value: Parameters<ResttyPaneApi["setFontHintTarget"]>[0]): void;
+    setFonts(fonts: Parameters<ResttyPaneApi["setFonts"]>[0]): ReturnType<ResttyPaneApi["setFonts"]>;
+    applyTheme(theme: Parameters<ResttyPaneApi["applyTheme"]>[0], sourceLabel?: Parameters<ResttyPaneApi["applyTheme"]>[1]): void;
     resetTheme(): void;
-    sendInput(text: string, source?: string): void;
-    sendKeyInput(text: string, source?: string): void;
+    sendInput(text: Parameters<ResttyPaneApi["sendInput"]>[0], source?: Parameters<ResttyPaneApi["sendInput"]>[1]): void;
+    sendKeyInput(text: Parameters<ResttyPaneApi["sendKeyInput"]>[0], source?: Parameters<ResttyPaneApi["sendKeyInput"]>[1]): void;
     clearScreen(): void;
-    setMouseMode(value: MouseMode): void;
-    getMouseStatus(): ReturnType<InputHandler["getMouseStatus"]>;
-    copySelectionToClipboard(): Promise<boolean>;
-    pasteFromClipboard(): Promise<boolean>;
-    openSearch(options?: ResttyPaneSearchUiOpenOptions): void;
-    closeSearch(options?: ResttyPaneSearchUiCloseOptions): void;
-    toggleSearch(options?: ResttyPaneSearchUiOpenOptions & ResttyPaneSearchUiCloseOptions): void;
+    connectPty(url?: Parameters<ResttyPaneApi["connectPty"]>[0]): void;
+    disconnectPty(): void;
+    setMouseMode(value: Parameters<ResttyPaneApi["setMouseMode"]>[0]): void;
+    getMouseStatus(): ReturnType<ResttyPaneApi["getMouseStatus"]>;
+    copySelectionToClipboard(): ReturnType<ResttyPaneApi["copySelectionToClipboard"]>;
+    pasteFromClipboard(): ReturnType<ResttyPaneApi["pasteFromClipboard"]>;
+    selectWordAtClientPoint(clientX: Parameters<ResttyPaneApi["selectWordAtClientPoint"]>[0], clientY: Parameters<ResttyPaneApi["selectWordAtClientPoint"]>[1]): ReturnType<ResttyPaneApi["selectWordAtClientPoint"]>;
+    setSearchQuery(query: Parameters<ResttyPaneApi["setSearchQuery"]>[0]): void;
+    clearSearch(): void;
+    searchNext(): void;
+    searchPrevious(): void;
+    getSearchState(): ReturnType<ResttyPaneApi["getSearchState"]>;
+    openSearch(options?: Parameters<ResttyPaneApi["openSearch"]>[0]): void;
+    closeSearch(options?: Parameters<ResttyPaneApi["closeSearch"]>[0]): void;
+    toggleSearch(options?: Parameters<ResttyPaneApi["toggleSearch"]>[0]): void;
     isSearchOpen(): boolean;
-    getSearchUiStyleOptions(): Readonly<Required<ResttyManagedPaneSearchUiStyleOptions>>;
-    setSearchUiStyleOptions(options: ResttyManagedPaneSearchUiStyleOptions): void;
-    dumpAtlasForCodepoint(cp: number): void;
+    getSearchUiStyleOptions(): ReturnType<ResttyPaneApi["getSearchUiStyleOptions"]>;
+    setSearchUiStyleOptions(options: Parameters<ResttyPaneApi["setSearchUiStyleOptions"]>[0]): void;
+    setShaderStages(stages: Parameters<ResttyPaneApi["setShaderStages"]>[0]): void;
+    getShaderStages(): ReturnType<ResttyPaneApi["getShaderStages"]>;
     updateSize(force?: boolean): void;
     getBackend(): string;
 }