restty 0.1.23 → 0.1.25

package/dist/runtime/overlay-scrollbar.d.ts

@@ -0,0 +1,24 @@
+import { type Color } from "../renderer";
+export declare const OVERLAY_SCROLLBAR_WIDTH_CSS_PX = 7;
+export declare const OVERLAY_SCROLLBAR_MARGIN_CSS_PX = 4;
+export declare const OVERLAY_SCROLLBAR_INSET_Y_CSS_PX = 2;
+export declare const OVERLAY_SCROLLBAR_MIN_THUMB_CSS_PX = 28;
+export declare const OVERLAY_SCROLLBAR_CAP_SUPERSAMPLE = 8;
+export type OverlayScrollbarLayout = {
+    total: number;
+    offset: number;
+    len: number;
+    denom: number;
+    width: number;
+    trackX: number;
+    trackY: number;
+    trackH: number;
+    thumbY: number;
+    thumbH: number;
+};
+export declare function computeOverlayScrollbarLayout(total: number, offset: number, len: number, canvasWidth: number, canvasHeight: number, currentDpr: number): OverlayScrollbarLayout | null;
+export declare function isPointInScrollbarHitArea(layout: OverlayScrollbarLayout, x: number, y: number): boolean;
+export declare function isPointInScrollbarThumb(layout: OverlayScrollbarLayout, x: number, y: number): boolean;
+export declare function scrollbarOffsetForPointerY(layout: OverlayScrollbarLayout, pointerY: number, thumbGrabRatio: number): number;
+export declare function pushRoundedVerticalBar(out: number[], x: number, y: number, w: number, h: number, color: Color, capSupersample?: number): void;
+export declare function resolveOverlayScrollbarAlpha(now: number, lastInputAt: number): number;

package/dist/runtime/pty-output-buffer.d.ts

@@ -0,0 +1,12 @@
+export type CreatePtyOutputBufferControllerOptions = {
+    idleMs: number;
+    maxMs: number;
+    onFlush: (text: string) => void;
+};
+export type PtyOutputBufferController = {
+    queue: (text: string) => void;
+    flush: () => void;
+    cancel: () => void;
+    clear: () => void;
+};
+export declare function createPtyOutputBufferController(options: CreatePtyOutputBufferControllerOptions): PtyOutputBufferController;

package/dist/runtime/render-color-utils.d.ts

@@ -0,0 +1,6 @@
+import type { Color } from "../renderer";
+export declare function decodePackedRGBA(color: number): Color;
+export declare function decodeRGBAWithCache(bytes: Uint8Array, index: number, cache: Map<number, Color>): Color;
+export declare function clamp01(value: number): number;
+export declare function brighten(color: Color, amount: number): Color;
+export declare function fade(color: Color, factor: number): Color;

package/dist/runtime/render-stage-runtime.d.ts

@@ -0,0 +1,18 @@
+import type { CompiledWebGPUShaderStage, WebGPUStageTargets, CompiledWebGLShaderStage, WebGLStageTargets } from "./create-app-types";
+import type { ResttyShaderStage } from "./types";
+export declare function compileShaderStageProgram(options: {
+    gl: WebGL2RenderingContext;
+    stage: ResttyShaderStage;
+    reportError: (stage: ResttyShaderStage, message: string) => void;
+}): CompiledWebGLShaderStage | null;
+export declare function createWebGLStageTexture(gl: WebGL2RenderingContext, width: number, height: number): WebGLTexture | null;
+export declare function createWebGLStageFramebuffer(gl: WebGL2RenderingContext, texture: WebGLTexture): WebGLFramebuffer | null;
+export declare function createWebGLStageTargets(gl: WebGL2RenderingContext, width: number, height: number): WebGLStageTargets | null;
+export declare function compileShaderStagePipelineWebGPU(options: {
+    device: GPUDevice;
+    format: GPUTextureFormat;
+    stage: ResttyShaderStage;
+    reportError: (stage: ResttyShaderStage, message: string) => void;
+}): CompiledWebGPUShaderStage | null;
+export declare function createWebGPUStageTargets(device: GPUDevice, format: GPUTextureFormat, width: number, height: number): WebGPUStageTargets;
+export declare function rebuildWebGPUStageBindGroups(device: GPUDevice, compiledStages: CompiledWebGPUShaderStage[], targets: WebGPUStageTargets): void;

package/dist/runtime/render-stage-shaders.d.ts

