restty 0.1.35 → 0.2.0

package/dist/fonts/local-font-access.types.d.ts

@@ -0,0 +1,19 @@
+export type LocalFontsPermissionDescriptor = PermissionDescriptor & {
+    name: "local-fonts";
+};
+export type LocalFontFaceData = {
+    family?: string;
+    fullName?: string;
+    postscriptName?: string;
+    blob: () => Promise<Blob>;
+};
+export type NavigatorWithLocalFontAccess = Navigator & {
+    queryLocalFonts?: () => Promise<LocalFontFaceData[]>;
+    permissions?: {
+        query?: (permissionDesc: LocalFontsPermissionDescriptor) => Promise<PermissionStatus>;
+    };
+};
+export type GlobalWithLocalFontAccess = typeof globalThis & {
+    queryLocalFonts?: () => Promise<LocalFontFaceData[]>;
+    navigator?: NavigatorWithLocalFontAccess;
+};

package/dist/fonts/manager/entries.d.ts

@@ -9,5 +9,12 @@ export declare function createFontManagerState(): FontManagerState;
 export declare function fontHasGlyph(font: Font, ch: string): boolean;
 /** Get the horizontal advance width in font design units, computing and caching it if needed. */
 export declare function fontAdvanceUnits(entry: FontEntry, shapeClusterWithFont: (entry: FontEntry, text: string) => ShapedCluster): number;
+/**
+ * Scale (pixels per font unit) that renders a fallback font at the primary
+ * font's em size, matching Ghostty's rule of loading every face at the same
+ * point size. Returns 0 when either font lacks a usable unitsPerEm (for
+ * example bitmap fonts), so callers can fall back to size-mode scaling.
+ */
+export declare function fallbackEmScale(primaryFont: Font | null | undefined, primaryScale: number, fallbackFont: Font | null | undefined): number;
 /** Get the bounding-box width of a glyph in font design units, with caching. */
 export declare function glyphWidthUnits(entry: FontEntry, glyphId: number | undefined | null): number;

package/dist/headless.d.ts

