restty 0.1.23 → 0.1.25

package/dist/runtime/create-runtime/render-tick-webgpu.types.d.ts

@@ -0,0 +1,386 @@
+import type { FontEntry, FontManagerState } from "../../fonts";
+import type { NerdConstraint } from "../../fonts/nerd-constraints";
+import type { Color, WebGPUState } from "../../renderer";
+import type { CompiledWebGPUShaderStage, WebGPUStageTargets } from "../create-app-types";
+import type { GlyphConstraintMeta } from "../atlas-builder";
+import type { KittyPlacement, RenderState, ResttyWasm, ResttyWasmExports } from "../../wasm";
+export type CursorPosition = {
+    col: number;
+    row: number;
+    wideTail: boolean;
+};
+export type GlyphShape = {
+    glyphId: number;
+    xAdvance: number;
+    xOffset: number;
+    yOffset: number;
+};
+export type ShapedCluster = {
+    glyphs: GlyphShape[];
+    advance: number;
+};
+export type NerdMetrics = {
+    cellWidth: number;
+    cellHeight: number;
+    faceWidth: number;
+    faceHeight: number;
+    faceY: number;
+    iconHeight: number;
+    iconHeightSingle: number;
+};
+export type GlyphQueueItem = {
+    x: number;
+    baseY: number;
+    xPad: number;
+    fg: Color;
+    bg: Color;
+    shaped: ShapedCluster;
+    fontIndex: number;
+    scale: number;
+    cellWidth: number;
+    symbolLike: boolean;
+    symbolConstraint?: boolean;
+    constraintWidth?: number;
+    forceFit?: boolean;
+    glyphWidthPx?: number;
+    cp?: number;
+    italic?: boolean;
+    bold?: boolean;
+};
+export type WebGPUFrame = {
+    bgData: number[];
+    selectionData: number[];
+    underlineData: number[];
+    cursorData: number[];
+    fgRectData: number[];
+    overlayData: number[];
+    glyphDataNearestByFont: Map<number, number[]>;
+    glyphDataLinearByFont: Map<number, number[]>;
+    glyphQueueByFont: Map<number, GlyphQueueItem[]>;
+    overlayGlyphDataNearestByFont: Map<number, number[]>;
+    overlayGlyphDataLinearByFont: Map<number, number[]>;
+    overlayGlyphQueueByFont: Map<number, GlyphQueueItem[]>;
+    neededGlyphIdsByFont: Map<number, Set<number>>;
+    neededGlyphMetaByFont: Map<number, Map<number, GlyphConstraintMeta>>;
+    scaleByFont: number[];
+    bitmapScaleByFont: number[];
+    baselineAdjustByFont: number[];
+    nerdMetrics: NerdMetrics;
+    getGlyphQueue: (fontIndex: number) => GlyphQueueItem[];
+    getOverlayGlyphQueue: (fontIndex: number) => GlyphQueueItem[];
+    getGlyphSet: (fontIndex: number) => Set<number>;
+};
+export type WebGPURenderInput = {
+    rows: number;
+    cols: number;
+    codepoints: Uint32Array;
+    contentTags: Uint8Array | null;
+    wide: Uint8Array | null;
+    styleFlags: Uint16Array | null;
+    linkIds: Uint32Array | null;
+    fgBytes: Uint8Array;
+    bgBytes: Uint8Array | null;
+    ulBytes: Uint8Array | null;
+    ulStyle: Uint8Array | null;
+    graphemeOffset: Uint32Array | null;
+    graphemeLen: Uint32Array | null;
+    graphemeBuffer: Uint32Array | null;
+};
+export type SharedTickDeps = {
+    fontState: FontManagerState;
+    fontHeightUnits: (font: FontEntry["font"]) => number;
+    fontScaleOverride: (entry: FontEntry, overrides: Array<{
+        match: RegExp;
+        scale: number;
+    }>) => number;
+    FONT_SCALE_OVERRIDES: Array<{
+        match: RegExp;
+        scale: number;
+    }>;
+    isSymbolFont: (entry: FontEntry) => boolean;
+    isColorEmojiFont: (entry: FontEntry) => boolean;
+    fontAdvanceUnits: (entry: FontEntry, shapeClusterWithFont: (entry: FontEntry, text: string) => ShapedCluster) => number;
+    shapeClusterWithFont: (entry: FontEntry, text: string) => ShapedCluster;
+    fontMaxCellSpan: (entry: FontEntry) => number;
+    clamp: (value: number, min: number, max: number) => number;
+    buildNerdMetrics: (cellW: number, cellH: number, lineHeight: number, primaryFont: FontEntry["font"] | undefined, primaryScale: number, iconScale: number) => NerdMetrics;
+    nerdIconScale: number;
+    selectionState: {
+        active: boolean;
+        dragging: boolean;
+    };
+    selectionForRow: (row: number, cols: number) => {
+        start: number;
+        end: number;
+    } | null;
+    pushRect: (target: number[], x: number, y: number, width: number, height: number, color: Color) => void;
+    pushRectBox: (target: number[], x: number, y: number, width: number, height: number, color: Color) => void;
+    selectionColor: Color;
+    STYLE_BOLD: number;
+    STYLE_ITALIC: number;
+    STYLE_FAINT: number;
+    STYLE_BLINK: number;
+    STYLE_INVERSE: number;
+    STYLE_INVISIBLE: number;
+    STYLE_STRIKE: number;
+    STYLE_OVERLINE: number;
+    STYLE_UNDERLINE_MASK: number;
+    decodeRGBAWithCache: (bytes: Uint8Array | null, index: number, cache: Map<number, Color>) => Color;
+    brighten: (color: Color, amount: number) => Color;
+    BOLD_BRIGHTEN: number;
+    fade: (color: Color, alpha: number) => Color;
+    FAINT_ALPHA: number;
+    linkState: {
+        hoverId: number;
+    };
+    drawUnderlineStyle: (target: number[], style: number, x: number, rowY: number, cellW: number, cellH: number, baseY: number, underlineOffsetPx: number, underlineThicknessPx: number, color: Color) => void;
+    drawStrikethrough: (target: number[], x: number, rowY: number, cellW: number, cellH: number, color: Color) => void;
+    drawOverline: (target: number[], x: number, rowY: number, cellW: number, color: Color) => void;
+    KITTY_PLACEHOLDER_CP: number;
+    isSpaceCp: (cp: number) => boolean;
+    shouldMergeTrailingClusterCodepoint: (cp: number) => boolean;
+    isBlockElement: (cp: number) => boolean;
+    drawBlockElement: (cp: number, x: number, y: number, cellW: number, cellH: number, fg: Color, target: number[]) => boolean;
+    isBoxDrawing: (cp: number) => boolean;
+    drawBoxDrawing: (cp: number, x: number, y: number, cellW: number, cellH: number, fg: Color, target: number[], underlineThicknessPx: number) => boolean;
+    isBraille: (cp: number) => boolean;
+    drawBraille: (cp: number, x: number, y: number, cellW: number, cellH: number, fg: Color, target: number[]) => boolean;
+    isPowerline: (cp: number) => boolean;
+    drawPowerline: (cp: number, x: number, y: number, cellW: number, cellH: number, fg: Color, target: number[]) => boolean;
+    pickFontIndexForText: (text: string, expectedSpan?: number, stylePreference?: string) => number;
+    stylePreferenceFromFlags: (bold: boolean, italic: boolean) => string;
+    noteColorGlyphText: (entry: FontEntry, text: string, shaped: {
+        glyphs: Array<{
+            glyphId: number;
+        }>;
+    }) => void;
+    isRenderSymbolLike: (cp: number) => boolean;
+    resolveSymbolConstraint: (cp: number) => NerdConstraint | null;
+    isGraphicsElement: (cp: number) => boolean;
+    glyphWidthUnits: (entry: FontEntry, glyphId: number) => number;
+    fitTextTailToWidth: (text: string, maxWidth: number, measure: (value: string) => number) => {
+        text: string;
+        widthPx: number;
+        offset: number;
+    };
+    PREEDIT_BG: Color;
+    PREEDIT_UL: Color;
+    PREEDIT_ACTIVE_BG: Color;
+    PREEDIT_CARET: Color;
+    PREEDIT_FG: Color;
+    resizeState: {
+        lastAt: number;
+        cols: number;
+        rows: number;
+    };
+    RESIZE_OVERLAY_HOLD_MS: number;
+    RESIZE_OVERLAY_FADE_MS: number;
+    ensureAtlasForFont: (device: GPUDevice, state: WebGPUState, entry: FontEntry, neededGlyphIds: Set<number>, fontSizePx: number, fontIndex: number, atlasScale: number, glyphMeta?: Map<number, GlyphConstraintMeta>, constraintContext?: {
+        cellW: number;
+        cellH: number;
+        yPad: number;
+        baselineOffset: number;
+        baselineAdjust: number;
+        fontScale: number;
+        nerdMetrics: NerdMetrics;
+        fontEntry: FontEntry;
+    } | null) => boolean;
+    defaultBg: Color;
+    decodePackedRGBA: (packed: number) => Color;
+    cursorFallback: Color;
+    scrollbarState: {
+        lastTotal: number;
+        lastOffset: number;
+        lastLen: number;
+    };
+    appendOverlayScrollbar: (target: number[], total: number, offset: number, len: number) => void;
+    webgpuUniforms: Float32Array;
+    ensureInstanceBuffer: (state: WebGPUState, kind: "rect" | "glyph", minBytes: number) => void;
+    GLYPH_INSTANCE_FLOATS: number;
+    wasm: ResttyWasm | null;
+    drawKittyOverlay: (placements: KittyPlacement[], cellW: number, cellH: number) => void;
+    isAppleSymbolsFont: (entry: FontEntry) => boolean;
+    DEFAULT_APPLE_SYMBOLS_CONSTRAINT: NerdConstraint;
+    DEFAULT_SYMBOL_CONSTRAINT: NerdConstraint;
+    DEFAULT_EMOJI_CONSTRAINT: NerdConstraint;
+    constrainGlyphBox: (box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, constraint: NerdConstraint, metrics: NerdMetrics, constraintWidth: number) => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    tightenNerdConstraintBox: (box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, constraint: NerdConstraint | null) => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    fontEntryHasItalicStyle: (entry: FontEntry) => boolean;
+    fontEntryHasBoldStyle: (entry: FontEntry) => boolean;
+    ITALIC_SLANT: number;
+    BOLD_OFFSET: number;
+    GLYPH_RENDER_MODE_COLOR: number;
+    GLYPH_RENDER_MODE_MONO: number;
+};
+export type RuntimeTickDeps = SharedTickDeps & {
+    isShaderStagesDirty: () => boolean;
+    rebuildWebGPUShaderStages: (state: WebGPUState) => void;
+    setShaderStagesDirty: (value: boolean) => void;
+    getCompiledWebGPUShaderStages: () => CompiledWebGPUShaderStage[];
+    ensureWebGPUStageTargets: (state: WebGPUState) => WebGPUStageTargets | null;
+    fontError: Error | null;
+    termDebug: HTMLElement | null;
+    reportDebugText: (text: string) => void;
+    updateGrid: () => void;
+    getRenderState: () => RenderState | null;
+    clearKittyOverlay: () => void;
+    resolveBlendFlags: (alphaMode: string, backend: "webgpu", state: WebGPUState) => {
+        useLinearBlending: boolean;
+        useLinearCorrection: boolean;
+    };
+    alphaBlending: string;
+    srgbToLinearColor: (color: Color) => Color;
+    reportTermSize: (cols: number, rows: number) => void;
+    resolveCursorPosition: (cursor: RenderState["cursor"]) => CursorPosition | null;
+    reportCursor: (cursor: {
+        col: number;
+        row: number;
+    } | null) => void;
+    FORCE_CURSOR_BLINK: boolean;
+    CURSOR_BLINK_MS: number;
+    imeInput: HTMLTextAreaElement | null;
+    resolveCursorStyle: (cursor: NonNullable<RenderState["cursor"]>, opts: {
+        focused: boolean;
+        preedit: boolean;
+        blinkVisible: boolean;
+    }) => number | null;
+    isFocused: boolean;
+    imeState: {
+        preedit: string;
+        selectionStart: number;
+        selectionEnd: number;
+    };
+    resolveImeAnchor: (cursor: CursorPosition | null, cols: number, rows: number) => {
+        row: number;
+        col: number;
+    } | null;
+    dbgEl: HTMLElement | null;
+    wasmExports: ResttyWasmExports | null;
+    wasmHandle: number;
+    gridState: {
+        cellW: number;
+        cellH: number;
+        fontSizePx: number;
+        scale: number;
+        lineHeight: number;
+        baselineOffset: number;
+        yPad: number;
+    };
+    canvas: HTMLCanvasElement;
+    updateImePosition: (cursor: {
+        row: number;
+        col: number;
+    }, cellW: number, cellH: number) => void;
+    lastRenderState: RenderState | null;
+};
+export type EmitWebGPUQueuedGlyphsParams = {
+    deps: SharedTickDeps;
+    state: WebGPUState;
+    frame: WebGPUFrame;
+    queueByFont: Map<number, GlyphQueueItem[]>;
+    targetMaps: {
+        nearest: Map<number, number[]>;
+        linear: Map<number, number[]>;
+    };
+    cellW: number;
+    cellH: number;
+    yPad: number;
+    baselineOffset: number;
+    primaryScale: number;
+};
+export type CollectWebGPUCellPassParams = {
+    deps: SharedTickDeps;
+    render: WebGPURenderInput;
+    cellW: number;
+    cellH: number;
+    fontSizePx: number;
+    primaryScale: number;
+    lineHeight: number;
+    baselineOffset: number;
+    yPad: number;
+    underlineOffsetPx: number;
+    underlineThicknessPx: number;
+    cursorBlock: boolean;
+    cursorCell: {
+        row: number;
+        col: number;
+        wide: boolean;
+    } | null;
+    blinkVisible: boolean;
+    defaultBg: Color;
+};
+export type AugmentWebGPUFrameParams = {
+    deps: SharedTickDeps & {
+        canvas: HTMLCanvasElement;
+        imeState: RuntimeTickDeps["imeState"];
+    };
+    state: WebGPUState;
+    frame: WebGPUFrame;
+    cursor: RenderState["cursor"];
+    cursorImeAnchor: {
+        row: number;
+        col: number;
+    } | null;
+    cursorCell: {
+        row: number;
+        col: number;
+        wide: boolean;
+    } | null;
+    cols: number;
+    cellW: number;
+    cellH: number;
+    yPad: number;
+    baselineOffset: number;
+    underlineOffsetPx: number;
+    underlineThicknessPx: number;
+    lineHeight: number;
+    primaryScale: number;
+    fontSizePx: number;
+};
+export type DrawWebGPUFrameParams = {
+    deps: SharedTickDeps & {
+        wasmHandle: number;
+        wasmExports: ResttyWasmExports | null;
+        canvas: HTMLCanvasElement;
+    };
+    state: WebGPUState;
+    frame: WebGPUFrame;
+    cursor: RenderState["cursor"];
+    cursorPos: CursorPosition | null;
+    cursorStyle: number | null;
+    rows: number;
+    cols: number;
+    cellW: number;
+    cellH: number;
+    yPad: number;
+    baselineOffset: number;
+    underlineOffsetPx: number;
+    underlineThicknessPx: number;
+    primaryScale: number;
+    useLinearBlending: boolean;
+    useLinearCorrection: boolean;
+    clearColor: Color;
+    hasShaderStages: boolean;
+    stageTargets: WebGPUStageTargets | null;
+    compiledWebGPUStages: CompiledWebGPUShaderStage[];
+};