@@ -0,0 +1,6 @@
+export declare const STAGE_UNIFORM_BUFFER_FLOATS = 12;
+export declare const FULLSCREEN_STAGE_VERTEX_SHADER_GL = "#version 300 es\nprecision highp float;\nlayout(location = 0) in vec2 a_quad;\nout vec2 v_uv;\nvoid main() {\n  v_uv = a_quad;\n  vec2 clip = vec2(a_quad.x * 2.0 - 1.0, 1.0 - a_quad.y * 2.0);\n  gl_Position = vec4(clip, 0.0, 1.0);\n}\n";
+export declare const FULLSCREEN_STAGE_SHADER_GL_PREFIX = "#version 300 es\nprecision highp float;\nuniform sampler2D u_source;\nuniform vec2 u_resolution;\nuniform float u_time;\nuniform vec4 u_params0;\nuniform vec4 u_params1;\nin vec2 v_uv;\nout vec4 fragColor;\n";
+export declare const FULLSCREEN_STAGE_SHADER_GL_SUFFIX = "\nvoid main() {\n  vec4 color = texture(u_source, v_uv);\n  fragColor = resttyStage(color, v_uv, u_time, u_params0, u_params1);\n}\n";
+export declare const FULLSCREEN_STAGE_SHADER_WGSL_PREFIX = "\nstruct StageUniforms {\n  resolution: vec2f,\n  time: f32,\n  _pad0: f32,\n  params0: vec4f,\n  params1: vec4f,\n};\n\n@group(0) @binding(0) var sourceSampler: sampler;\n@group(0) @binding(1) var sourceTex: texture_2d<f32>;\n@group(0) @binding(2) var<uniform> stageUniforms: StageUniforms;\n\nstruct VSOut {\n  @builtin(position) position: vec4f,\n  @location(0) uv: vec2f,\n};\n\n@vertex\nfn vsMain(@location(0) quad: vec2f) -> VSOut {\n  var out: VSOut;\n  out.uv = quad;\n  let clip = vec2f(quad.x * 2.0 - 1.0, 1.0 - quad.y * 2.0);\n  out.position = vec4f(clip.x, clip.y, 0.0, 1.0);\n  return out;\n}\n";
+export declare const FULLSCREEN_STAGE_SHADER_WGSL_SUFFIX = "\n@fragment\nfn fsMain(input: VSOut) -> @location(0) vec4f {\n  let color = textureSample(sourceTex, sourceSampler, input.uv);\n  return resttyStage(\n    color,\n    input.uv,\n    stageUniforms.time,\n    stageUniforms.params0,\n    stageUniforms.params1,\n  );\n}\n";

package/dist/runtime/shader-stages.d.ts

@@ -0,0 +1,9 @@
+import type { ResttyShaderStage } from "./types";
+export declare const RESTTY_SHADER_STAGE_UNIFORM_CAP = 8;
+export declare function cloneShaderStage(stage: ResttyShaderStage): ResttyShaderStage;
+export declare function cloneShaderStages(stages: ResttyShaderStage[]): ResttyShaderStage[];
+export declare function normalizeShaderStage(stage: ResttyShaderStage): ResttyShaderStage;
+export declare function normalizeShaderStages(stages: ResttyShaderStage[]): ResttyShaderStage[];
+export declare function sortShaderStages(stages: ResttyShaderStage[]): ResttyShaderStage[];
+export declare function packShaderStageUniforms(stage: ResttyShaderStage): Float32Array;
+export declare function isShaderStageEnabledForBackend(stage: ResttyShaderStage, backend: "webgpu" | "webgl2"): boolean;

package/dist/runtime/text-decoration.d.ts

@@ -0,0 +1,4 @@
+import { type Color } from "../renderer";
+export declare function drawUnderlineStyle(underlineData: number[], style: number, x: number, rowY: number, cellW: number, cellH: number, baseY: number, underlineOffsetPx: number, underlineThicknessPx: number, color: Color): void;
+export declare function drawStrikethrough(underlineData: number[], x: number, rowY: number, cellW: number, cellH: number, color: Color): void;
+export declare function drawOverline(underlineData: number[], x: number, rowY: number, cellW: number, color: Color): void;

package/dist/{app → runtime}/types.d.ts

@@ -1,4 +1,4 @@
-import type { InputHandler, MouseMode } from "../input";
+import type { DesktopNotification, InputHandler, MouseMode } from "../input";
 import type { PtyTransport } from "../pty";
 import type { WebGPUCoreState } from "../renderer";
 import type { GhosttyTheme } from "../theme";
