restty 0.1.35 → 0.2.0

package/dist/restty.js

@@ -2,19 +2,25 @@ import {
   RESTTY_PLUGIN_API_VERSION,
   Restty,
   ResttyPaneHandle,
-  createRestty,
+  createRestty
+} from "./chunk-wdme6j9c.js";
+import"./chunk-y6hfk43b.js";
+import {
+  createWebSocketPtyTransport,
   getBuiltinTheme,
   getBuiltinThemeSource,
   isBuiltinThemeName,
   listBuiltinThemeNames,
   parseGhosttyTheme
-} from "./chunk-zqscavsh.js";
+} from "./chunk-db9dt7pr.js";
+import"./chunk-s26trws6.js";
 export {
   parseGhosttyTheme,
   listBuiltinThemeNames,
   isBuiltinThemeName,
   getBuiltinThemeSource,
   getBuiltinTheme,
+  createWebSocketPtyTransport,
   createRestty,
   ResttyPaneHandle,
   Restty,

package/dist/runtime/core/api.d.ts

@@ -0,0 +1,112 @@
+import type { InputHandler, MouseMode } from "../../input";
+import type { GhosttyTheme } from "../../theme";
+import type { ResttyRuntimeLifecycleState } from "./lifecycle";
+import type { ResttyRuntimeEvent } from "./runtime-events";
+import type { ResttyFontHintTarget, ResttyFontInput, ResttySearchState, ResttyShaderStage } from "./models";
+/**
+ * Public API for a single terminal runtime instance.
+ */
+export type ResttyRuntimeLifecycleApi = {
+    init: () => Promise<void>;
+    destroy: () => void;
+    state: () => ResttyRuntimeLifecycleState;
+};
+export type ResttyRuntimeEventsApi = {
+    /** Runtime lifecycle and state-change events. */
+    events: {
+        /** Subscribe to runtime lifecycle and state-change events. */
+        subscribe: (listener: (event: ResttyRuntimeEvent) => void) => () => void;
+    };
+};
+export type ResttyRuntimeTerminalApi = {
+    /** Switch the renderer backend at runtime. */
+    setRenderer: (value: "auto" | "webgpu" | "webgl2") => void;
+    /** Pause or resume rendering. */
+    setPaused: (value: boolean) => void;
+    /** Toggle the rendering pause state. */
+    togglePause: () => void;
+    /** Update the terminal font size in CSS pixels. */
+    setFontSize: (value: number) => void;
+    /** Enable or disable programming ligature shaping. */
+    setLigatures: (value: boolean) => void;
+    /** Enable or disable TrueType hinting for atlas glyph rasterization. */
+    setFontHinting: (value: boolean) => void;
+    /** Update hinting target mode used when hinting is enabled. */
+    setFontHintTarget: (value: ResttyFontHintTarget) => void;
+    /** Replace the active font list and reload fonts. */
+    setFonts: (fonts: ResttyFontInput[]) => Promise<void>;
+    /** Apply a Ghostty color theme. */
+    applyTheme: (theme: GhosttyTheme, sourceLabel?: string) => void;
+    /** Reset colors to the default theme. */
+    resetTheme: () => void;
+    /** Clear terminal scrollback and visible content. */
+    clearScreen: () => void;
+};
+export type ResttyRuntimeIoApi = {
+    /** Write raw text to the terminal PTY. */
+    sendInput: (text: string, source?: string) => void;
+    /** Encode and send a key sequence to the terminal PTY. */
+    sendKeyInput: (text: string, source?: string) => void;
+    /** Open a PTY connection, optionally to a specific URL. */
+    connectPty: (url?: string) => void;
+    /** Close the active PTY connection. */
+    disconnectPty: () => void;
+    /** Check whether the PTY transport is currently connected. */
+    isPtyConnected: () => boolean;
+};
+export type ResttyRuntimeInteractionApi = {
+    /** Override the mouse reporting mode. */
+    setMouseMode: (value: MouseMode) => void;
+    /** Return current mouse reporting status. */
+    getMouseStatus: () => ReturnType<InputHandler["getMouseStatus"]>;
+    /** Copy the current text selection to the clipboard. */
+    copySelectionToClipboard: () => Promise<boolean>;
+    /** Paste clipboard contents into the terminal. */
+    pasteFromClipboard: () => Promise<boolean>;
+    /** Select the word at a viewport client coordinate. */
+    selectWordAtClientPoint: (clientX: number, clientY: number) => boolean;
+    /** Resize terminal grid to explicit columns/rows. */
+    resize: (cols: number, rows: number) => void;
+    /** Focus terminal input targets. */
+    focus: () => void;
+    /** Blur terminal input targets. */
+    blur: () => void;
+    /** Recalculate terminal dimensions from the canvas size. */
+    updateSize: (force?: boolean) => void;
+};
+export type ResttyRuntimeSearchApi = {
+    /** Update the active terminal search query. */
+    setQuery: (query: string) => void;
+    /** Clear terminal search state and visible highlights. */
+    clear: () => void;
+    /** Navigate to the next terminal search match. */
+    next: () => void;
+    /** Navigate to the previous terminal search match. */
+    previous: () => void;
+    /** Get the current terminal search state. */
+    getState: () => ResttySearchState;
+};
+export type ResttyRuntimeRenderApi = {
+    /** 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[];
+};
+export type ResttyRuntimeLifecycleView = {
+    init: ResttyRuntimeLifecycleApi["init"];
+    destroy: ResttyRuntimeLifecycleApi["destroy"];
+    state: ResttyRuntimeLifecycleApi["state"];
+};
+export type ResttyRuntimeEventsView = ResttyRuntimeEventsApi["events"];
+export type ResttyRuntimeGroupedApi = {
+    lifecycle: ResttyRuntimeLifecycleView;
+    events: ResttyRuntimeEventsView;
+    terminal: ResttyRuntimeTerminalApi;
+    io: ResttyRuntimeIoApi;
+    interaction: ResttyRuntimeInteractionApi;
+    search: ResttyRuntimeSearchApi;
+    render: ResttyRuntimeRenderApi;
+};
+export type ResttyRuntime = ResttyRuntimeGroupedApi;

package/dist/runtime/core/config.d.ts

@@ -0,0 +1,133 @@
+import type { PtyTransport } from "../../pty";
+import type { ResttyRuntimeInputPayload, ResttyFontHintTarget, ResttyFontInput, ResttyShaderStage, ResttyTouchSelectionMode } from "./models";
+import type { ResttyRuntimeCallbacks, ResttyRuntimeSession } from "./resources";
+import type { GhosttyTheme } from "../../theme";
+/**
+ * DOM/session fields required to mount a runtime instance.
+ */
+export type ResttyRuntimeMountConfig = {
+    /** Target canvas element for terminal rendering. */
+    canvas: HTMLCanvasElement;
+    /** Shared session for WASM/WebGPU resource reuse across panes. */
+    session?: ResttyRuntimeSession;
+    /** Hidden textarea for IME composition input. */
+    imeInput?: HTMLTextAreaElement | null;
+};
+/**
+ * Advanced runtime service hooks and adapters.
+ */
+export type ResttyRuntimeServicesConfig = {
+    /** Callbacks for state-change notifications. */
+    callbacks?: ResttyRuntimeCallbacks;
+    /** PTY transport layer for terminal I/O. */
+    ptyTransport?: PtyTransport;
+    /**
+     * Optional hook to transform or suppress terminal/program input
+     * before it is written to the terminal core.
+     */
+    beforeInput?: (payload: ResttyRuntimeInputPayload) => string | null | void;
+    /**
+     * Optional hook to transform or suppress PTY output before it is
+     * queued for rendering.
+     */
+    beforeRenderOutput?: (payload: ResttyRuntimeInputPayload) => string | null | void;
+};
+/**
+ * Terminal behavior/config shared across panes and runtime creation.
+ */
+export type ResttyTerminalConfig = {
+    /** Renderer backend preference (default "auto"). */
+    renderer?: "auto" | "webgpu" | "webgl2";
+    /** Font size in CSS pixels. */
+    fontSize?: number;
+    /** Enable programming ligature shaping across adjacent operator cells (default true). */
+    ligatures?: boolean;
+    /** Enable TrueType hinting during atlas rasterization (default false). */
+    fontHinting?: boolean;
+    /**
+     * Hinting target mode passed to text-shaper when hinting is enabled.
+     * - auto: infer from pixel mode
+     * - light: prefer light/subpixel-like vertical hinting
+     * - normal: prefer full hinting
+     */
+    fontHintTarget?: ResttyFontHintTarget;
+    /**
+     * Font sizing mode used by text-shaper scale resolution.
+     * - em: interpret fontSize as EM size
+     * - height: interpret fontSize as full font height (ascender-descender-lineGap)
+     */
+    fontSizeMode?: "em" | "height";
+    /**
+     * Alpha blending strategy.
+     * - native: GPU-native premultiplied alpha
+     * - linear: linear-space blending
+     * - linear-corrected: linear-space with gamma correction
+     */
+    alphaBlending?: "native" | "linear" | "linear-corrected";
+    /** Ordered terminal fonts. Omit to use the built-in local-first fallback chain. */
+    fonts?: ResttyFontInput[];
+    /** Initial Ghostty-compatible color theme applied before the runtime becomes ready. */
+    theme?: GhosttyTheme;
+    /** Maximum scale factor for the symbol atlas texture. */
+    maxSymbolAtlasScale?: number;
+    /** Per-glyph scale overrides matched by regex. */
+    fontScaleOverrides?: {
+        match: RegExp;
+        scale: number;
+    }[];
+    /** Scale factor applied to Nerd Font icons. */
+    nerdIconScale?: number;
+    /** Automatically resize the terminal on container/window changes (default true). */
+    autoResize?: boolean;
+    /** Show the centered cols x rows badge while resizing (default true). */
+    showResizeOverlay?: boolean;
+    /**
+     * Forward terminal-generated reply bytes to the PTY transport (default true).
+     * Set false when a backend/headless terminal is authoritative for replies.
+     */
+    forwardTerminalReplies?: boolean;
+    /** Attach resize/focus listeners to the window object. */
+    attachWindowEvents?: boolean;
+    /** Attach pointer/keyboard listeners to the canvas. */
+    attachCanvasEvents?: boolean;
+    /**
+     * Touch selection behavior on pointerType=touch:
+     * - drag: immediate drag-selection (legacy behavior)
+     * - long-press: selection starts after press timeout (default)
+     * - off: disable touch selection, keep touch scrolling
+     */
+    touchSelectionMode?: ResttyTouchSelectionMode;
+    /**
+     * Long-press timeout in ms for touch selection intent.
+     * Only used when touchSelectionMode is "long-press".
+     */
+    touchSelectionLongPressMs?: number;
+    /**
+     * Pointer move threshold in CSS pixels before long-press selection is
+     * canceled and touch pan-scroll takes priority.
+     */
+    touchSelectionMoveThresholdPx?: number;
+    /** Optional render-stage shader chain. */
+    shaderStages?: ResttyShaderStage[];
+    /**
+     * Maximum scrollback buffer size in bytes passed to the WASM terminal.
+     * Default is 10_000_000 (10MB).
+     */
+    maxScrollbackBytes?: number;
+    /**
+     * Deprecated alias for maxScrollbackBytes.
+     * If both are set, maxScrollbackBytes takes precedence.
+     */
+    maxScrollback?: number;
+};
+/**
+ * Configuration for creating a Restty runtime instance.
+ */
+export type ResttyRuntimeConfig = {
+    /** DOM/session fields required to mount the runtime. */
+    mount: ResttyRuntimeMountConfig;
+    /** Terminal behavior/config applied to the runtime instance. */
+    terminal?: ResttyTerminalConfig;
+    /** Service hooks and adapters used by the runtime. */
+    services?: ResttyRuntimeServicesConfig;
+};

package/dist/runtime/core/lifecycle.d.ts

@@ -0,0 +1 @@
+export type ResttyRuntimeLifecycleState = "created" | "initializing" | "ready" | "failed" | "destroyed";

package/dist/runtime/core/models.d.ts

@@ -0,0 +1,124 @@
+import type { SearchViewportMatch } from "../../wasm";
+export type ResttySearchState = {
+    query: string;
+    active: boolean;
+    pending: boolean;
+    complete: boolean;
+    total: number;
+    selectedIndex: number | null;
+};
+export type ResttySearchViewportMatch = SearchViewportMatch;
+/** Raw font data as an ArrayBuffer or typed-array view. */
+export type ResttyFontData = ArrayBuffer | ArrayBufferView;
+/** Font style metadata used for local matching and face labels. */
+export type ResttyFontStyle = "normal" | "italic" | "oblique";
+/** Local Font Access behavior for family-based inputs. */
+export type ResttyLocalFontMode = "prefer" | "require";
+/** Font loaded from a URL or app-relative path. */
+export type ResttyFontUrlInput = {
+    url: string | URL;
+    name?: string;
+    weight?: number;
+    style?: ResttyFontStyle;
+};
+/** Font loaded from an app-relative path. */
+export type ResttyFontPathInput = {
+    path: string;
+    name?: string;
+    weight?: number;
+    style?: ResttyFontStyle;
+};
+/** Font loaded from an in-memory buffer. */
+export type ResttyFontBufferInput = {
+    data: ResttyFontData;
+    name?: string;
+    weight?: number;
+    style?: ResttyFontStyle;
+};
+/** Non-family font inputs that can be used as fallbacks. */
+export type ResttyFontFallbackInput = string | URL | ResttyFontData | ResttyFontUrlInput | ResttyFontPathInput | ResttyFontBufferInput;
+/**
+ * Font resolved by family name through Local Font Access, optionally falling
+ * back to a URL/path/buffer when the local face is unavailable.
+ */
+export type ResttyFontFamilyInput = {
+    family: string;
+    local?: ResttyLocalFontMode;
+    fallback?: ResttyFontFallbackInput;
+    name?: string;
+    weight?: number;
+    style?: ResttyFontStyle;
+};
+/**
+ * Public font input accepted by runtime and surface APIs.
+ * - string/URL/path: fetched directly when URL-like, otherwise treated as a local family
+ * - buffer/data: parsed from memory
+ * - family: tries Local Font Access, with optional fallback
+ */
+export type ResttyFontInput = ResttyFontFallbackInput | ResttyFontFamilyInput;
+/** Internal resolved source consumed by the runtime font resource store. */
+export type ResttyResolvedFontSource = {
+    kind: "url";
+    url: string;
+    label: string;
+    weight?: number;
+    style?: ResttyFontStyle;
+} | {
+    kind: "buffer";
+    data: ResttyFontData;
+    label: string;
+    weight?: number;
+    style?: ResttyFontStyle;
+} | {
+    kind: "local";
+    family: string;
+    matchers: string[];
+    label: string;
+    required: boolean;
+    weight?: number;
+    style?: ResttyFontStyle;
+};
+/**
+ * Touch-based text selection behavior.
+ * - drag: immediate drag-selection on touch
+ * - long-press: selection starts after a long-press timeout
+ * - off: disable touch selection entirely
+ */
+export type ResttyTouchSelectionMode = "drag" | "long-press" | "off";
+/** Hinting target mode used when TrueType hinting is enabled. */
+export type ResttyFontHintTarget = "auto" | "light" | "normal";
+/** Input payload passed to runtime before-input hooks. */
+export type ResttyRuntimeInputPayload = {
+    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;
+};

package/dist/runtime/core/resources.d.ts

@@ -0,0 +1,50 @@
+import type { DesktopNotification } from "../../input";
+import type { WebGPUCoreState } from "../../renderer";
+import type { ResttyWasm } from "../../wasm";
+import type { Font as TextShaperFont } from "text-shaper";
+import type { ResttyResolvedFontSource, ResttySearchState } from "./models";
+/** Callback for WASM log messages. */
+export type ResttyWasmLogListener = (message: string) => void;
+/** Shared parsed font face reused across panes within a session. */
+export type ResttyFontResourceFace = {
+    /** Human-readable label for UI/status output. */
+    label: string;
+    /** Parsed text-shaper font instance. */
+    font: TextShaperFont;
+};
+/** Lease handle returned by the shared font resource store. */
+export type ResttyFontResourceLease = {
+    /** Ordered parsed faces (primary + fallbacks). */
+    faces: ResttyFontResourceFace[];
+    /** Release the lease when pane/runtime no longer needs the faces. */
+    release: () => void;
+};
+/** Session-level font resource store for deduped loading/parsing and caching. */
+export type ResttyFontResourceStore = {
+    /** Acquire parsed faces for a source list. */
+    acquire: (sources: ResttyResolvedFontSource[]) => Promise<ResttyFontResourceLease>;
+};
+/**
+ * Runtime session provider that supplies shared WASM and WebGPU resources.
+ */
+export type ResttyRuntimeSession = {
+    /** Lazily initialize and return the WASM module. */
+    getWasm: () => Promise<ResttyWasm>;
+    /** Lazily initialize and return the WebGPU renderer core for a canvas. */
+    getWebGPUCore: (canvas: HTMLCanvasElement) => Promise<WebGPUCoreState | null>;
+    /** Return the shared font resource store for this session/tab. */
+    getFontResourceStore?: () => ResttyFontResourceStore;
+    /** Subscribe to WASM log output. */
+    addWasmLogListener?: (listener: ResttyWasmLogListener) => void;
+    /** Unsubscribe from WASM log output. */
+    removeWasmLogListener?: (listener: ResttyWasmLogListener) => void;
+};
+/**
+ * Callbacks fired by the runtime when internal state changes.
+ */
+export type ResttyRuntimeCallbacks = {
+    /** Terminal requested a desktop notification via OSC 9 / OSC 777. */
+    onDesktopNotification?: (notification: DesktopNotification) => void;
+    /** Terminal search state changed. */
+    onSearchState?: (state: ResttySearchState) => void;
+};

package/dist/runtime/core/runtime-events.d.ts

@@ -0,0 +1,28 @@
+import type { ResttySearchState } from "./models";
+import type { ResttyRuntimeLifecycleState } from "./lifecycle";
+/**
+ * Event emitted by a single runtime instance.
+ */
+export type ResttyRuntimeEvent = {
+    type: "state";
+    state: ResttyRuntimeLifecycleState;
+} | {
+    type: "backend";
+    backend: string;
+} | {
+    type: "term-size";
+    cols: number;
+    rows: number;
+} | {
+    type: "pty-status";
+    status: string;
+} | {
+    type: "search-state";
+    state: ResttySearchState;
+};
+export type ResttyRuntimeEventListener = (event: ResttyRuntimeEvent) => void;
+export type ResttyRuntimeEventHub = {
+    emit: (event: ResttyRuntimeEvent) => void;
+    subscribe: (listener: ResttyRuntimeEventListener) => () => void;
+};
+export declare function createRuntimeEventHub(): ResttyRuntimeEventHub;

package/dist/runtime/core/session.d.ts

@@ -0,0 +1,9 @@
+import type { ResttyRuntimeSession } from "./resources";
+/**
+ * Create a new runtime session that lazily loads the WASM module and
+ * initializes the WebGPU core on first use. Multiple panes can
+ * share a single session to avoid duplicate resource loading.
+ */
+export declare function createResttyRuntimeSession(): ResttyRuntimeSession;
+/** Return the global default session, creating it on first call. */
+export declare function getDefaultResttyRuntimeSession(): ResttyRuntimeSession;

package/dist/runtime/{codepoint-utils.d.ts → create-runtime/codepoint-utils.d.ts}

@@ -1,4 +1,4 @@
-import type { FontEntry } from "../fonts";
+import type { FontEntry } from "../../fonts";
 export declare function isLikelyEmojiCodepoint(cp: number): boolean;
 export declare function isVariationSelectorCodepoint(cp: number): boolean;
 export declare function isCombiningMarkCodepoint(cp: number): boolean;

package/dist/runtime/create-runtime/{color-glyph-atlas.d.ts → font-runtime/color-glyph-atlas.d.ts}

@@ -1,5 +1,5 @@
-import type { FontAtlas } from "../../fonts";
-import type { BuildColorEmojiAtlasWithCanvas } from "./font-runtime-helpers.types";
+import type { FontAtlas } from "../../../fonts";
+import type { BuildColorEmojiAtlasWithCanvas } from "./types";
 type CreateColorGlyphAtlasHelpersOptions = {
     pixelModeRgba: number;
     atlasToRGBA: (atlas: FontAtlas) => Uint8Array;

package/dist/runtime/create-runtime/font-runtime/grid.d.ts

@@ -0,0 +1,6 @@
+import type { CellMetrics } from "./types";
+import type { CreateFontRuntimeGridHelpersOptions } from "./grid.types";
+export declare function createFontRuntimeGridHelpers(options: CreateFontRuntimeGridHelpersOptions): {
+    computeCellMetrics: () => CellMetrics | null;
+    updateGrid: () => void;
+};

package/dist/runtime/create-runtime/font-runtime/grid.types.d.ts

@@ -0,0 +1,22 @@
+import type { FontEntry, FontManagerState } from "../../../fonts";
+import type { WebGLState, WebGPUState } from "../../../renderer";
+import type { PtyTransport } from "../../../pty";
+import type { ResttyWasm } from "../../../wasm";
+import type { FontConfigRef, GridStateRef } from "./types";
+export type CreateFontRuntimeGridHelpersOptions = {
+    fontState: FontManagerState;
+    fontConfig: FontConfigRef;
+    gridState: GridStateRef;
+    getCanvas: () => HTMLCanvasElement;
+    getCurrentDpr: () => number;
+    getActiveState: () => WebGPUState | WebGLState | null;
+    getWasmReady: () => boolean;
+    getWasm: () => ResttyWasm | null;
+    getWasmHandle: () => number;
+    ptyTransport: PtyTransport;
+    setNeedsRender: () => void;
+    markSearchDirty?: () => void;
+    shapeClusterWithFont: (entry: FontEntry, text: string) => {
+        advance: number;
+    };
+};

package/dist/runtime/create-runtime/font-runtime/index.d.ts

@@ -0,0 +1,15 @@
+import type { CreateRuntimeFontRuntimeHelpersOptions } from "./types";
+export type { CreateRuntimeFontRuntimeHelpersOptions } from "./types";
+export declare function createRuntimeFontRuntimeHelpers(options: CreateRuntimeFontRuntimeHelpersOptions): {
+    ensureAtlasForFont: (device: GPUDevice, state: import("../../../renderer").WebGPUState, entry: import("../../../fonts").FontEntry, neededGlyphIds: Set<number>, fontSizePx: number, fontIndex: number, atlasScale: number, glyphMeta?: Map<number, import("../../fonts/atlas-builder").GlyphConstraintMeta>, constraintContext?: import("../../fonts/atlas-builder").AtlasConstraintContext | null) => boolean;
+    computeCellMetrics: () => import("./types").CellMetrics | null;
+    updateGrid: () => void;
+    shapeClusterWithFont: (entry: import("../../../fonts").FontEntry, text: string) => import("../../../fonts").ShapedCluster;
+    noteColorGlyphText: (entry: import("../../../fonts").FontEntry, text: string, shaped: {
+        glyphs: Array<{
+            glyphId: number;
+        }>;
+    }) => void;
+    fontHasGlyph: (font: import("../../../fonts").Font, ch: string) => boolean;
+    pickFontIndexForText: (text: string, expectedSpan?: number, stylePreference?: string) => number;
+};

package/dist/runtime/create-runtime/font-runtime/text.d.ts

@@ -0,0 +1,12 @@
+import { type Font, type FontEntry } from "../../../fonts";
+import type { CreateFontRuntimeTextHelpersOptions } from "./text.types";
+export declare function createFontRuntimeTextHelpers(options: CreateFontRuntimeTextHelpersOptions): {
+    shapeClusterWithFont: (entry: FontEntry, text: string) => import("../../../fonts").ShapedCluster;
+    noteColorGlyphText: (entry: FontEntry, text: string, shaped: {
+        glyphs: Array<{
+            glyphId: number;
+        }>;
+    }) => void;
+    fontHasGlyph: (font: Font, ch: string) => boolean;
+    pickFontIndexForText: (text: string, expectedSpan?: number, stylePreference?: string) => number;
+};

package/dist/runtime/create-runtime/font-runtime/text.types.d.ts

@@ -0,0 +1,10 @@
+import type { FontManagerState } from "../../../fonts";
+import type { GlyphBufferToShapedGlyphsFn, ShapeFn, UnicodeBufferCtor } from "./types";
+export type CreateFontRuntimeTextHelpersOptions = {
+    fontState: FontManagerState;
+    glyphShapeCacheLimit: number;
+    fontPickCacheLimit: number;
+    UnicodeBuffer: UnicodeBufferCtor;
+    shape: ShapeFn;
+    glyphBufferToShapedGlyphs: GlyphBufferToShapedGlyphsFn;
+};

package/dist/runtime/create-runtime/{font-runtime-helpers.types.d.ts → font-runtime/types.d.ts}

@@ -1,8 +1,8 @@
-import type { Font, FontAtlas, FontEntry, FontManagerState, FontSizeMode, ShapedGlyph } from "../../fonts";
-import type { WebGLState, WebGPUState } from "../../renderer";
-import type { PtyTransport } from "../../pty";
-import type { ResttyWasm } from "../../wasm";
-import type { ResttyAppCallbacks, ResttyFontHintTarget } from "../types";
+import type { Font, FontAtlas, FontEntry, FontManagerState, FontSizeMode, ShapedGlyph } from "../../../fonts";
+import type { WebGLState, WebGPUState } from "../../../renderer";
+import type { PtyTransport } from "../../../pty";
+import type { ResttyWasm } from "../../../wasm";
+import type { ResttyFontHintTarget } from "../../core/models";
 import type { AtlasOptions, GlyphBuffer, GlyphRasterizeOptions, Matrix2D, Matrix3x3, RasterizedGlyph, UnicodeBuffer } from "text-shaper";
 export type GridStateRef = {
     cols: number;
@@ -58,9 +58,6 @@ export type CreateRuntimeFontRuntimeHelpersOptions = {
     fontState: FontManagerState;
     fontConfig: FontConfigRef;
     gridState: GridStateRef;
-    callbacks?: ResttyAppCallbacks;
-    gridEl: HTMLElement | null;
-    cellEl: HTMLElement | null;
     getCanvas: () => HTMLCanvasElement;
     getCurrentDpr: () => number;
     getActiveState: () => WebGPUState | WebGLState | null;

package/dist/runtime/create-runtime/font-runtime/webgpu-atlas.d.ts

@@ -0,0 +1,7 @@
+import { type FontEntry } from "../../../fonts";
+import type { WebGPUState } from "../../../renderer";
+import { type AtlasConstraintContext, type GlyphConstraintMeta } from "../../fonts/atlas-builder";
+import type { CreateRuntimeWebGPUAtlasHelpersOptions } from "./webgpu-atlas.types";
+export declare function createRuntimeWebGPUAtlasHelpers(options: CreateRuntimeWebGPUAtlasHelpersOptions): {
+    ensureAtlasForFont: (device: GPUDevice, state: WebGPUState, entry: FontEntry, neededGlyphIds: Set<number>, fontSizePx: number, fontIndex: number, atlasScale: number, glyphMeta?: Map<number, GlyphConstraintMeta>, constraintContext?: AtlasConstraintContext | null) => boolean;
+};

package/dist/runtime/create-runtime/font-runtime/webgpu-atlas.types.d.ts

@@ -0,0 +1,23 @@
+import type { FontManagerState } from "../../../fonts";
+import type { ResttyFontHintTarget } from "../../core/models";
+import type { AtlasBitmapToRGBA, BuildAtlasFn, BuildColorEmojiAtlasWithCanvas, PadAtlasRGBAFn, RasterizeGlyphFn, RasterizeGlyphWithTransformFn, ResolveGlyphPixelMode } from "./types";
+export type CreateRuntimeWebGPUAtlasHelpersOptions = {
+    fontState: FontManagerState;
+    getFontHinting: () => boolean;
+    getFontHintTarget: () => ResttyFontHintTarget;
+    fontScaleOverrides: Array<{
+        match: RegExp;
+        scale: number;
+    }>;
+    resolveGlyphPixelMode: ResolveGlyphPixelMode;
+    atlasBitmapToRGBA: AtlasBitmapToRGBA;
+    padAtlasRGBA: PadAtlasRGBAFn;
+    buildAtlas: BuildAtlasFn;
+    buildColorEmojiAtlasWithCanvas: BuildColorEmojiAtlasWithCanvas;
+    rasterizeGlyph: RasterizeGlyphFn;
+    rasterizeGlyphWithTransform: RasterizeGlyphWithTransformFn;
+    pixelModeRgbaValue: number;
+    atlasPadding: number;
+    symbolAtlasPadding: number;
+    symbolAtlasMaxSize: number;
+};

package/dist/runtime/create-runtime/highlight-terminal-color-utils.d.ts

@@ -1,13 +1,6 @@
 import { type ThemeTerminalColor } from "../../theme";
 import type { Color } from "../../renderer";
-export type RuntimeTerminalColor = {
-    kind: "color";
-    color: Color;
-} | {
-    kind: "cell-foreground";
-} | {
-    kind: "cell-background";
-};
+import type { RuntimeTerminalColor } from "./highlight-terminal-color-utils.types";
 export declare function runtimeTerminalColorFromTheme(value: ThemeTerminalColor): RuntimeTerminalColor;
 export declare function resolveHighlightBackgroundColor(value: RuntimeTerminalColor, cellFg: Color, cellBg: Color, inverse: boolean): Color;
 export declare function resolveHighlightForegroundColor(value: RuntimeTerminalColor, cellFg: Color, cellBg: Color, inverse: boolean): Color;