package/dist/runtime/create-runtime/render-ticks.d.ts

@@ -0,0 +1,9 @@
+import type { WebGLState, WebGPUState } from "../../renderer";
+import type { WebGLTickDeps } from "./render-tick-webgl.types";
+import type { RuntimeTickDeps } from "./render-tick-webgpu.types";
+type RuntimeRenderTickDeps = RuntimeTickDeps & WebGLTickDeps;
+export declare function createRuntimeRenderTicks(deps: RuntimeRenderTickDeps): {
+    tickWebGPU: (state: WebGPUState) => void;
+    tickWebGL: (state: WebGLState) => void;
+};
+export {};

package/dist/runtime/create-runtime/runtime-app-api.d.ts

@@ -0,0 +1,103 @@
+import type { InputHandler } from "../../input";
+import { type WebGPUState, type WebGLState } from "../../renderer";
+import type { PtyTransport } from "../../pty";
+import { type GhosttyTheme } from "../../theme";
+import type { ResttyWasm, ResttyWasmExports } from "../../wasm";
+import type { ResttyApp, ResttyAppCallbacks, ResttyAppSession } from "../types";
+import type { PtyInputRuntime } from "./pty-input-runtime";
+import type { RuntimeInteraction } from "./interaction-runtime";
+export type RuntimeAppApiSharedState = {
+    wasm: ResttyWasm | null;
+    wasmExports: ResttyWasmExports | null;
+    wasmHandle: number;
+    wasmReady: boolean;
+    activeState: WebGPUState | WebGLState | null;
+    needsRender: boolean;
+    lastRenderTime: number;
+    currentContextType: "webgpu" | "webgl2" | null;
+    isFocused: boolean;
+    lastKeydownSeq: string;
+    lastKeydownSeqAt: number;
+};
+type PreferredRenderer = "auto" | "webgpu" | "webgl2";
+type RuntimeSendInput = (text: string, source?: string, options?: {
+    skipHooks?: boolean;
+}) => void;
+type RuntimePublicApiOptions = {
+    setFontSize: ResttyApp["setFontSize"];
+    setFontSources: ResttyApp["setFontSources"];
+    resetTheme: ResttyApp["resetTheme"];
+    dumpAtlasForCodepoint: ResttyApp["dumpAtlasForCodepoint"];
+    resize: ResttyApp["resize"];
+    focus: ResttyApp["focus"];
+    blur: ResttyApp["blur"];
+    updateSize: ResttyApp["updateSize"];
+    setShaderStages: ResttyApp["setShaderStages"];
+    getShaderStages: ResttyApp["getShaderStages"];
+};
+export type RuntimeAppApiRuntime = {
+    sendInput: RuntimeSendInput;
+    createPublicApi: (options: RuntimePublicApiOptions) => ResttyApp;
+};
+type LifecycleThemeRuntime = {
+    cancelScheduledSizeUpdate: () => void;
+    getActiveTheme: () => GhosttyTheme | null;
+};
+type CreateRuntimeAppApiOptions = {
+    session: ResttyAppSession;
+    ptyTransport: PtyTransport;
+    inputHandler: InputHandler;
+    ptyInputRuntime: PtyInputRuntime;
+    interaction: RuntimeInteraction;
+    lifecycleThemeSizeRuntime: LifecycleThemeRuntime;
+    cleanupFns: Array<() => void>;
+    cleanupCanvasFns: Array<() => void>;
+    callbacks?: ResttyAppCallbacks;
+    fpsEl: HTMLElement | null;
+    backendEl: HTMLElement | null;
+    inputDebugEl: HTMLElement | null;
+    imeInput: HTMLTextAreaElement | null;
+    attachWindowEvents: boolean;
+    isMacPlatform: boolean;
+    textEncoder: TextEncoder;
+    readState: () => RuntimeAppApiSharedState;
+    writeState: (patch: Partial<RuntimeAppApiSharedState>) => void;
+    appendLog: (line: string) => void;
+    shouldSuppressWasmLog: (text: string) => boolean;
+    runBeforeInputHook: (text: string, source: string) => string | null;
+    runBeforeRenderOutputHook: (text: string, source: string) => string | null;
+    getSelectionText: () => string;
+    initialPreferredRenderer: PreferredRenderer;
+    CURSOR_BLINK_MS: number;
+    RESIZE_ACTIVE_MS: number;
+    TARGET_RENDER_FPS: number;
+    BACKGROUND_RENDER_FPS: number;
+    KITTY_FLAG_REPORT_EVENTS: number;
+    resizeState: {
+        lastAt: number;
+    };
+    flushPendingTerminalResize: () => void;
+    tickWebGPU: (state: WebGPUState) => void;
+    tickWebGL: (state: WebGLState) => void;
+    updateGrid: () => void;
+    gridState: {
+        cols: number;
+        rows: number;
+    };
+    getCanvas: () => HTMLCanvasElement;
+    applyTheme: ResttyApp["applyTheme"];
+    ensureFont: () => Promise<void>;
+    updateSize: ResttyApp["updateSize"];
+    log: (line: string) => void;
+    replaceCanvas: () => void;
+    rebuildWebGPUShaderStages: (state: WebGPUState) => void;
+    rebuildWebGLShaderStages: (state: WebGLState) => void;
+    setShaderStagesDirty: (dirty: boolean) => void;
+    clearWebGPUShaderStages: () => void;
+    destroyWebGPUStageTargets: () => void;
+    clearWebGLShaderStages: (state?: WebGLState) => void;
+    destroyWebGLStageTargets: (state?: WebGLState) => void;
+    resetTerminalResizeScheduler: () => void;
+};
+export declare function createRuntimeAppApi(options: CreateRuntimeAppApiOptions): RuntimeAppApiRuntime;
+export {};