@@ -85,6 +85,8 @@ export type ResttyAppCallbacks = {
     onPtyStatus?: (status: string) => void;
     /** Mouse mode/status changed. */
     onMouseStatus?: (status: string) => void;
+    /** Terminal requested a desktop notification via OSC 9 / OSC 777. */
+    onDesktopNotification?: (notification: DesktopNotification) => void;
 };
 /** Raw font data as an ArrayBuffer or typed-array view. */
 export type ResttyFontBufferData = ArrayBuffer | ArrayBufferView;
@@ -141,6 +143,36 @@ export type ResttyAppInputPayload = {
     text: string;
     source: string;
 };
+/** Render-stage phase ordering. */
+export type ResttyShaderStageMode = "before-main" | "after-main" | "replace-main";
+/** Target backend(s) for a shader stage. */
+export type ResttyShaderStageBackend = "webgpu" | "webgl2" | "both";
+/** Stage shader source definitions. */
+export type ResttyShaderStageSource = {
+    /**
+     * WGSL source that defines:
+     * fn resttyStage(color: vec4f, uv: vec2f, time: f32, params0: vec4f, params1: vec4f) -> vec4f
+     */
+    wgsl?: string;
+    /**
+     * GLSL source that defines:
+     * vec4 resttyStage(vec4 color, vec2 uv, float time, vec4 params0, vec4 params1)
+     */
+    glsl?: string;
+};
+/** User-defined frame shader stage. */
+export type ResttyShaderStage = {
+    id: string;
+    mode?: ResttyShaderStageMode;
+    backend?: ResttyShaderStageBackend;
+    priority?: number;
+    enabled?: boolean;
+    /** Optional numeric uniforms packed into params0/params1 (up to 8 values). */
+    uniforms?: number[];
+    shader: ResttyShaderStageSource;
+    /** Optional compile/runtime error callback for this stage. */
+    onError?: (message: string) => void;
+};
 /**
  * Options for creating a ResttyApp instance.
  */
@@ -222,6 +254,8 @@ export type ResttyAppOptions = {
      * queued for rendering.
      */
     beforeRenderOutput?: (payload: ResttyAppInputPayload) => string | null | void;
+    /** Optional render-stage shader chain. */
+    shaderStages?: ResttyShaderStage[];
 };
 /**
  * Public API for a terminal app instance.
@@ -277,4 +311,8 @@ export type ResttyApp = {
     updateSize: (force?: boolean) => void;
     /** Return the name of the active renderer backend. */
     getBackend: () => string;
+    /** Replace the active shader stage list. */
+    setShaderStages: (stages: ResttyShaderStage[]) => void;
+    /** Get the current shader stage list. */
+    getShaderStages: () => ResttyShaderStage[];
 };

package/dist/selection/clipboard.d.ts

@@ -0,0 +1,4 @@
+/** Copy text to the system clipboard, with a legacy execCommand fallback. */
+export declare function copyToClipboard(text: string): Promise<boolean>;
+/** Read text from the system clipboard, returning null on failure. */
+export declare function pasteFromClipboard(): Promise<string | null>;

package/dist/selection/{selection.d.ts → core.d.ts}

@@ -17,13 +17,6 @@ export declare function endSelection(state: SelectionState, cell: CellPosition):
  * is outside the selection.
  */
 export declare function selectionForRow(state: SelectionState, row: number, cols: number): SelectionRange | null;
-/** Callback that returns the text content of a cell by flat grid index. */
-export type CellTextGetter = (idx: number) => string;
-/**
- * Extract the selected text as a newline-separated string, with trailing
- * whitespace trimmed from each line.
- */
-export declare function getSelectionText(state: SelectionState, rows: number, cols: number, getCellText: CellTextGetter): string;
 /**
  * Clamp a cell position to the grid bounds and snap wide-character
  * continuation cells back to the leading cell.
@@ -31,7 +24,3 @@ export declare function getSelectionText(state: SelectionState, rows: number, co
 export declare function normalizeSelectionCell(cell: CellPosition | null, rows: number, cols: number, wideFlags?: Uint8Array | null): CellPosition | null;
 /** Convert client pixel coordinates to a grid cell position. */
 export declare function positionToCell(clientX: number, clientY: number, canvasRect: DOMRect, dpr: number, cellW: number, cellH: number, cols: number, rows: number): CellPosition;
-/** Copy text to the system clipboard, with a legacy execCommand fallback. */
-export declare function copyToClipboard(text: string): Promise<boolean>;
-/** Read text from the system clipboard, returning null on failure. */
-export declare function pasteFromClipboard(): Promise<string | null>;