@@ -0,0 +1,102 @@
+import type { KittyPlacement, RenderState, ResttyWasmOptions, SearchStatus, SearchViewportMatch } from "./wasm";
+import type { ResttyWasm } from "./wasm";
+export type ResttyHeadlessInput = string | ArrayBuffer | ArrayBufferView;
+export type ResttyHeadlessReplayOptions = {
+    /** Maximum replay journal size in UTF-8 bytes. Default: 10MB. */
+    maxBytes?: number;
+};
+export type ResttyHeadlessReplayWriteEvent = {
+    type: "write";
+    data: string;
+    byteLength: number;
+};
+export type ResttyHeadlessReplayResizeEvent = {
+    type: "resize";
+    cols: number;
+    rows: number;
+};
+export type ResttyHeadlessReplayEvent = ResttyHeadlessReplayWriteEvent | ResttyHeadlessReplayResizeEvent;
+export type ResttyHeadlessTerminalOptions = {
+    /** Initial terminal width in columns. Default: 80. */
+    cols?: number;
+    /** Initial terminal height in rows. Default: 24. */
+    rows?: number;
+    /** Maximum scrollback buffer size in bytes. Default: 10MB. */
+    maxScrollbackBytes?: number;
+    /** Initial pixel width used by protocols such as Kitty graphics. */
+    pixelWidth?: number;
+    /** Initial pixel height used by protocols such as Kitty graphics. */
+    pixelHeight?: number;
+    /**
+     * Replay journal config. Set to false when reconnect replay is not needed.
+     * The journal is a bounded input replay stream, not a binary terminal-state snapshot.
+     */
+    replay?: false | ResttyHeadlessReplayOptions;
+    /** Reuse an existing WASM runtime instance. */
+    wasm?: ResttyWasm;
+    /** WASM loader options used when wasm is not provided. */
+    wasmOptions?: ResttyWasmOptions;
+};
+export type ResttyHeadlessReplay = {
+    kind: "restty-headless-replay";
+    version: 1;
+    initialCols: number;
+    initialRows: number;
+    cols: number;
+    rows: number;
+    events: ResttyHeadlessReplayEvent[];
+    data: string;
+    byteLength: number;
+    truncated: boolean;
+};
+export type ResttyHeadlessSnapshot = RenderState;
+export type ResttyHeadlessWriteOptions = {
+    recordReplay?: boolean;
+};
+export type ResttyHeadlessApplyReplayOptions = {
+    resize?: boolean;
+};
+export declare class ResttyHeadlessTerminal {
+    readonly wasm: ResttyWasm;
+    private wasmHandle;
+    private replayEnabled;
+    private replayMaxBytes;
+    private replayEvents;
+    private replayByteLength;
+    private replayTruncated;
+    private replayStartCols;
+    private replayStartRows;
+    private disposed;
+    cols: number;
+    rows: number;
+    constructor(wasm: ResttyWasm, options?: ResttyHeadlessTerminalOptions);
+    get handle(): number;
+    write(input: ResttyHeadlessInput, options?: ResttyHeadlessWriteOptions): void;
+    writeln(input?: ResttyHeadlessInput): void;
+    resize(cols: number, rows: number): void;
+    private applyResize;
+    setPixelSize(widthPx: number, heightPx: number): void;
+    renderUpdate(): void;
+    getRenderState(): RenderState | null;
+    snapshot(): ResttyHeadlessSnapshot | null;
+    drainOutput(): string;
+    getKittyKeyboardFlags(): number;
+    getKittyPlacements(): KittyPlacement[];
+    scrollViewport(delta: number): void;
+    setSearchQuery(query: string): void;
+    clearSearch(): void;
+    stepSearch(budget?: number): void;
+    searchNext(): void;
+    searchPrevious(): void;
+    getSearchStatus(): SearchStatus;
+    getSearchViewportMatches(): SearchViewportMatch[];
+    createReplay(): ResttyHeadlessReplay;
+    applyReplay(replay: ResttyHeadlessReplay | string, options?: ResttyHeadlessApplyReplayOptions): void;
+    clearReplay(): void;
+    dispose(): void;
+    private appendReplay;
+    private appendReplayResize;
+    private replaceReplay;
+    private assertUsable;
+}
+export declare function createHeadlessTerminal(options?: ResttyHeadlessTerminalOptions): Promise<ResttyHeadlessTerminal>;

package/dist/headless.js