package/dist/runtime/create-runtime/runtime-logger.d.ts

@@ -0,0 +1,17 @@
+type RuntimeLogFilter = {
+    re: RegExp;
+    note: string;
+};
+export type CreateRuntimeLoggerOptions = {
+    logEl?: HTMLElement | null;
+    onLog?: ((entry: string) => void) | null;
+    logLimit?: number;
+    wasmLogFilters?: RuntimeLogFilter[];
+};
+export type RuntimeLogger = {
+    log: (msg: string) => void;
+    appendLog: (line: string) => void;
+    shouldSuppressWasmLog: (text: string) => boolean;
+};
+export declare function createRuntimeLogger(options: CreateRuntimeLoggerOptions): RuntimeLogger;
+export {};

package/dist/runtime/create-runtime/runtime-reporting.d.ts

@@ -0,0 +1,40 @@
+import type { CursorInfo, RenderState, ResttyWasm, ResttyWasmExports } from "../../wasm";
+import type { ResttyAppCallbacks } from "../types";
+import type { RuntimeSelectionState } from "./interaction-runtime/types";
+export type CreateRuntimeReportingOptions = {
+    selectionState: RuntimeSelectionState;
+    getLastRenderState: () => RenderState | null;
+    getWasmReady: () => boolean;
+    getWasm: () => ResttyWasm | null;
+    getWasmHandle: () => number;
+    getWasmExports: () => ResttyWasmExports | null;
+    callbacks?: ResttyAppCallbacks;
+    termSizeEl: HTMLElement | null;
+    cursorPosEl: HTMLElement | null;
+    dbgEl: HTMLElement | null;
+    setCursorForCpr: (pos: {
+        row: number;
+        col: number;
+    }) => void;
+};
+export declare function createRuntimeReporting(options: CreateRuntimeReportingOptions): {
+    selectionForRow: (row: number, cols: number) => import("../../selection").SelectionRange;
+    getSelectionText: () => string;
+    getRenderState: () => RenderState | null;
+    resolveCursorPosition: (cursor: CursorInfo | null) => {
+        col: number;
+        row: number;
+        wideTail: boolean;
+    };
+    resolveCursorStyle: (cursor: CursorInfo | null, opts: {
+        focused: boolean;
+        preedit: boolean;
+        blinkVisible: boolean;
+    }) => number | null;
+    reportTermSize: (cols: number, rows: number) => void;
+    reportCursor: (cursorPos: {
+        col: number;
+        row: number;
+    } | null) => void;
+    reportDebugText: (text: string) => void;
+};

