restty 0.1.23 → 0.1.25

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

@@ -0,0 +1,164 @@
+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;
+    };
+};
+/** A disposable resource returned by plugin APIs. */
+export type ResttyPluginDisposable = {
+    dispose: () => void;
+};
+/** Optional cleanup return supported by plugin activation. */
+export type ResttyPluginCleanup = void | (() => void) | ResttyPluginDisposable;
+/** Payload passed to input interceptors before terminal/program input is written. */
+export type ResttyInputInterceptorPayload = {
+    paneId: number;
+    text: string;
+    source: string;
+};
+/** Payload passed to output interceptors before PTY data is rendered. */
+export type ResttyOutputInterceptorPayload = {
+    paneId: number;
+    text: string;
+    source: string;
+};
+/** Input interceptor contract. */
+export type ResttyInputInterceptor = (payload: ResttyInputInterceptorPayload) => string | null | void;
+/** Output interceptor contract. */
+export type ResttyOutputInterceptor = (payload: ResttyOutputInterceptorPayload) => string | null | void;
+/** Payload passed to lifecycle hooks registered by plugins. */
+export type ResttyLifecycleHookPayload = {
+    phase: "before" | "after";
+    action: "create-initial-pane" | "split-active-pane" | "split-pane" | "close-pane" | "set-active-pane" | "mark-pane-focused" | "connect-pty" | "disconnect-pty" | "resize" | "focus" | "blur";
+    paneId?: number | null;
+    sourcePaneId?: number;
+    createdPaneId?: number | null;
+    direction?: ResttyPaneSplitDirection;
+    cols?: number;
+    rows?: number;
+    ok?: boolean;
+    error?: string | null;
+};
+/** Lifecycle hook contract. */
+export type ResttyLifecycleHook = (payload: ResttyLifecycleHookPayload) => void;
+/** Payload passed to render hooks registered by plugins. */
+export type ResttyRenderHookPayload = {
+    phase: "before" | "after";
+    paneId: number;
+    text: string;
+    source: string;
+    dropped: boolean;
+};
+/** Render hook contract. */
+export type ResttyRenderHook = (payload: ResttyRenderHookPayload) => void;
+/** Shared options for interceptor ordering. */
+export type ResttyInterceptorOptions = {
+    priority?: number;
+};
+export type ResttyRenderStageHandle = {
+    id: string;
+    setUniforms: (uniforms: number[]) => void;
+    setEnabled: (value: boolean) => void;
+    dispose: () => void;
+};
+/** Context object provided to each plugin on activation. */
+export type ResttyPluginContext = {
+    restty: Restty;
+    options: unknown;
+    panes: () => ResttyPaneHandle[];
+    pane: (id: number) => ResttyPaneHandle | null;
+    activePane: () => ResttyPaneHandle | null;
+    focusedPane: () => ResttyPaneHandle | null;
+    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;
+    addLifecycleHook: (hook: ResttyLifecycleHook, options?: ResttyInterceptorOptions) => ResttyPluginDisposable;
+    addRenderHook: (hook: ResttyRenderHook, options?: ResttyInterceptorOptions) => ResttyPluginDisposable;
+    addRenderStage: (stage: ResttyShaderStage) => ResttyRenderStageHandle;
+};
+/** Plugin contract for extending Restty behavior. */
+export type ResttyPlugin = {
+    id: string;
+    version?: string;
+    apiVersion?: number;
+    requires?: ResttyPluginRequires;
+    activate: (context: ResttyPluginContext, options?: unknown) => ResttyPluginCleanup | Promise<ResttyPluginCleanup>;
+};

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