@@ -0,0 +1,350 @@
+import {
+  loadResttyWasm
+} from "./chunk-s26trws6.js";
+
+// src/headless.ts
+var DEFAULT_COLS = 80;
+var DEFAULT_ROWS = 24;
+var DEFAULT_MAX_SCROLLBACK_BYTES = 1e7;
+var MAX_MAX_SCROLLBACK_BYTES = 256000000;
+var DEFAULT_REPLAY_MAX_BYTES = 1e7;
+var HARD_RESET_SEQUENCE = "\x1Bc";
+var textDecoder = new TextDecoder;
+var textEncoder = new TextEncoder;
+function normalizePositiveInt(value, fallback) {
+  if (!Number.isFinite(value))
+    return fallback;
+  const asInt = Math.trunc(Number(value));
+  return asInt > 0 ? asInt : fallback;
+}
+function normalizeMaxBytes(value, fallback) {
+  if (!Number.isFinite(value))
+    return fallback;
+  const asInt = Math.trunc(Number(value));
+  if (asInt <= 0)
+    return 0;
+  return Math.min(asInt, MAX_MAX_SCROLLBACK_BYTES);
+}
+function decodeInput(input) {
+  if (typeof input === "string")
+    return input;
+  return textDecoder.decode(input);
+}
+function copyCursor(cursor) {
+  return cursor ? { ...cursor } : null;
+}
+function copyRenderState(state) {
+  if (!state)
+    return null;
+  return {
+    rows: state.rows,
+    cols: state.cols,
+    cellCount: state.cellCount,
+    codepoints: state.codepoints ? new Uint32Array(state.codepoints) : null,
+    contentTags: state.contentTags ? new Uint8Array(state.contentTags) : null,
+    wide: state.wide ? new Uint8Array(state.wide) : null,
+    cellFlags: state.cellFlags ? new Uint16Array(state.cellFlags) : null,
+    styleFlags: state.styleFlags ? new Uint16Array(state.styleFlags) : null,
+    linkIds: state.linkIds ? new Uint32Array(state.linkIds) : null,
+    fgBytes: state.fgBytes ? new Uint8Array(state.fgBytes) : null,
+    bgBytes: state.bgBytes ? new Uint8Array(state.bgBytes) : null,
+    ulBytes: state.ulBytes ? new Uint8Array(state.ulBytes) : null,
+    ulStyle: state.ulStyle ? new Uint8Array(state.ulStyle) : null,
+    linkOffsets: state.linkOffsets ? new Uint32Array(state.linkOffsets) : null,
+    linkLengths: state.linkLengths ? new Uint32Array(state.linkLengths) : null,
+    linkBuffer: state.linkBuffer ? new Uint8Array(state.linkBuffer) : null,
+    graphemeOffset: state.graphemeOffset ? new Uint32Array(state.graphemeOffset) : null,
+    graphemeLen: state.graphemeLen ? new Uint32Array(state.graphemeLen) : null,
+    graphemeBuffer: state.graphemeBuffer ? new Uint32Array(state.graphemeBuffer) : null,
+    selectionStart: state.selectionStart ? new Int16Array(state.selectionStart) : null,
+    selectionEnd: state.selectionEnd ? new Int16Array(state.selectionEnd) : null,
+    cursor: copyCursor(state.cursor)
+  };
+}
+
+class ResttyHeadlessTerminal {
+  wasm;
+  wasmHandle;
+  replayEnabled;
+  replayMaxBytes;
+  replayEvents = [];
+  replayByteLength = 0;
+  replayTruncated = false;
+  replayStartCols;
+  replayStartRows;
+  disposed = false;
+  cols;
+  rows;
+  constructor(wasm, options = {}) {
+    this.wasm = wasm;
+    this.cols = normalizePositiveInt(options.cols, DEFAULT_COLS);
+    this.rows = normalizePositiveInt(options.rows, DEFAULT_ROWS);
+    const maxScrollbackBytes = normalizeMaxBytes(options.maxScrollbackBytes, DEFAULT_MAX_SCROLLBACK_BYTES);
+    const replayOptions = options.replay === false ? null : options.replay ?? {};
+    this.replayEnabled = !!replayOptions;
+    this.replayMaxBytes = replayOptions ? normalizeMaxBytes(replayOptions.maxBytes, DEFAULT_REPLAY_MAX_BYTES) : 0;
+    if (this.replayMaxBytes <= 0) {
+      this.replayEnabled = false;
+    }
+    this.wasmHandle = this.wasm.create(this.cols, this.rows, maxScrollbackBytes);
+    if (!this.wasmHandle) {
+      throw new Error("restty headless create failed (restty_create returned 0)");
+    }
+    this.replayStartCols = this.cols;
+    this.replayStartRows = this.rows;
+    if (options.pixelWidth !== undefined || options.pixelHeight !== undefined) {
+      this.setPixelSize(options.pixelWidth ?? 0, options.pixelHeight ?? 0);
+    }
+    this.renderUpdate();
+  }
+  get handle() {
+    return this.wasmHandle;
+  }
+  write(input, options = {}) {
+    this.assertUsable();
+    const text = decodeInput(input);
+    if (!text)
+      return;
+    if (options.recordReplay !== false) {
+      this.appendReplay(text);
+    }
+    this.wasm.write(this.wasmHandle, text);
+    this.renderUpdate();
+  }
+  writeln(input = "") {
+    this.write(`${decodeInput(input)}\r
+`);
+  }
+  resize(cols, rows) {
+    this.applyResize(cols, rows);
+  }
+  applyResize(cols, rows, options = {}) {
+    this.assertUsable();
+    const previousCols = this.cols;
+    const previousRows = this.rows;
+    this.cols = normalizePositiveInt(cols, this.cols);
+    this.rows = normalizePositiveInt(rows, this.rows);
+    this.wasm.resize(this.wasmHandle, this.cols, this.rows);
+    if (options.recordReplay !== false && (this.cols !== previousCols || this.rows !== previousRows)) {
+      this.appendReplayResize(this.cols, this.rows);
+    }
+    this.renderUpdate();
+  }
+  setPixelSize(widthPx, heightPx) {
+    this.assertUsable();
+    this.wasm.setPixelSize(this.wasmHandle, Math.max(0, Math.trunc(Number(widthPx) || 0)), Math.max(0, Math.trunc(Number(heightPx) || 0)));
+  }
+  renderUpdate() {
+    this.assertUsable();
+    this.wasm.renderUpdate(this.wasmHandle);
+  }
+  getRenderState() {
+    this.assertUsable();
+    return this.wasm.getRenderState(this.wasmHandle);
+  }
+  snapshot() {
+    return copyRenderState(this.getRenderState());
+  }
+  drainOutput() {
+    this.assertUsable();
+    return this.wasm.drainOutput(this.wasmHandle);
+  }
+  getKittyKeyboardFlags() {
+    this.assertUsable();
+    return this.wasm.getKittyKeyboardFlags(this.wasmHandle);
+  }
+  getKittyPlacements() {
+    this.assertUsable();
+    return this.wasm.getKittyPlacements(this.wasmHandle);
+  }
+  scrollViewport(delta) {
+    this.assertUsable();
+    this.wasm.scrollViewport(this.wasmHandle, Math.trunc(delta));
+    this.renderUpdate();
+  }
+  setSearchQuery(query) {
+    this.assertUsable();
+    this.wasm.setSearchQuery(this.wasmHandle, query);
+  }
+  clearSearch() {
+    this.assertUsable();
+    this.wasm.clearSearch(this.wasmHandle);
+    this.renderUpdate();
+  }
+  stepSearch(budget = 1000) {
+    this.assertUsable();
+    this.wasm.stepSearch(this.wasmHandle, budget);
+  }
+  searchNext() {
+    this.assertUsable();
+    this.wasm.searchNext(this.wasmHandle);
+    this.renderUpdate();
+  }
+  searchPrevious() {
+    this.assertUsable();
+    this.wasm.searchPrevious(this.wasmHandle);
+    this.renderUpdate();
+  }
+  getSearchStatus() {
+    this.assertUsable();
+    return this.wasm.getSearchStatus(this.wasmHandle);
+  }
+  getSearchViewportMatches() {
+    this.assertUsable();
+    return this.wasm.getSearchViewportMatches(this.wasmHandle);
+  }
+  createReplay() {
+    this.assertUsable();
+    const events = this.replayEvents.map((event) => ({ ...event }));
+    const data = events.filter((event) => event.type === "write").map((event) => event.data).join("");
+    return {
+      kind: "restty-headless-replay",
+      version: 1,
+      initialCols: this.replayStartCols,
+      initialRows: this.replayStartRows,
+      cols: this.cols,
+      rows: this.rows,
+      events,
+      data,
+      byteLength: this.replayByteLength,
+      truncated: this.replayTruncated
+    };
+  }
+  applyReplay(replay, options = {}) {
+    this.assertUsable();
+    if (typeof replay === "string") {
+      if (replay) {
+        this.write(replay, { recordReplay: false });
+      }
+      this.replaceReplay(replay, false);
+      return;
+    }
+    const shouldResize = options.resize !== false;
+    const events = replay.events?.length ? replay.events : [
+      {
+        type: "write",
+        data: replay.data,
+        byteLength: replay.byteLength
+      }
+    ];
+    if (shouldResize) {
+      this.applyResize(replay.initialCols ?? replay.cols, replay.initialRows ?? replay.rows, {
+        recordReplay: false
+      });
+    }
+    for (const event of events) {
+      if (event.type === "resize") {
+        if (shouldResize) {
+          this.applyResize(event.cols, event.rows, { recordReplay: false });
+        }
+        continue;
+      }
+      if (event.data) {
+        this.write(event.data, { recordReplay: false });
+      }
+    }
+    if (shouldResize && (this.cols !== replay.cols || this.rows !== replay.rows)) {
+      this.applyResize(replay.cols, replay.rows, { recordReplay: false });
+    }
+    this.replaceReplay(replay);
+  }
+  clearReplay() {
+    this.replayEvents = [];
+    this.replayByteLength = 0;
+    this.replayTruncated = false;
+    this.replayStartCols = this.cols;
+    this.replayStartRows = this.rows;
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    if (this.wasmHandle) {
+      this.wasm.destroy(this.wasmHandle);
+      this.wasmHandle = 0;
+    }
+    this.clearReplay();
+  }
+  appendReplay(text) {
+    if (!this.replayEnabled || !text)
+      return;
+    const hardResetIndex = text.lastIndexOf(HARD_RESET_SEQUENCE);
+    const replayText = hardResetIndex >= 0 ? text.slice(hardResetIndex) : text;
+    if (hardResetIndex >= 0) {
+      this.clearReplay();
+    }
+    const byteLength = textEncoder.encode(replayText).byteLength;
+    if (byteLength > this.replayMaxBytes) {
+      this.clearReplay();
+      this.replayTruncated = true;
+      return;
+    }
+    while (this.replayEvents.length > 0 && this.replayByteLength + byteLength > this.replayMaxBytes) {
+      const removed = this.replayEvents.shift();
+      if (removed?.type === "write") {
+        this.replayByteLength -= removed.byteLength;
+      }
+      this.replayTruncated = true;
+    }
+    this.replayEvents.push({ type: "write", data: replayText, byteLength });
+    this.replayByteLength += byteLength;
+  }
+  appendReplayResize(cols, rows) {
+    if (!this.replayEnabled)
+      return;
+    const previous = this.replayEvents.at(-1);
+    if (previous?.type === "resize") {
+      previous.cols = cols;
+      previous.rows = rows;
+      return;
+    }
+    this.replayEvents.push({ type: "resize", cols, rows });
+  }
+  replaceReplay(replay, truncated = false) {
+    if (!this.replayEnabled)
+      return;
+    if (typeof replay !== "string") {
+      const events = replay.events?.length ? replay.events : [
+        {
+          type: "write",
+          data: replay.data,
+          byteLength: replay.byteLength
+        }
+      ];
+      this.replayStartCols = replay.initialCols ?? replay.cols;
+      this.replayStartRows = replay.initialRows ?? replay.rows;
+      this.replayEvents = events.map((event) => ({ ...event }));
+      this.replayByteLength = this.replayEvents.reduce((sum, event) => sum + (event.type === "write" ? event.byteLength : 0), 0);
+      this.replayTruncated = replay.truncated || this.replayByteLength > this.replayMaxBytes;
+      if (this.replayByteLength <= this.replayMaxBytes)
+        return;
+      this.replayEvents = [];
+      this.replayByteLength = 0;
+      return;
+    }
+    this.clearReplay();
+    this.replayTruncated = truncated;
+    if (!replay)
+      return;
+    const byteLength = textEncoder.encode(replay).byteLength;
+    if (byteLength > this.replayMaxBytes) {
+      this.replayTruncated = true;
+      return;
+    }
+    this.replayEvents = [{ type: "write", data: replay, byteLength }];
+    this.replayByteLength = byteLength;
+  }
+  assertUsable() {
+    if (this.disposed || !this.wasmHandle) {
+      throw new Error("ResttyHeadlessTerminal is disposed");
+    }
+  }
+}
+async function createHeadlessTerminal(options = {}) {
+  const wasm = options.wasm ?? await loadResttyWasm(options.wasmOptions);
+  return new ResttyHeadlessTerminal(wasm, options);
+}
+export {
+  createHeadlessTerminal,
+  ResttyHeadlessTerminal
+};