package/dist/runtime/create-runtime/shader-stage-runtime.d.ts

@@ -0,0 +1,29 @@
+import type { WebGPUState, WebGLState } from "../../renderer";
+import type { CompiledWebGPUShaderStage, WebGPUStageTargets, CompiledWebGLShaderStage, WebGLStageTargets } from "../create-app-types";
+import type { ResttyShaderStage } from "../types";
+export type CreateShaderStageRuntimeOptions = {
+    appendLog: (line: string) => void;
+    getCanvasSize: () => {
+        width: number;
+        height: number;
+    };
+    getActiveWebGLState: () => WebGLState | null;
+    onShaderStagesChanged: () => void;
+};
+export type ShaderStageRuntime = {
+    setShaderStages: (stages: ResttyShaderStage[]) => void;
+    getShaderStages: () => ResttyShaderStage[];
+    isShaderStagesDirty: () => boolean;
+    setShaderStagesDirty: (value: boolean) => void;
+    getCompiledWebGPUShaderStages: () => CompiledWebGPUShaderStage[];
+    getCompiledWebGLShaderStages: () => CompiledWebGLShaderStage[];
+    clearWebGPUShaderStages: () => void;
+    clearWebGLShaderStages: (state?: WebGLState | null) => void;
+    destroyWebGPUStageTargets: () => void;
+    destroyWebGLStageTargets: (state?: WebGLState | null) => void;
+    ensureWebGPUStageTargets: (state: WebGPUState) => WebGPUStageTargets | null;
+    ensureWebGLStageTargets: (state: WebGLState) => WebGLStageTargets | null;
+    rebuildWebGPUShaderStages: (state: WebGPUState) => void;
+    rebuildWebGLShaderStages: (state: WebGLState) => void;
+};
+export declare function createShaderStageRuntime(options: CreateShaderStageRuntimeOptions): ShaderStageRuntime;

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