package/dist/selection/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./types";
-export * from "./selection";
+export * from "./core";
+export * from "./text";
+export * from "./clipboard";

package/dist/selection/text.d.ts

@@ -0,0 +1,8 @@
+import type { SelectionState } from "./types";
+/** Callback that returns the text content of a cell by flat grid index. */
+export type CellTextGetter = (idx: number) => string;
+/**
+ * Extract the selected text as a newline-separated string, with trailing
+ * whitespace trimmed from each line.
+ */
+export declare function getSelectionText(state: SelectionState, rows: number, cols: number, getCellText: CellTextGetter): string;

package/dist/surface/app-factory.d.ts

@@ -0,0 +1,3 @@
+import type { ResttyApp, ResttyAppOptions } from "../runtime/types";
+/** Internal app-construction boundary used by pane manager wiring. */
+export declare function createResttyApp(options: ResttyAppOptions): ResttyApp;

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

@@ -1,5 +1,5 @@
-import { type ResttyPaneStyleOptions, type ResttyPaneStylesOptions, type ResttyPaneContextMenuOptions, type ResttyPaneManager, type ResttyPaneShortcutsOptions, type ResttyPaneWithApp } from "./panes";
-import type { ResttyAppOptions, ResttyAppSession } from "./types";
+import { type ResttyPaneStyleOptions, type ResttyPaneStylesOptions, type ResttyPaneContextMenuOptions, type ResttyPaneManager, type ResttyPaneShortcutsOptions, type ResttyPaneWithApp } from "./panes-types";
+import type { ResttyAppOptions, ResttyAppSession } from "../runtime/types";
 /**
  * A pane created by the app pane manager, extending the base pane
  * with DOM elements needed by the terminal app.

package/dist/surface/panes/default-context-menu-items.d.ts

@@ -0,0 +1,8 @@
+import type { CreateDefaultResttyPaneContextMenuItemsOptions, ResttyPaneContextMenuItem, ResttyPaneWithApp } from "../panes-types";
+/** Return the platform-appropriate shortcut modifier label ("Cmd" on macOS, "Ctrl" elsewhere). */
+export declare function getResttyShortcutModifierLabel(): "Cmd" | "Ctrl";
+/**
+ * Build the standard right-click context menu items for a pane
+ * (copy, paste, split, close, clear, PTY toggle, pause toggle).
+ */
+export declare function createDefaultResttyPaneContextMenuItems<TPane extends ResttyPaneWithApp>(options: CreateDefaultResttyPaneContextMenuItemsOptions<TPane>): Array<ResttyPaneContextMenuItem | "separator">;

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

@@ -0,0 +1,9 @@
+import type { ResttyPaneDefinition, ResttyPaneSplitDirection } from "../panes-types";
+export declare function findClosestPaneToRect<TPane extends ResttyPaneDefinition>(sourceRect: DOMRectReadOnly | null, panes: Iterable<TPane>): TPane | null;
+export declare function collapseSplitAncestors(start: HTMLElement | null): void;
+export declare function createSplitDividerFactory(options: {
+    minPaneSize: number;
+    requestLayoutSync: () => void;
+}): {
+    createSplitDivider: (direction: ResttyPaneSplitDirection) => HTMLDivElement;
+};

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

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

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

@@ -0,0 +1,11 @@
+import type { PaneContextMenuController } from "../panes-context-menu";
+import type { ResttyPaneContextMenuOptions, ResttyPaneDefinition, ResttyPaneManager } from "../panes-types";
+export declare function createPaneInteractions<TPane extends ResttyPaneDefinition>(options: {
+    contextMenu: ResttyPaneContextMenuOptions<TPane> | null | undefined;
+    contextMenuController: PaneContextMenuController<TPane> | null;
+    getManager: () => ResttyPaneManager<TPane>;
+    markPaneFocused: (id: number) => void;
+}): {
+    bindPaneInteractions: (pane: TPane) => void;
+    cleanupPaneInteractions: (id: number) => void;
+};

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

@@ -0,0 +1,10 @@
+import type { ResttyPaneShortcutsOptions, ResttyPaneSplitDirection } from "../panes-types";
+export declare function attachPaneManagerWindowEvents(options: {
+    contextMenuController?: {
+        isOpen: () => boolean;
+        containsTarget: (target: EventTarget | null) => boolean;
+    } | null;
+    hideContextMenu: () => void;
+    shortcutOptions: ResttyPaneShortcutsOptions;
+    splitActivePane: (direction: ResttyPaneSplitDirection) => void;
+}): () => void;

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