package/dist/index.d.ts

@@ -1,7 +1,11 @@
 export { RESTTY_PLUGIN_API_VERSION, Restty, ResttyPaneHandle, createRestty, } from "./surface/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, ResttyRenderStageHandle, } from "./surface/restty";
-export type { ResttyManagedPaneSearchUiOptions, ResttyManagedPaneSearchUiStyleOptions, } from "./surface/pane-app-manager";
-export type { ResttyPaneSearchUiOpenOptions, ResttyPaneSearchUiCloseOptions, } from "./surface/pane-search-ui";
+export type { ResttyConfig, ResttyServicesConfig, ResttySurfaceConfig, ResttySurfaceEvents, ResttySurfacePane, ResttyPaneApi, ResttyPluginApiRange, ResttyPlugin, ResttyPluginCleanup, ResttyPluginContext, ResttyPluginDisposable, ResttyPluginHostApi, ResttyPluginEvents, ResttyPluginInfo, ResttyPluginRequires, ResttyInputInterceptor, ResttyInputInterceptorPayload, ResttyInterceptorOptions, ResttyLifecycleHook, ResttyLifecycleHookPayload, ResttyPluginLoadResult, ResttyPluginLoadStatus, ResttyPluginManifestEntry, ResttyPluginRegistry, ResttyPluginRegistryEntry, ResttyRenderHook, ResttyRenderHookPayload, ResttyOutputInterceptor, ResttyOutputInterceptorPayload, ResttyRenderStageHandle, } from "./surface/restty";
+export type { ResttyManagedPaneSearchUiOptions, ResttyManagedPaneSearchUiStyleOptions, } from "./surface/panes/managed-pane-types";
+export type { ResttyPaneSearchUiOpenOptions, ResttyPaneSearchUiCloseOptions, } from "./surface/search-ui";
 export { getBuiltinTheme, getBuiltinThemeSource, isBuiltinThemeName, listBuiltinThemeNames, parseGhosttyTheme, } from "./theme";
 export type { GhosttyTheme, ResttyBuiltinThemeName } from "./theme";