@@ -0,0 +1,7 @@
+import type { ResttyApp, ResttyAppOptions } from "./types";
+export { createResttyAppSession, getDefaultResttyAppSession } from "./session";
+export { createResttyPaneManager, } from "../surface/panes/manager";
+export { createDefaultResttyPaneContextMenuItems, getResttyShortcutModifierLabel, } from "../surface/panes/default-context-menu-items";
+export type { ResttyAppElements, ResttyAppCallbacks, FontSource, ResttyFontSource, ResttyTouchSelectionMode, ResttyUrlFontSource, ResttyBufferFontSource, ResttyLocalFontSource, ResttyWasmLogListener, ResttyAppSession, ResttyAppInputPayload, ResttyShaderStage, ResttyShaderStageMode, ResttyShaderStageBackend, ResttyShaderStageSource, ResttyAppOptions, ResttyApp, } from "./types";
+export type { ResttyPaneSplitDirection, ResttyPaneContextMenuItem, ResttyPaneDefinition, ResttyPaneStyleOptions, ResttyPaneStylesOptions, ResttyPaneShortcutsOptions, ResttyPaneContextMenuOptions, CreateResttyPaneManagerOptions, ResttyPaneManager, ResttyPaneWithApp, CreateDefaultResttyPaneContextMenuItemsOptions, } from "../surface/panes-types";
+export declare function createResttyApp(options: ResttyAppOptions): ResttyApp;