@@ -0,0 +1,22 @@
+export type ResttyPluginApiRangeLike = {
+    min: number;
+    max?: number;
+};
+export type ResttyPluginRequiresLike = {
+    pluginApi?: number | ResttyPluginApiRangeLike;
+};
+export type ResttyPluginLike = {
+    id: string;
+    version?: string;
+    apiVersion?: number;
+    requires?: ResttyPluginRequiresLike;
+};
+export type ResttyPluginCleanupLike = void | (() => void) | {
+    dispose: () => void;
+};
+export declare function errorToMessage(error: unknown): string;
+export declare function normalizePluginMetadata<T extends ResttyPluginLike>(plugin: T, pluginId: string): T;
+export declare function assertPluginCompatibility(pluginId: string, plugin: ResttyPluginLike, pluginApiVersion: number): void;
+export declare function lookupPluginRegistryEntry<T>(registry: ReadonlyMap<string, T> | Record<string, T>, pluginId: string): T | null;
+export declare function resolvePluginRegistryEntry<T>(entry: T | (() => T | Promise<T>)): Promise<T>;
+export declare function normalizePluginCleanup(cleanup: ResttyPluginCleanupLike): (() => void) | null;

package/dist/surface/restty.d.ts

@@ -0,0 +1,93 @@
+import type { DesktopNotification } from "../input";
+import { type CreateResttyAppPaneManagerOptions, type ResttyManagedAppPane, type ResttyManagedPaneStyleOptions, type ResttyPaneAppOptionsInput } from "./pane-app-manager";
+import type { ResttyPaneManager, ResttyPaneSplitDirection } from "./panes-types";
+import type { ResttyFontSource, ResttyShaderStage } from "../runtime/types";
+import { ResttyPaneHandle } from "./restty-pane-handle";
+import { ResttyActivePaneApi } from "./restty/active-pane-api";
+import { type ResttyPluginInfo, type ResttyPluginManifestEntry, type ResttyPluginRegistry, type ResttyPluginLoadResult, type ResttyRenderStageHandle, type ResttyPlugin } from "./restty-plugin-types";
+export { ResttyPaneHandle } from "./restty-pane-handle";
+export type { ResttyPaneApi } from "./restty-pane-handle";
+export { RESTTY_PLUGIN_API_VERSION } from "./restty-plugin-types";
+export type { ResttyPluginApiRange, ResttyPluginRequires, ResttyPluginInfo, ResttyPluginManifestEntry, ResttyPluginRegistryEntry, ResttyPluginRegistry, ResttyPluginLoadStatus, ResttyPluginLoadResult, ResttyPluginEvents, ResttyPluginDisposable, ResttyPluginCleanup, ResttyInputInterceptorPayload, ResttyOutputInterceptorPayload, ResttyInputInterceptor, ResttyOutputInterceptor, ResttyLifecycleHookPayload, ResttyLifecycleHook, ResttyRenderHookPayload, ResttyRenderHook, ResttyInterceptorOptions, ResttyRenderStageHandle, ResttyPluginContext, ResttyPlugin, } from "./restty-plugin-types";
+/**
+ * Top-level configuration for creating a Restty instance.
+ */
+export type ResttyOptions = Omit<CreateResttyAppPaneManagerOptions, "appOptions"> & {
+    /** Per-pane app options, static or factory. */
+    appOptions?: CreateResttyAppPaneManagerOptions["appOptions"];
+    /** Font sources applied to every pane. */
+    fontSources?: ResttyPaneAppOptionsInput["fontSources"];
+    /** Global shader stages synchronized to all panes. */
+    shaderStages?: ResttyShaderStage[];
+    /** Global handler for desktop notifications emitted by any pane. */
+    onDesktopNotification?: (notification: DesktopNotification & {
+        paneId: number;
+    }) => void;
+    /** Whether to create the first pane automatically (default true). */
+    createInitialPane?: boolean | {
+        focus?: boolean;
+    };
+};
+/**
+ * Main entry point for the restty terminal widget. Manages a set of
+ * split panes, each running its own terminal app, and exposes
+ * convenience methods that operate on the active pane.
+ */
+export declare class Restty extends ResttyActivePaneApi {
+    readonly paneManager: ResttyPaneManager<ResttyManagedAppPane>;
+    private fontSources;
+    private readonly shaderOps;
+    private readonly pluginOps;
+    constructor(options: ResttyOptions);
+    getPanes(): ResttyManagedAppPane[];
+    getPaneById(id: number): ResttyManagedAppPane | null;
+    getActivePane(): ResttyManagedAppPane | null;
+    getFocusedPane(): ResttyManagedAppPane | null;
+    panes(): ResttyPaneHandle[];
+    pane(id: number): ResttyPaneHandle | null;
+    activePane(): ResttyPaneHandle | null;
+    focusedPane(): ResttyPaneHandle | null;
+    forEachPane(visitor: (pane: ResttyPaneHandle) => void): void;
+    setFontSources(sources: ResttyFontSource[]): Promise<void>;
+    setShaderStages(stages: ResttyShaderStage[]): void;
+    getShaderStages(): ResttyShaderStage[];
+    addShaderStage(stage: ResttyShaderStage): ResttyRenderStageHandle;
+    removeShaderStage(id: string): boolean;
+    createInitialPane(options?: {
+        focus?: boolean;
+    }): ResttyManagedAppPane;
+    splitActivePane(direction: ResttyPaneSplitDirection): ResttyManagedAppPane | null;
+    splitPane(id: number, direction: ResttyPaneSplitDirection): ResttyManagedAppPane | null;
+    closePane(id: number): boolean;
+    getPaneStyleOptions(): Readonly<Required<ResttyManagedPaneStyleOptions>>;
+    setPaneStyleOptions(options: ResttyManagedPaneStyleOptions): void;
+    setActivePane(id: number, options?: {
+        focus?: boolean;
+    }): void;
+    markPaneFocused(id: number, options?: {
+        focus?: boolean;
+    }): void;
+    requestLayoutSync(): void;
+    hideContextMenu(): void;
+    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;
+    connectPty(url?: string): void;
+    disconnectPty(): void;
+    resize(cols: number, rows: number): void;
+    focus(): void;
+    blur(): void;
+    private paneLookup;
+    private lifecycleHooks;
+    private lifecycleAndPluginHooks;
+    protected requireActivePaneHandle(): ResttyPaneHandle;
+    private runLifecycleHooks;
+    private runRenderHooks;
+    private emitPluginEvent;
+}
+/** Create a new Restty instance with the given options. */
+export declare function createRestty(options: ResttyOptions): Restty;