@@ -1,4 +1,4 @@
-import type { ResttyApp } from "./types";
+import type { ResttyApp } from "../runtime/types";
 /**
  * Direction for splitting a pane.
  * - vertical: split left/right

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

@@ -0,0 +1,23 @@
+import type { InputHandler, MouseMode } from "../../input";
+import type { GhosttyTheme } from "../../theme";
+import type { ResttyPaneHandle } from "../restty-pane-handle";
+export declare abstract class ResttyActivePaneApi {
+    protected abstract requireActivePaneHandle(): ResttyPaneHandle;
+    isPtyConnected(): boolean;
+    setRenderer(value: "auto" | "webgpu" | "webgl2"): void;
+    setPaused(value: boolean): void;
+    togglePause(): void;
+    setFontSize(value: number): void;
+    applyTheme(theme: GhosttyTheme, sourceLabel?: string): void;
+    resetTheme(): void;
+    sendInput(text: string, source?: string): void;
+    sendKeyInput(text: string, source?: string): void;
+    clearScreen(): void;
+    setMouseMode(value: MouseMode): void;
+    getMouseStatus(): ReturnType<InputHandler["getMouseStatus"]>;
+    copySelectionToClipboard(): Promise<boolean>;
+    pasteFromClipboard(): Promise<boolean>;
+    dumpAtlasForCodepoint(cp: number): void;
+    updateSize(force?: boolean): void;
+    getBackend(): string;
+}

package/dist/surface/restty/manager-options.d.ts

@@ -0,0 +1,24 @@
+import type { DesktopNotification } from "../../input";
+import type { CreateResttyAppPaneManagerOptions } from "../pane-app-manager";
+import type { ResttyPluginEvents, ResttyRenderHookPayload } from "../restty-plugin-types";
+import type { ResttyFontSource } from "../../runtime/types";
+import type { ResttyPluginOps } from "./plugin-ops";
+import type { ResttyShaderOps } from "./shader-ops";
+type PaneManagerEventHandlers = Pick<CreateResttyAppPaneManagerOptions, "onPaneCreated" | "onPaneClosed" | "onPaneSplit" | "onActivePaneChange" | "onLayoutChanged">;
+type MergedPaneAppOptionsDeps = {
+    appOptions: CreateResttyAppPaneManagerOptions["appOptions"] | undefined;
+    getFontSources: () => ResttyFontSource[] | undefined;
+    onDesktopNotification?: (notification: DesktopNotification & {
+        paneId: number;
+    }) => void;
+    shaderOps: Pick<ResttyShaderOps, "normalizePaneShaderStages" | "setPaneBaseShaderStages" | "buildMergedShaderStages">;
+    pluginOps: Pick<ResttyPluginOps, "applyInputInterceptors" | "applyOutputInterceptors">;
+    runRenderHooks: (payload: ResttyRenderHookPayload) => void;
+};
+type PaneManagerCallbacksDeps = PaneManagerEventHandlers & {
+    shaderOps: Pick<ResttyShaderOps, "syncPaneShaderStages" | "removePaneBaseShaderStages">;
+    emitPluginEvent: <E extends keyof ResttyPluginEvents>(event: E, payload: ResttyPluginEvents[E]) => void;
+};
+export declare function createMergedPaneAppOptions(deps: MergedPaneAppOptionsDeps): CreateResttyAppPaneManagerOptions["appOptions"];
+export declare function createPaneManagerEventHandlers(deps: PaneManagerCallbacksDeps): PaneManagerEventHandlers;
+export {};

package/dist/surface/restty/pane-ops.d.ts

@@ -0,0 +1,42 @@
+import type { ResttyManagedAppPane, ResttyManagedPaneStyleOptions } from "../pane-app-manager";
+import type { ResttyPaneManager, ResttyPaneSplitDirection } from "../panes-types";
+import { ResttyPaneHandle } from "../restty-pane-handle";
+import type { ResttyLifecycleHookPayload, ResttyPluginEvents } from "../restty-plugin-types";
+type ResttyPaneLookup = {
+    getPanes: () => ResttyManagedAppPane[];
+    getPaneById: (id: number) => ResttyManagedAppPane | null;
+    getActivePane: () => ResttyManagedAppPane | null;
+    getFocusedPane: () => ResttyManagedAppPane | null;
+};
+type ResttyLifecycleEmitter = {
+    runLifecycleHooks: (payload: ResttyLifecycleHookPayload) => void;
+    emitPluginEvent: <E extends keyof ResttyPluginEvents>(event: E, payload: ResttyPluginEvents[E]) => void;
+};
+export declare function requirePaneById(getPaneById: (id: number) => ResttyManagedAppPane | null, id: number): ResttyManagedAppPane;
+export declare function makePaneHandle(getPaneById: (id: number) => ResttyManagedAppPane | null, id: number): ResttyPaneHandle;
+export declare function requireActivePaneHandle(lookup: Pick<ResttyPaneLookup, "getActivePane" | "getPaneById">): ResttyPaneHandle;
+export declare function panes(lookup: Pick<ResttyPaneLookup, "getPanes" | "getPaneById">): ResttyPaneHandle[];
+export declare function pane(lookup: Pick<ResttyPaneLookup, "getPaneById">, id: number): ResttyPaneHandle | null;
+export declare function activePane(lookup: Pick<ResttyPaneLookup, "getActivePane" | "getPaneById">): ResttyPaneHandle | null;
+export declare function focusedPane(lookup: Pick<ResttyPaneLookup, "getFocusedPane" | "getPaneById">): ResttyPaneHandle | null;
+export declare function forEachPane(lookup: Pick<ResttyPaneLookup, "getPanes" | "getPaneById">, visitor: (pane: ResttyPaneHandle) => void): void;
+export declare function createInitialPane(paneManager: ResttyPaneManager<ResttyManagedAppPane>, hooks: Pick<ResttyLifecycleEmitter, "runLifecycleHooks">, options?: {
+    focus?: boolean;
+}): ResttyManagedAppPane;
+export declare function splitActivePane(paneManager: ResttyPaneManager<ResttyManagedAppPane>, lookup: Pick<ResttyPaneLookup, "getActivePane">, hooks: Pick<ResttyLifecycleEmitter, "runLifecycleHooks">, direction: ResttyPaneSplitDirection): ResttyManagedAppPane | null;
+export declare function splitPane(paneManager: ResttyPaneManager<ResttyManagedAppPane>, hooks: Pick<ResttyLifecycleEmitter, "runLifecycleHooks">, id: number, direction: ResttyPaneSplitDirection): ResttyManagedAppPane | null;
+export declare function closePane(paneManager: ResttyPaneManager<ResttyManagedAppPane>, hooks: Pick<ResttyLifecycleEmitter, "runLifecycleHooks">, id: number): boolean;
+export declare function setActivePane(paneManager: ResttyPaneManager<ResttyManagedAppPane>, lookup: Pick<ResttyPaneLookup, "getActivePane">, hooks: Pick<ResttyLifecycleEmitter, "runLifecycleHooks">, id: number, options?: {
+    focus?: boolean;
+}): void;
+export declare function markPaneFocused(paneManager: ResttyPaneManager<ResttyManagedAppPane>, lookup: Pick<ResttyPaneLookup, "getFocusedPane">, hooks: Pick<ResttyLifecycleEmitter, "runLifecycleHooks">, id: number, options?: {
+    focus?: boolean;
+}): void;
+export declare function connectPty(lookup: Pick<ResttyPaneLookup, "getActivePane" | "getPaneById">, hooks: Pick<ResttyLifecycleEmitter, "runLifecycleHooks">, url?: string): void;
+export declare function disconnectPty(lookup: Pick<ResttyPaneLookup, "getActivePane" | "getPaneById">, hooks: Pick<ResttyLifecycleEmitter, "runLifecycleHooks">): void;
+export declare function resize(lookup: Pick<ResttyPaneLookup, "getActivePane" | "getPaneById">, hooks: ResttyLifecycleEmitter, cols: number, rows: number): void;
+export declare function focus(lookup: Pick<ResttyPaneLookup, "getActivePane" | "getPaneById">, hooks: ResttyLifecycleEmitter): void;
+export declare function blur(lookup: Pick<ResttyPaneLookup, "getActivePane" | "getPaneById">, hooks: ResttyLifecycleEmitter): void;
+export declare function getPaneStyleOptions(paneManager: ResttyPaneManager<ResttyManagedAppPane>): Readonly<Required<ResttyManagedPaneStyleOptions>>;
+export declare function setPaneStyleOptions(paneManager: ResttyPaneManager<ResttyManagedAppPane>, options: ResttyManagedPaneStyleOptions): void;
+export {};

package/dist/surface/restty/plugin-dispatcher.d.ts

@@ -0,0 +1,39 @@
+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;
+};
+export declare class ResttyPluginDispatcher {
+    private readonly deps;
+    private readonly pluginListeners;
+    private readonly inputInterceptors;
+    private readonly outputInterceptors;
+    private readonly lifecycleHooks;
+    private readonly renderHooks;
+    private nextInterceptorId;
+    private nextInterceptorOrder;
+    constructor(deps: ResttyPluginHostDeps);
+    createPluginContext(runtime: ResttyPluginRuntime): ResttyPluginContext;
+    applyInputInterceptors(paneId: number, text: string, source: string): string | null;
+    applyOutputInterceptors(paneId: number, text: string, source: string): string | null;
+    runLifecycleHooks(payload: ResttyLifecycleHookPayload): void;
+    runRenderHooks(payload: ResttyRenderHookPayload): void;
+    emitPluginEvent<E extends keyof ResttyPluginEvents>(event: E, payload: ResttyPluginEvents[E]): void;
+    private attachRuntimeDisposer;
+    private addInputInterceptor;
+    private addOutputInterceptor;
+    private addLifecycleHook;
+    private addRenderHook;
+    private registerInterceptor;
+    private applyInterceptors;
+    private runHooks;
+    private onPluginEvent;
+}

package/dist/surface/restty/plugin-ops.d.ts

@@ -0,0 +1,24 @@
+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 {
+    private readonly pluginRuntimes;
+    private readonly pluginDiagnostics;
+    private readonly dispatcher;
+    constructor(deps: ResttyPluginHostDeps);
+    use(plugin: ResttyPlugin, options?: unknown): Promise<void>;
+    loadPlugins(manifest: ReadonlyArray<ResttyPluginManifestEntry>, registry: ResttyPluginRegistry): Promise<ResttyPluginLoadResult[]>;
+    unuse(pluginId: string): boolean;
+    plugins(): string[];
+    pluginInfo(pluginId: string): ResttyPluginInfo | null;
+    pluginInfo(): ResttyPluginInfo[];
+    destroy(): void;
+    applyInputInterceptors(paneId: number, text: string, source: string): string | null;
+    applyOutputInterceptors(paneId: number, text: string, source: string): string | null;
+    runLifecycleHooks(payload: ResttyLifecycleHookPayload): void;
+    runRenderHooks(payload: ResttyRenderHookPayload): void;
+    emitPluginEvent<E extends keyof ResttyPluginEvents>(event: E, payload: ResttyPluginEvents[E]): void;
+    private setPluginLoadError;
+    private updatePluginDiagnostic;
+    private buildPluginInfo;
+    private teardownPluginRuntime;
+}

package/dist/surface/restty/shader-ops.d.ts

@@ -0,0 +1,27 @@
+import type { ResttyManagedAppPane } from "../pane-app-manager";
+import type { ResttyRenderStageHandle } from "../restty-plugin-types";
+import type { ResttyShaderStage } from "../../runtime/types";
+type ResttyShaderOpsDeps = {
+    getPanes: () => ResttyManagedAppPane[];
+    getPaneById: (id: number) => ResttyManagedAppPane | null;
+};
+export declare class ResttyShaderOps {
+    private readonly paneBaseShaderStages;
+    private readonly globalShaderStages;
+    private nextShaderStageOrder;
+    private readonly deps;
+    constructor(deps: ResttyShaderOpsDeps, shaderStages?: ResttyShaderStage[]);
+    setShaderStages(stages: ResttyShaderStage[]): void;
+    getShaderStages(): ResttyShaderStage[];
+    addShaderStage(stage: ResttyShaderStage): ResttyRenderStageHandle;
+    addManagedShaderStage(stage: ResttyShaderStage, ownerPluginId: string | null): ResttyRenderStageHandle;
+    removeShaderStage(id: string): boolean;
+    normalizePaneShaderStages(stages: ResttyShaderStage[] | undefined, paneId: number): ResttyShaderStage[];
+    setPaneBaseShaderStages(paneId: number, stages: ResttyShaderStage[]): void;
+    removePaneBaseShaderStages(paneId: number): void;
+    buildMergedShaderStages(baseStages: ResttyShaderStage[]): ResttyShaderStage[];
+    syncPaneShaderStages(paneId?: number): void;
+    clear(): void;
+    private listGlobalShaderStages;
+}
+export {};

package/dist/surface/restty-pane-handle.d.ts

@@ -0,0 +1,70 @@
+import type { InputHandler, MouseMode } from "../input";
+import type { GhosttyTheme } from "../theme";
+import type { ResttyManagedAppPane } from "./pane-app-manager";
+import type { ResttyShaderStage } from "../runtime/types";
+/**
+ * Public API surface exposed by each pane handle.
+ */
+export type ResttyPaneApi = {
+    id: number;
+    setRenderer: (value: "auto" | "webgpu" | "webgl2") => void;
+    setPaused: (value: boolean) => void;
+    togglePause: () => void;
+    setFontSize: (value: number) => void;
+    applyTheme: (theme: GhosttyTheme, sourceLabel?: string) => void;
+    resetTheme: () => void;
+    sendInput: (text: string, source?: string) => void;
+    sendKeyInput: (text: string, source?: string) => void;
+    clearScreen: () => void;
+    connectPty: (url?: string) => void;
+    disconnectPty: () => void;
+    isPtyConnected: () => boolean;
+    setMouseMode: (value: MouseMode) => void;
+    getMouseStatus: () => ReturnType<InputHandler["getMouseStatus"]>;
+    copySelectionToClipboard: () => Promise<boolean>;
+    pasteFromClipboard: () => Promise<boolean>;
+    dumpAtlasForCodepoint: (cp: number) => void;
+    resize: (cols: number, rows: number) => void;
+    focus: () => void;
+    blur: () => void;
+    updateSize: (force?: boolean) => void;
+    getBackend: () => string;
+    setShaderStages: (stages: ResttyShaderStage[]) => void;
+    getShaderStages: () => ResttyShaderStage[];
+    getRawPane: () => ResttyManagedAppPane;
+};
+/**
+ * Thin wrapper around a managed pane that delegates calls to the
+ * underlying app. Resolves the pane lazily so it stays valid across
+ * layout changes.
+ */
+export declare class ResttyPaneHandle implements ResttyPaneApi {
+    private readonly resolvePane;
+    constructor(resolvePane: () => ResttyManagedAppPane);
+    get id(): number;
+    setRenderer(value: "auto" | "webgpu" | "webgl2"): void;
+    setPaused(value: boolean): void;
+    togglePause(): void;
+    setFontSize(value: number): void;
+    applyTheme(theme: GhosttyTheme, sourceLabel?: string): void;
+    resetTheme(): void;
+    sendInput(text: string, source?: string): void;
+    sendKeyInput(text: string, source?: string): void;
+    clearScreen(): void;
+    connectPty(url?: string): void;
+    disconnectPty(): void;
+    isPtyConnected(): boolean;
+    setMouseMode(value: MouseMode): void;
+    getMouseStatus(): ReturnType<InputHandler["getMouseStatus"]>;
+    copySelectionToClipboard(): Promise<boolean>;
+    pasteFromClipboard(): Promise<boolean>;
+    dumpAtlasForCodepoint(cp: number): void;
+    resize(cols: number, rows: number): void;
+    focus(): void;
+    blur(): void;
+    updateSize(force?: boolean): void;
+    getBackend(): string;
+    setShaderStages(stages: ResttyShaderStage[]): void;
+    getShaderStages(): ResttyShaderStage[];
+    getRawPane(): ResttyManagedAppPane;
+}