-export type { ResttyFontHintTarget, ResttyFontSource, ResttyUrlFontSource, ResttyBufferFontSource, ResttyLocalFontSource, ResttyFontPreset, ResttyShaderStage, ResttyShaderStageMode, ResttyShaderStageBackend, ResttyShaderStageSource, } from "./runtime/types";
+export type { ResttyFontData, ResttyFontHintTarget, ResttyFontInput, ResttyFontUrlInput, ResttyFontPathInput, ResttyFontBufferInput, ResttyFontFamilyInput, ResttyFontFallbackInput, ResttyFontStyle, ResttyLocalFontMode, ResttyShaderStage, ResttyShaderStageMode, ResttyShaderStageBackend, ResttyShaderStageSource, } from "./runtime/core/models";
+export type { ResttyTerminalConfig, ResttyRuntimeMountConfig, ResttyRuntimeServicesConfig, ResttyRuntimeConfig, } from "./runtime/core/config";
+export type { ResttyRuntimeEvent, ResttyRuntimeLifecycleState } from "./runtime/types";
+export { createWebSocketPtyTransport } from "./pty";
+export type { PtyCallbacks, PtyConnectOptions, PtyResizeMeta, PtyTransport } from "./pty";

package/dist/input/keymap/default-mapping.d.ts