package/dist/utils/base64.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Decode base64 text into bytes. Throws when no decoder is available in
+ * the current runtime.
+ */
+export declare function decodeBase64Bytes(text: string): Uint8Array;
+/**
+ * Encode bytes to base64 text. Throws when no encoder is available in the
+ * current runtime.
+ */
+export declare function encodeBase64Bytes(bytes: Uint8Array): string;
+/** Decode base64 text payloads to UTF-8 text, returning empty text on errors. */
+export declare function decodeBase64Text(text: string): string;

package/dist/wasm/index.d.ts

@@ -1 +1,2 @@
-export * from "./runtime";
+export type { CursorInfo, KittyPlacement, RenderState, ResttyWasmExports, ResttyWasmOptions, WasmAbi, WasmAbiKind, } from "./runtime/types";
+export { ResttyWasm, loadResttyWasm } from "./runtime/restty-wasm";

package/dist/wasm/runtime/abi.d.ts

@@ -0,0 +1,7 @@
+import type { CursorInfo, RenderPtrs, ResttyWasmExports, WasmAbi } from "./types";
+export declare function resolveWasmAbi(exports: ResttyWasmExports): WasmAbi | null;
+export declare function unpackCursor(buffer: ArrayBufferLike, ptr: number): CursorInfo | null;
+export declare function readRenderInfo(exports: ResttyWasmExports, handle: number): RenderPtrs | null;
+export declare function readRenderPtrs(exports: ResttyWasmExports, handle: number): RenderPtrs;
+export declare function readCellPtrs(exports: ResttyWasmExports, handle: number): RenderPtrs;
+export declare function readRenderStatePtrs(abi: WasmAbi, exports: ResttyWasmExports, handle: number): RenderPtrs | null;