package/dist/surface/restty-plugin-runtime.d.ts

@@ -0,0 +1,57 @@
+import type { ResttyShaderStage } from "../runtime/types";
+import type { ResttyInterceptorOptions, ResttyPlugin, ResttyPluginEvents, ResttyPluginInfo, ResttyPluginRequires } from "./restty-plugin-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 declare function registerPluginInterceptor<T extends (payload: unknown) => unknown>(bucket: Array<ResttyRegisteredInterceptor<T>>, pluginId: string, interceptor: T, options: ResttyInterceptorOptions | undefined, 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: Map<string, ResttyPluginDiagnostic>, pluginId: string, message: string): void;
+export declare function patchPluginDiagnostic(pluginDiagnostics: Map<string, ResttyPluginDiagnostic>, pluginId: string, patch: Partial<Pick<ResttyPluginDiagnostic, "active" | "activatedAt" | "lastError">>): void;
+export declare function buildPluginInfo(pluginId: string, pluginDiagnostics: Map<string, ResttyPluginDiagnostic>, pluginRuntimes: Map<string, ResttyPluginRuntime>): ResttyPluginInfo | null;
+export declare function onPluginEvent<E extends keyof ResttyPluginEvents>(pluginListeners: Map<keyof ResttyPluginEvents, Set<(payload: unknown) => void>>, event: E, listener: (payload: ResttyPluginEvents[E]) => void): () => void;
+export declare function emitPluginEvent<E extends keyof ResttyPluginEvents>(pluginListeners: Map<keyof ResttyPluginEvents, Set<(payload: unknown) => void>>, event: E, payload: ResttyPluginEvents[E]): void;