@@ -1 +1,2 @@
+export declare function encodeCommandNavigationKeyEvent(event: KeyboardEvent): string;
 export declare function encodeDefaultKeyEvent(event: KeyboardEvent): string;

package/dist/input/mouse.d.ts

@@ -12,6 +12,14 @@ export type MouseControllerOptions = {
         x: number;
         y: number;
     };
+    /** Provide cell metrics in CSS pixels for wheel delta accumulation. */
+    getWheelCellMetrics?: () => WheelCellMetrics | null;
+};
+export type WheelCellMetrics = {
+    cellWidth: number;
+    cellHeight: number;
+    rows: number;
+    cols: number;
 };
 /**
  * Tracks mouse reporting state (mode, format, motion tracking) and encodes
@@ -26,9 +34,12 @@ export declare class MouseController {
     private button;
     private flags;
     private x10Event;
+    private pendingWheelX;
+    private pendingWheelY;
     private sendReply;
     private positionToCell;
     private positionToPixel?;
+    private getWheelCellMetrics?;
     constructor(options: MouseControllerOptions);
     setReplySink(fn: (data: string) => void): void;
     setPositionToCell(fn: (event: MouseEvent | PointerEvent | WheelEvent) => CellPosition): void;
@@ -36,11 +47,13 @@ export declare class MouseController {
         x: number;
         y: number;
     }): void;
+    setWheelCellMetricsProvider(fn: () => WheelCellMetrics | null): void;
     setMode(mode: MouseMode): void;
     handleModeSeq(seq: string): boolean;
     isActive(): boolean;
     getStatus(): MouseStatus;
     sendMouseEvent(kind: "down" | "up" | "move" | "wheel", event: PointerEvent | WheelEvent): boolean;
+    private consumeWheelDelta;
     private updateFlags;
     private isX10EventMode;
     private modifiers;

package/dist/input/types.d.ts

@@ -95,6 +95,15 @@ export type InputHandlerOptions = {
         x: number;
         y: number;
     };
+    /**
+     * Provide cell metrics in CSS pixels for wheel delta accumulation.
+     */
+    getWheelCellMetrics?: () => {
+        cellWidth: number;
+        cellHeight: number;
+        rows: number;
+        cols: number;
+    } | null;
     /**
      * Provide default colors for OSC 10/11/12 queries (RGB 0-255).
      */