package/dist/wasm/runtime/kitty.d.ts

@@ -0,0 +1,2 @@
+import type { KittyPlacement, ResttyWasmExports } from "./types";
+export declare function readKittyPlacements(exports: ResttyWasmExports, memory: WebAssembly.Memory, handle: number): KittyPlacement[];

package/dist/wasm/runtime/render-state.d.ts

@@ -0,0 +1,2 @@
+import type { RenderState, RenderViewCache, ResttyWasmExports, WasmAbi } from "./types";
+export declare function readRenderState(abi: WasmAbi, exports: ResttyWasmExports, memory: WebAssembly.Memory, handle: number, cache: RenderViewCache): RenderState | null;

package/dist/wasm/runtime/restty-wasm.d.ts

@@ -0,0 +1,42 @@
+import type { KittyPlacement, RenderState, ResttyWasmExports, ResttyWasmOptions, WasmAbi } from "./types";
+/** WASM terminal core runtime with memory management and typed array caching. */
+export declare class ResttyWasm {
+    readonly exports: ResttyWasmExports;
+    readonly abi: WasmAbi;
+    readonly memory: WebAssembly.Memory;
+    private readonly renderViewCaches;
+    private constructor();
+    /** Load and instantiate the embedded WASM module. */
+    static load(options?: ResttyWasmOptions): Promise<ResttyWasm>;
+    /** Create a new terminal instance and return its handle. */
+    create(cols: number, rows: number, maxScrollback: number): number;
+    /** Destroy a terminal instance and free its resources. */
+    destroy(handle: number): void;
+    private getRenderViewCache;
+    /** Resize the terminal grid. */
+    resize(handle: number, cols: number, rows: number): void;
+    /** Set pixel dimensions for Kitty graphics protocol. */
+    setPixelSize(handle: number, widthPx: number, heightPx: number): void;
+    /** Update internal render buffers after state changes. */
+    renderUpdate(handle: number): void;
+    /** Scroll the viewport by delta rows. */
+    scrollViewport(handle: number, delta: number): void;
+    /** Read and clear pending output replies from terminal. */
+    drainOutput(handle: number): string;
+    /** Get active Kitty keyboard protocol flags. */
+    getKittyKeyboardFlags(handle: number): number;
+    /** Get all active Kitty graphics placements. */
+    getKittyPlacements(handle: number): KittyPlacement[];
+    /** Write text to terminal for processing. */
+    write(handle: number, text: string): void;
+    /** Set default colors for terminal (RGB packed as 0xRRGGBB). */
+    setDefaultColors(handle: number, fg: number, bg: number, cursor: number): void;
+    /** Set terminal color palette (RGB triples). */
+    setPalette(handle: number, colors: Uint8Array, count: number): void;
+    /** Reset terminal palette to defaults. */
+    resetPalette(handle: number): void;
+    /** Get current render state with cached typed array views. */
+    getRenderState(handle: number): RenderState | null;
+}
+/** Load and instantiate the embedded WASM module (convenience function). */
+export declare function loadResttyWasm(options?: ResttyWasmOptions): Promise<ResttyWasm>;

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

