restty 0.1.21 → 0.1.23

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { Restty, ResttyPaneHandle, createRestty } from "./app/restty";
-export type { ResttyOptions, ResttyPaneApi } from "./app/restty";
+export { RESTTY_PLUGIN_API_VERSION, Restty, ResttyPaneHandle, createRestty } from "./app/restty";
+export type { ResttyOptions, ResttyPaneApi, ResttyPluginApiRange, ResttyPlugin, ResttyPluginCleanup, ResttyPluginContext, ResttyPluginDisposable, ResttyPluginEvents, ResttyPluginInfo, ResttyPluginRequires, ResttyInputInterceptor, ResttyInputInterceptorPayload, ResttyInterceptorOptions, ResttyLifecycleHook, ResttyLifecycleHookPayload, ResttyPluginLoadResult, ResttyPluginLoadStatus, ResttyPluginManifestEntry, ResttyPluginRegistry, ResttyPluginRegistryEntry, ResttyRenderHook, ResttyRenderHookPayload, ResttyOutputInterceptor, ResttyOutputInterceptorPayload, } from "./app/restty";
 export { getBuiltinTheme, getBuiltinThemeSource, isBuiltinThemeName, listBuiltinThemeNames, parseGhosttyTheme, } from "./theme";
 export type { GhosttyTheme, ResttyBuiltinThemeName } from "./theme";
 export type { ResttyFontSource, ResttyUrlFontSource, ResttyBufferFontSource, ResttyLocalFontSource, ResttyFontPreset, } from "./app/types";

package/dist/input/output.d.ts

@@ -1,4 +1,4 @@
-import type { CursorPosition, WindowOp } from "./types";
+import type { CellPosition, CursorPosition, WindowOp } from "./types";
 import type { MouseController } from "./mouse";
 /**
  * Construction options for OutputFilter.
@@ -50,6 +50,10 @@ export declare class OutputFilter {
     private clipboardWrite?;
     private clipboardRead?;
     private getDefaultColors?;
+    private semanticPromptSeen;
+    private promptClickEvents;
+    private promptInputActive;
+    private commandRunning;
     constructor(options: OutputFilterOptions);
     setCursorProvider(fn: () => CursorPosition): void;
     setReplySink(fn: (data: string) => void): void;
@@ -58,6 +62,11 @@ export declare class OutputFilter {
     isBracketedPaste(): boolean;
     isFocusReporting(): boolean;
     isSynchronizedOutput(): boolean;
+    isPromptClickEventsEnabled(): boolean;
+    encodePromptClickEvent(cell: CellPosition): string;
+    private readOsc133BoolOption;
+    private observeSemanticPromptOsc;
+    private observeOsc;
     private replyOscColor;
     private handleOsc;
     private handleModeSeq;

package/dist/input/types.d.ts

@@ -160,6 +160,8 @@ export type InputHandler = {
     isFocusReporting: () => boolean;
     isAltScreen: () => boolean;
     isSynchronizedOutput: () => boolean;
+    isPromptClickEventsEnabled: () => boolean;
+    encodePromptClickEvent: (cell: CellPosition) => string;
     /**
      * Encode pointer input as terminal mouse events (SGR).
      */

package/dist/internal.js