package/dist/runtime/font-atlas-utils/bitmap-utils.d.ts

@@ -0,0 +1,5 @@
+import type { FontAtlasBitmap } from "../../fonts";
+export declare function bitmapBytesPerPixel(pixelMode: number): number;
+export declare function createAtlasBitmap(width: number, height: number, pixelMode: FontAtlasBitmap["pixelMode"]): FontAtlasBitmap;
+export declare function cloneBitmap(bitmap: FontAtlasBitmap | null | undefined, defaultPixelMode?: FontAtlasBitmap["pixelMode"]): FontAtlasBitmap;
+export declare function copyBitmapToAtlas(src: FontAtlasBitmap, dst: FontAtlasBitmap, dstX: number, dstY: number): void;

package/dist/runtime/font-atlas-utils/glyph-atlas-builder.d.ts

@@ -0,0 +1,29 @@
+import { type Font, type FontAtlas, type FontSizeMode } from "../../fonts";
+import type { GlyphConstraintMeta, AtlasConstraintContext } from "../atlas-builder";
+import type { GlyphRasterizeOptions, Matrix2D, Matrix3x3, RasterizedGlyph } from "text-shaper";
+export type RasterizeGlyphTransformOptions = GlyphRasterizeOptions & {
+    offsetX26?: number;
+    offsetY26?: number;
+};
+export type RasterizeGlyphFn = (font: Font, glyphId: number, fontSize: number, options?: GlyphRasterizeOptions) => RasterizedGlyph | null;
+export type RasterizeGlyphWithTransformFn = (font: Font, glyphId: number, fontSize: number, matrix: Matrix2D | Matrix3x3, options?: RasterizeGlyphTransformOptions) => RasterizedGlyph | null;
+export type BuildGlyphAtlasWithConstraintsOptions = {
+    font: Font;
+    glyphIds: number[];
+    fontSize: number;
+    sizeMode: FontSizeMode;
+    padding: number;
+    maxWidth: number;
+    maxHeight: number;
+    pixelMode: number;
+    hinting: boolean;
+    rasterizeGlyph?: RasterizeGlyphFn;
+    rasterizeGlyphWithTransform?: RasterizeGlyphWithTransformFn;
+    glyphMeta?: Map<number, GlyphConstraintMeta>;
+    constraintContext?: AtlasConstraintContext;
+};
+export type BuildGlyphAtlasWithConstraintsResult = {
+    atlas: FontAtlas | null;
+    constrainedGlyphWidths: Map<number, number> | null;
+};
+export declare function buildGlyphAtlasWithConstraints(options: BuildGlyphAtlasWithConstraintsOptions): BuildGlyphAtlasWithConstraintsResult;