@@ -141,44 +141,51 @@ export type ResttyWasmExports = WebAssembly.Exports & {
 export type ResttyWasmOptions = {
     log?: (message: string) => void;
 };
-/** WASM terminal core runtime with memory management and typed array caching. */
-export declare class ResttyWasm {
-    readonly exports: ResttyWasmExports;
-    readonly abi: WasmAbi;
-    readonly memory: WebAssembly.Memory;
-    private readonly renderViewCaches;
-    private constructor();
-    /** Load and instantiate the embedded WASM module. */
-    static load(options?: ResttyWasmOptions): Promise<ResttyWasm>;
-    /** Create a new terminal instance and return its handle. */
-    create(cols: number, rows: number, maxScrollback: number): number;
-    /** Destroy a terminal instance and free its resources. */
-    destroy(handle: number): void;
-    private getRenderViewCache;
-    /** Resize the terminal grid. */
-    resize(handle: number, cols: number, rows: number): void;
-    /** Set pixel dimensions for Kitty graphics protocol. */
-    setPixelSize(handle: number, widthPx: number, heightPx: number): void;
-    /** Update internal render buffers after state changes. */
-    renderUpdate(handle: number): void;
-    /** Scroll the viewport by delta rows. */
-    scrollViewport(handle: number, delta: number): void;
-    /** Read and clear pending output replies from terminal. */
-    drainOutput(handle: number): string;
-    /** Get active Kitty keyboard protocol flags. */
-    getKittyKeyboardFlags(handle: number): number;
-    /** Get all active Kitty graphics placements. */
-    getKittyPlacements(handle: number): KittyPlacement[];
-    /** Write text to terminal for processing. */
-    write(handle: number, text: string): void;
-    /** Set default colors for terminal (RGB packed as 0xRRGGBB). */
-    setDefaultColors(handle: number, fg: number, bg: number, cursor: number): void;
-    /** Set terminal color palette (RGB triples). */
-    setPalette(handle: number, colors: Uint8Array, count: number): void;
-    /** Reset terminal palette to defaults. */
-    resetPalette(handle: number): void;
-    /** Get current render state with cached typed array views. */
-    getRenderState(handle: number): RenderState | null;
-}
-/** Load and instantiate the embedded WASM module (convenience function). */
-export declare function loadResttyWasm(options?: ResttyWasmOptions): Promise<ResttyWasm>;
+export type RenderPtrs = {
+    rows: number;
+    cols: number;
+    codepointsPtr: number;
+    contentTagsPtr: number;
+    widePtr: number;
+    flagsPtr: number;
+    styleFlagsPtr: number;
+    linkIdsPtr: number;
+    fgPtr: number;
+    bgPtr: number;
+    ulPtr: number;
+    ulStylePtr: number;
+    graphemeOffsetPtr: number;
+    graphemeLenPtr: number;
+    graphemeBufferPtr: number;
+    graphemeBufferLen: number;
+    selectionStartPtr: number;
+    selectionEndPtr: number;
+    cursorPtr: number;
+};
+export type ViewEntry<T extends ArrayBufferView> = {
+    buffer: ArrayBufferLike | null;
+    ptr: number;
+    len: number;
+    view: T | null;
+};
+export type RenderViewCache = {
+    codepoints: ViewEntry<Uint32Array>;
+    contentTags: ViewEntry<Uint8Array>;
+    wide: ViewEntry<Uint8Array>;
+    cellFlags: ViewEntry<Uint16Array>;
+    styleFlags: ViewEntry<Uint16Array>;
+    linkIds: ViewEntry<Uint32Array>;
+    fgBytes: ViewEntry<Uint8Array>;
+    bgBytes: ViewEntry<Uint8Array>;
+    ulBytes: ViewEntry<Uint8Array>;
+    ulStyle: ViewEntry<Uint8Array>;
+    linkOffsets: ViewEntry<Uint32Array>;
+    linkLengths: ViewEntry<Uint32Array>;
+    linkBuffer: ViewEntry<Uint8Array>;
+    graphemeOffset: ViewEntry<Uint32Array>;
+    graphemeLen: ViewEntry<Uint32Array>;
+    graphemeBuffer: ViewEntry<Uint32Array>;
+    selectionStart: ViewEntry<Int16Array>;
+    selectionEnd: ViewEntry<Int16Array>;
+};
+export type TypedArrayCtor<T extends ArrayBufferView> = new (buffer: ArrayBufferLike, byteOffset: number, length: number) => T;

package/dist/wasm/runtime/view-cache.d.ts

@@ -0,0 +1,4 @@
+import type { RenderViewCache, TypedArrayCtor, ViewEntry } from "./types";
+export declare function makeViewEntry<T extends ArrayBufferView>(): ViewEntry<T>;
+export declare function makeRenderViewCache(): RenderViewCache;
+export declare function getCachedView<T extends ArrayBufferView>(entry: ViewEntry<T>, buffer: ArrayBufferLike, ptr: number, len: number, Ctor: TypedArrayCtor<T>): T | null;

package/dist/xterm/app-options.d.ts

@@ -0,0 +1,2 @@
+import type { ResttyOptions } from "../surface/restty";
+export declare function createCompatAppOptions(userAppOptions: ResttyOptions["appOptions"], emitData: (data: string) => void): ResttyOptions["appOptions"];

package/dist/xterm/dimensions.d.ts

@@ -0,0 +1 @@
+export declare function normalizeDimension(value: number | undefined, fallback: number): number;

package/dist/xterm/listeners.d.ts

@@ -0,0 +1,5 @@
+export type Listener<T> = (payload: T) => void;
+export declare function addListener<T>(bucket: Set<Listener<T>>, listener: Listener<T>): {
+    dispose: () => void;
+};
+export declare function emitWithGuard<T>(bucket: Set<Listener<T>>, payload: T, label: "onData" | "onResize"): void;

package/dist/xterm.d.ts

@@ -1,4 +1,4 @@
-import { type Restty, type ResttyOptions } from "./app/restty";
+import { type Restty, type ResttyOptions } from "./surface/restty";
 export type IDisposable = {
     dispose: () => void;
 };
@@ -69,9 +69,4 @@ export declare class Terminal {
     dispose(): void;
     private ensureUsable;
     private applyOptions;
-    private createCompatAppOptions;
-    private emitData;
-    private emitResize;
-    private addListener;
-    private normalizeDimension;
 }

package/dist/xterm.js

@@ -1,6 +1,54 @@
 import {
   createRestty
-} from "./chunk-mkkhfg0z.js";
+} from "./chunk-pab3ge3d.js";
+
+// src/xterm/app-options.ts
+function createCompatAppOptions(userAppOptions, emitData) {
+  return (context) => {
+    const resolved = typeof userAppOptions === "function" ? userAppOptions(context) : userAppOptions ?? {};
+    const userBeforeInput = resolved.beforeInput;
+    return {
+      ...resolved,
+      beforeInput: ({ text, source }) => {
+        const maybeNext = userBeforeInput?.({ text, source });
+        if (maybeNext === null)
+          return null;
+        const nextText = maybeNext === undefined ? text : maybeNext;
+        if (source !== "pty" && nextText) {
+          emitData(nextText);
+        }
+        return nextText;
+      }
+    };
+  };
+}
+
+// src/xterm/dimensions.ts
+function normalizeDimension(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+    return fallback;
+  return Math.max(1, Math.trunc(value));
+}
+
+// src/xterm/listeners.ts
+function addListener(bucket, listener) {
+  bucket.add(listener);
+  return {
+    dispose: () => {
+      bucket.delete(listener);
+    }
+  };
+}
+function emitWithGuard(bucket, payload, label) {
+  const listeners = Array.from(bucket);
+  for (let i = 0;i < listeners.length; i += 1) {
+    try {
+      listeners[i](payload);
+    } catch (error) {
+      console.error(`[restty/xterm] ${label} listener error:`, error);
+    }
+  }
+}
 
 // src/xterm.ts
 class Terminal {
@@ -25,8 +73,8 @@ class Terminal {
     this.optionValues = { ...options };
     delete this.optionValues.cols;
     delete this.optionValues.rows;
-    this.cols = this.normalizeDimension(cols, 80);
-    this.rows = this.normalizeDimension(rows, 24);
+    this.cols = normalizeDimension(cols, 80);
+    this.rows = normalizeDimension(rows, 24);
     if (Number.isFinite(cols) && Number.isFinite(rows)) {
       this.pendingSize = { cols: this.cols, rows: this.rows };
     }
@@ -57,7 +105,9 @@ class Terminal {
     this.elementRef = parent;
     this.resttyInstance = createRestty({
       ...this.resttyOptionsBase,
-      appOptions: this.createCompatAppOptions(),
+      appOptions: createCompatAppOptions(this.userAppOptions, (data) => {
+        emitWithGuard(this.dataListeners, data, "onData");
+      }),
       root: parent
     });
     if (this.pendingSize) {
@@ -90,14 +140,14 @@ class Terminal {
   resize(cols, rows) {
     this.ensureUsable();
     const next = {
-      cols: this.normalizeDimension(cols, this.cols),
-      rows: this.normalizeDimension(rows, this.rows)
+      cols: normalizeDimension(cols, this.cols),
+      rows: normalizeDimension(rows, this.rows)
     };
     this.cols = next.cols;
     this.rows = next.rows;
     this.pendingSize = next;
     this.resttyInstance?.resize(next.cols, next.rows);
-    this.emitResize(next);
+    emitWithGuard(this.resizeListeners, next, "onResize");
   }
   focus() {
     if (this.disposed)
@@ -126,11 +176,11 @@ class Terminal {
   }
   onData(listener) {
     this.ensureUsable();
-    return this.addListener(this.dataListeners, listener);
+    return addListener(this.dataListeners, listener);
   }
   onResize(listener) {
     this.ensureUsable();
-    return this.addListener(this.resizeListeners, listener);
+    return addListener(this.resizeListeners, listener);
   }
   setOption(key, value) {
     this.ensureUsable();
@@ -184,8 +234,8 @@ class Terminal {
     const hasCols = Object.prototype.hasOwnProperty.call(next, "cols");
     const hasRows = Object.prototype.hasOwnProperty.call(next, "rows");
     if (hasCols || hasRows) {
-      const cols = hasCols ? this.normalizeDimension(next.cols, this.cols) : this.cols;
-      const rows = hasRows ? this.normalizeDimension(next.rows, this.rows) : this.rows;
+      const cols = hasCols ? normalizeDimension(next.cols, this.cols) : this.cols;
+      const rows = hasRows ? normalizeDimension(next.rows, this.rows) : this.rows;
       this.resize(cols, rows);
     }
     const keys = Object.keys(next);
@@ -196,58 +246,6 @@ class Terminal {
       this.optionValues[key] = next[key];
     }
   }
-  createCompatAppOptions() {
-    return (context) => {
-      const resolved = typeof this.userAppOptions === "function" ? this.userAppOptions(context) : this.userAppOptions ?? {};
-      const userBeforeInput = resolved.beforeInput;
-      return {
-        ...resolved,
-        beforeInput: ({ text, source }) => {
-          const maybeNext = userBeforeInput?.({ text, source });
-          if (maybeNext === null)
-            return null;
-          const nextText = maybeNext === undefined ? text : maybeNext;
-          if (source !== "pty" && nextText) {
-            this.emitData(nextText);
-          }
-          return nextText;
-        }
-      };
-    };
-  }
-  emitData(data) {
-    const listeners = Array.from(this.dataListeners);
-    for (let i = 0;i < listeners.length; i += 1) {
-      try {
-        listeners[i](data);
-      } catch (error) {
-        console.error("[restty/xterm] onData listener error:", error);
-      }
-    }
-  }
-  emitResize(size) {
-    const listeners = Array.from(this.resizeListeners);
-    for (let i = 0;i < listeners.length; i += 1) {
-      try {
-        listeners[i](size);
-      } catch (error) {
-        console.error("[restty/xterm] onResize listener error:", error);
-      }
-    }
-  }
-  addListener(bucket, listener) {
-    bucket.add(listener);
-    return {
-      dispose: () => {
-        bucket.delete(listener);
-      }
-    };
-  }
-  normalizeDimension(value, fallback) {
-    if (!Number.isFinite(value) || value <= 0)
-      return fallback;
-    return Math.max(1, Math.trunc(value));
-  }
 }
 export {
   Terminal