@@ -122,7 +131,7 @@ export type InputHandlerOptions = {
     getKittyKeyboardFlags?: () => number;
 };
 /**
- * Exposed mouse status for UI debugging.
+ * Exposed mouse status for UI displays.
  */
 export type MouseStatus = {
     mode: MouseMode;

package/dist/internal/runtime.d.ts

@@ -0,0 +1,4 @@
+export { createResttyRuntime, createResttyRuntimeSession, getDefaultResttyRuntimeSession, } from "../runtime/create-runtime";
+export type { ResttyRuntimeCallbacks, ResttyFontData, ResttyFontInput, ResttyFontUrlInput, ResttyFontPathInput, ResttyFontBufferInput, ResttyFontFamilyInput, ResttyFontFallbackInput, ResttyFontStyle, ResttyLocalFontMode, ResttyFontHintTarget, ResttyTouchSelectionMode, ResttyWasmLogListener, ResttyRuntimeSession, ResttyRuntimeInputPayload, ResttyRuntimeEvent, ResttyRuntimeLifecycleState, ResttyRuntimeConfig, ResttyRuntime, } from "../runtime/create-runtime";
+export type { ResttyShaderStage, ResttyShaderStageMode, ResttyShaderStageBackend, ResttyShaderStageSource, } from "../runtime/core/models";
+export type { ResttyTerminalConfig, ResttyRuntimeMountConfig, ResttyRuntimeServicesConfig, } from "../runtime/core/config";

package/dist/internal/runtime.js

@@ -0,0 +1,12 @@
+import"../chunk-30px21q2.js";
+import {
+  createResttyRuntime,
+  createResttyRuntimeSession,
+  getDefaultResttyRuntimeSession
+} from "../chunk-db9dt7pr.js";
+import"../chunk-s26trws6.js";
+export {
+  getDefaultResttyRuntimeSession,
+  createResttyRuntimeSession,
+  createResttyRuntime
+};

package/dist/internal/surface.d.ts

@@ -0,0 +1,6 @@
+export { createResttyPaneManager } from "../surface/panes/manager";
+export { createDefaultResttyPaneContextMenuItems, getResttyShortcutModifierLabel, } from "../surface/panes/default-context-menu-items";
+export type { ResttyPaneSplitDirection, ResttyPaneContextMenuItem, ResttyPaneDefinition, ResttyPaneStyleOptions, ResttyPaneStylesOptions, ResttyPaneShortcutsOptions, ResttyPaneContextMenuOptions, CreateResttyPaneManagerOptions, ResttyPaneManager, ResttyPaneWithRuntime, ResttyPaneWithRuntimeActions, ResttyPaneWithManagedRuntime, CreateDefaultResttyPaneContextMenuItemsOptions, } from "../surface/panes/types";
+export { createResttyManagedPaneManager } from "../surface/panes/managed-pane-manager";
+export type { CreateResttyManagedPaneManagerOptions, ResttyManagedPaneManager, ResttyDefaultPaneContextMenuOptions, ResttyManagedPane, ResttyPaneDomDefaults, ResttyManagedPaneStyleOptions, ResttyManagedPaneStylesOptions, ResttyManagedPaneSearchUiOptions, ResttyManagedPaneSearchUiStyleOptions, ResttyPaneRuntimeContext, ResttyTerminalConfigInput, ResttyRuntimeServicesConfigInput, } from "../surface/panes/managed-pane-types";
+export type { ResttyPaneSearchUiOpenOptions, ResttyPaneSearchUiCloseOptions, } from "../surface/search-ui";

package/dist/internal/surface.js

@@ -0,0 +1,15 @@
+import"../chunk-xykzfd81.js";
+import {
+  createDefaultResttyPaneContextMenuItems,
+  createResttyManagedPaneManager,
+  createResttyPaneManager,
+  getResttyShortcutModifierLabel
+} from "../chunk-y6hfk43b.js";
+import"../chunk-db9dt7pr.js";
+import"../chunk-s26trws6.js";
+export {
+  getResttyShortcutModifierLabel,
+  createResttyPaneManager,
+  createResttyManagedPaneManager,
+  createDefaultResttyPaneContextMenuItems
+};

package/dist/internal.d.ts

@@ -12,8 +12,5 @@ export { loadResttyWasm, ResttyWasm } from "./wasm";
 export type { WasmAbi, WasmAbiKind, CursorInfo, RenderState, ResttyWasmExports, ResttyWasmOptions, } from "./wasm";
 export { parseGhosttyTheme, parseGhosttyColor, colorToFloats, colorToRgbU32, listBuiltinThemeNames, isBuiltinThemeName, getBuiltinThemeSource, getBuiltinTheme, } from "./theme";
 export type { GhosttyTheme, ThemeColor, ResttyBuiltinThemeName } from "./theme";
-export { Restty } from "./surface/restty";
-export type { ResttyOptions } from "./surface/restty";
-export type { ResttyManagedAppPane, ResttyPaneDomDefaults, ResttyManagedPaneStyleOptions, ResttyManagedPaneStylesOptions, ResttyManagedPaneSearchUiOptions, ResttyManagedPaneSearchUiStyleOptions, ResttyPaneAppOptionsInput, } from "./surface/pane-app-manager";
-export type { ResttyPaneSearchUiOpenOptions, ResttyPaneSearchUiCloseOptions, } from "./surface/pane-search-ui";
-export type { ResttyFontHintTarget, ResttyFontSource, ResttyUrlFontSource, ResttyBufferFontSource, ResttyLocalFontSource, ResttyShaderStage, ResttyShaderStageMode, ResttyShaderStageBackend, ResttyShaderStageSource, } from "./runtime/types";
+export * from "./internal/runtime";
+export * from "./internal/surface";