@@ -89,7 +89,7 @@ import {
   updateComposition,
   updateGridState,
   updateImePosition
-} from "./chunk-ym658zhj.js";
+} from "./chunk-mkkhfg0z.js";
 // src/selection/selection.ts
 function createSelectionState() {
   return {

package/dist/restty.js

@@ -1,4 +1,5 @@
 import {
+  RESTTY_PLUGIN_API_VERSION,
   Restty,
   ResttyPaneHandle,
   createRestty,
@@ -7,7 +8,7 @@ import {
   isBuiltinThemeName,
   listBuiltinThemeNames,
   parseGhosttyTheme
-} from "./chunk-ym658zhj.js";
+} from "./chunk-mkkhfg0z.js";
 export {
   parseGhosttyTheme,
   listBuiltinThemeNames,
@@ -16,5 +17,6 @@ export {
   getBuiltinTheme,
   createRestty,
   ResttyPaneHandle,
-  Restty
+  Restty,
+  RESTTY_PLUGIN_API_VERSION
 };

package/dist/xterm.d.ts

@@ -0,0 +1,77 @@
+import { type Restty, type ResttyOptions } from "./app/restty";
+export type IDisposable = {
+    dispose: () => void;
+};
+export type TerminalResizeEvent = {
+    cols: number;
+    rows: number;
+};
+/**
+ * Subset of xterm.js addon contract supported by the restty compatibility layer.
+ */
+export type TerminalAddon = {
+    activate: (terminal: Terminal) => void;
+    dispose: () => void;
+};
+/**
+ * Options for the xterm compatibility terminal.
+ *
+ * `root` is intentionally omitted because xterm-style flow mounts via `open(element)`.
+ * Additional unknown keys are accepted for migration ergonomics and kept in
+ * the terminal option bag, but are not forwarded to restty internals.
+ */
+export type TerminalOptions = Omit<ResttyOptions, "root"> & {
+    cols?: number;
+    rows?: number;
+    [key: string]: unknown;
+};
+/**
+ * xterm.js-style compatibility wrapper backed by `Restty`.
+ *
+ * This intentionally implements a focused subset needed for migration.
+ */
+export declare class Terminal {
+    private readonly resttyOptionsBase;
+    private readonly userAppOptions;
+    private readonly addons;
+    private readonly pendingOutput;
+    private readonly dataListeners;
+    private readonly resizeListeners;
+    private readonly optionValues;
+    private resttyInstance;
+    private elementRef;
+    private disposed;
+    private opened;
+    private pendingSize;
+    cols: number;
+    rows: number;
+    constructor(options?: TerminalOptions);
+    /** Mounted root passed to `open`, null before mount/dispose. */
+    get element(): HTMLElement | null;
+    /** Underlying restty instance after `open`, null otherwise. */
+    get restty(): Restty | null;
+    /** xterm-like option bag (compat-focused subset). */
+    get options(): Record<string, unknown>;
+    set options(next: Record<string, unknown>);
+    open(parent: HTMLElement): void;
+    write(data: string, callback?: () => void): void;
+    writeln(data?: string, callback?: () => void): void;
+    resize(cols: number, rows: number): void;
+    focus(): void;
+    blur(): void;
+    clear(): void;
+    reset(): void;
+    onData(listener: (data: string) => void): IDisposable;
+    onResize(listener: (size: TerminalResizeEvent) => void): IDisposable;
+    setOption(key: string, value: unknown): void;
+    getOption(key: string): unknown;
+    loadAddon(addon: TerminalAddon): void;
+    dispose(): void;
+    private ensureUsable;
+    private applyOptions;
+    private createCompatAppOptions;
+    private emitData;
+    private emitResize;
+    private addListener;
+    private normalizeDimension;
+}

package/dist/xterm.js

@@ -0,0 +1,254 @@
+import {
+  createRestty
+} from "./chunk-mkkhfg0z.js";
+
+// src/xterm.ts
+class Terminal {
+  resttyOptionsBase;
+  userAppOptions;
+  addons = new Set;
+  pendingOutput = [];
+  dataListeners = new Set;
+  resizeListeners = new Set;
+  optionValues;
+  resttyInstance = null;
+  elementRef = null;
+  disposed = false;
+  opened = false;
+  pendingSize = null;
+  cols;
+  rows;
+  constructor(options = {}) {
+    const { cols, rows, appOptions, ...resttyOptionsBase } = options;
+    this.resttyOptionsBase = resttyOptionsBase;
+    this.userAppOptions = appOptions;
+    this.optionValues = { ...options };
+    delete this.optionValues.cols;
+    delete this.optionValues.rows;
+    this.cols = this.normalizeDimension(cols, 80);
+    this.rows = this.normalizeDimension(rows, 24);
+    if (Number.isFinite(cols) && Number.isFinite(rows)) {
+      this.pendingSize = { cols: this.cols, rows: this.rows };
+    }
+  }
+  get element() {
+    return this.elementRef;
+  }
+  get restty() {
+    return this.resttyInstance;
+  }
+  get options() {
+    return {
+      ...this.optionValues,
+      cols: this.cols,
+      rows: this.rows
+    };
+  }
+  set options(next) {
+    this.ensureUsable();
+    this.applyOptions(next);
+  }
+  open(parent) {
+    this.ensureUsable();
+    if (this.opened) {
+      throw new Error("xterm compatibility Terminal is already opened");
+    }
+    this.opened = true;
+    this.elementRef = parent;
+    this.resttyInstance = createRestty({
+      ...this.resttyOptionsBase,
+      appOptions: this.createCompatAppOptions(),
+      root: parent
+    });
+    if (this.pendingSize) {
+      this.resttyInstance.resize(this.pendingSize.cols, this.pendingSize.rows);
+    }
+    if (this.pendingOutput.length > 0) {
+      for (let i = 0;i < this.pendingOutput.length; i += 1) {
+        this.resttyInstance.sendInput(this.pendingOutput[i], "pty");
+      }
+      this.pendingOutput.length = 0;
+    }
+  }
+  write(data, callback) {
+    this.ensureUsable();
+    if (!data) {
+      callback?.();
+      return;
+    }
+    if (this.resttyInstance) {
+      this.resttyInstance.sendInput(data, "pty");
+    } else {
+      this.pendingOutput.push(data);
+    }
+    callback?.();
+  }
+  writeln(data = "", callback) {
+    this.write(`${data}\r
+`, callback);
+  }
+  resize(cols, rows) {
+    this.ensureUsable();
+    const next = {
+      cols: this.normalizeDimension(cols, this.cols),
+      rows: this.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);
+  }
+  focus() {
+    if (this.disposed)
+      return;
+    this.resttyInstance?.focus();
+  }
+  blur() {
+    if (this.disposed)
+      return;
+    this.resttyInstance?.blur();
+  }
+  clear() {
+    this.ensureUsable();
+    if (this.resttyInstance) {
+      this.resttyInstance.clearScreen();
+      return;
+    }
+    this.pendingOutput.length = 0;
+  }
+  reset() {
+    this.ensureUsable();
+    this.clear();
+    if (this.resttyInstance) {
+      this.resttyInstance.sendInput("\x1Bc", "pty");
+    }
+  }
+  onData(listener) {
+    this.ensureUsable();
+    return this.addListener(this.dataListeners, listener);
+  }
+  onResize(listener) {
+    this.ensureUsable();
+    return this.addListener(this.resizeListeners, listener);
+  }
+  setOption(key, value) {
+    this.ensureUsable();
+    this.applyOptions({ [key]: value });
+  }
+  getOption(key) {
+    if (key === "cols")
+      return this.cols;
+    if (key === "rows")
+      return this.rows;
+    return this.optionValues[key];
+  }
+  loadAddon(addon) {
+    this.ensureUsable();
+    if (!addon || typeof addon.activate !== "function" || typeof addon.dispose !== "function") {
+      throw new Error("xterm compatibility addon must define activate() and dispose()");
+    }
+    if (this.addons.has(addon))
+      return;
+    addon.activate(this);
+    this.addons.add(addon);
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    const addons = Array.from(this.addons);
+    this.addons.clear();
+    for (let i = 0;i < addons.length; i += 1) {
+      try {
+        addons[i].dispose();
+      } catch {}
+    }
+    this.pendingOutput.length = 0;
+    this.pendingSize = null;
+    this.opened = false;
+    this.elementRef = null;
+    this.dataListeners.clear();
+    this.resizeListeners.clear();
+    if (this.resttyInstance) {
+      this.resttyInstance.destroy();
+      this.resttyInstance = null;
+    }
+  }
+  ensureUsable() {
+    if (this.disposed) {
+      throw new Error("xterm compatibility Terminal is disposed");
+    }
+  }
+  applyOptions(next) {
+    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;
+      this.resize(cols, rows);
+    }
+    const keys = Object.keys(next);
+    for (let i = 0;i < keys.length; i += 1) {
+      const key = keys[i];
+      if (key === "cols" || key === "rows")
+        continue;
+      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
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "restty",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Browser terminal rendering library powered by WASM, WebGPU/WebGL2, and TypeScript text shaping.",
   "keywords": [
     "terminal",
@@ -46,6 +46,11 @@
       "types": "./dist/internal.d.ts",
       "import": "./dist/internal.js",
       "default": "./dist/internal.js"
+    },
+    "./xterm": {
+      "types": "./dist/xterm.d.ts",
+      "import": "./dist/xterm.js",
+      "default": "./dist/xterm.js"
     }
   },
   "scripts": {