package/dist/runtime/font-atlas-utils/nerd-metrics-utils.d.ts

@@ -0,0 +1,25 @@
+import type { Font } from "../../fonts";
+import type { GlyphConstraintMeta, AtlasConstraintContext } from "../atlas-builder";
+export declare function resolveFontScaleForAtlas(font: Font | null | undefined, fontSize: number, sizeMode?: "em" | "height" | null): number;
+export declare function fontCapHeightUnits(font: Font | null | undefined): number;
+export declare function buildNerdMetrics(cellW: number, cellH: number, lineHeight: number, primaryFont: Font | null | undefined, primaryScale: number, iconScale: number): {
+    cellWidth: number;
+    cellHeight: number;
+    faceWidth: number;
+    faceHeight: number;
+    faceY: number;
+    iconHeight: number;
+    iconHeightSingle: number;
+};
+export declare function nerdConstraintSignature(glyphMeta?: Map<number, GlyphConstraintMeta>, constraintContext?: AtlasConstraintContext | null): string;
+export declare function tightenNerdConstraintBox(box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, constraint: import("../../fonts").NerdConstraint | null): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};

package/dist/runtime/font-atlas-utils/packing-utils.d.ts

@@ -0,0 +1,13 @@
+export declare function nextPowerOf2(n: number): number;
+export declare function packGlyphs(sizes: Array<{
+    width: number;
+    height: number;
+}>, maxWidth: number, maxHeight: number): {
+    width: number;
+    height: number;
+    placements: {
+        x: number;
+        y: number;
+        placed: boolean;
+    }[];
+};