restty 0.1.23 → 0.1.25

package/dist/runtime/create-runtime/debug-tools/types.d.ts

@@ -0,0 +1,63 @@
+import type { fontAdvanceUnits as fontAdvanceUnitsFn, fontMaxCellSpan as fontMaxCellSpanFn, fontScaleOverride as fontScaleOverrideFn, FontEntry, FontManagerState, NerdConstraint, isColorEmojiFont as isColorEmojiFontFn, isNerdSymbolCodepoint as isNerdSymbolCodepointFn, isSymbolFont as isSymbolFontFn } from "../../../fonts";
+import type { clamp as clampFn, fontHeightUnits as fontHeightUnitsFn } from "../../../grid";
+import type { WebGLState, WebGPUState } from "../../../renderer";
+import type { GlyphConstraintMeta, AtlasConstraintContext } from "../../atlas-builder";
+import type { NerdMetrics } from "../render-tick-webgpu.types";
+export type GridState = {
+    cols: number;
+    rows: number;
+    cellW: number;
+    cellH: number;
+    fontSizePx: number;
+    yPad: number;
+};
+export type FontConfig = {
+    sizePx: number;
+};
+export type ShapeClusterResult = {
+    glyphs: Array<{
+        glyphId: number;
+        xAdvance: number;
+        xOffset: number;
+        yOffset: number;
+    }>;
+    advance: number;
+};
+export type BuildNerdMetricsFn = (cellW: number, cellH: number, lineHeight: number, font: FontEntry["font"] | null | undefined, primaryScale: number, nerdIconScale: number) => NerdMetrics;
+export type EnsureAtlasForFontFn = (device: GPUDevice, state: WebGPUState, entry: FontEntry, neededGlyphIds: Set<number>, fontSizePx: number, fontIndex: number, atlasScale: number, glyphMeta?: Map<number, GlyphConstraintMeta>, constraintContext?: AtlasConstraintContext | null) => boolean;
+export type CreateRuntimeDebugToolsOptions = {
+    debugExpose: boolean;
+    getWindow: () => (Window & typeof globalThis) | undefined;
+    getActiveState: () => WebGPUState | WebGLState | null;
+    getCanvas: () => HTMLCanvasElement;
+    atlasCanvas: HTMLCanvasElement | null;
+    atlasInfoEl: HTMLElement | null;
+    fontState: FontManagerState;
+    gridState: GridState;
+    fontConfig: FontConfig;
+    pickFontIndexForText: (text: string, expectedSpan?: number) => number;
+    ensureAtlasForFont: EnsureAtlasForFontFn;
+    formatCodepoint: (cp: number) => string;
+    isSymbolFont: typeof isSymbolFontFn;
+    isNerdSymbolCodepoint: typeof isNerdSymbolCodepointFn;
+    isSymbolCp: (cp: number) => boolean;
+    fontHasGlyph: (font: FontEntry["font"], ch: string) => boolean;
+    shapeClusterWithFont: (entry: FontEntry, text: string) => ShapeClusterResult;
+    getNerdConstraint: (cp: number) => NerdConstraint | null;
+    fontHeightUnits: typeof fontHeightUnitsFn;
+    fontScaleOverride: typeof fontScaleOverrideFn;
+    fontScaleOverrides: Array<{
+        match: RegExp;
+        scale: number;
+    }>;
+    fontAdvanceUnits: typeof fontAdvanceUnitsFn;
+    fontMaxCellSpan: typeof fontMaxCellSpanFn;
+    clamp: typeof clampFn;
+    buildNerdMetrics: BuildNerdMetricsFn;
+    nerdIconScale: number;
+    isColorEmojiFont: typeof isColorEmojiFontFn;
+    atlasPadding: number;
+    symbolAtlasPadding: number;
+    pixelModeGray: number;
+    pixelModeRgba: number;
+};

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

@@ -0,0 +1,6 @@
+import type { CreateRuntimeDebugToolsOptions } from "./debug-tools/types";
+export type { CreateRuntimeDebugToolsOptions } from "./debug-tools/types";
+export declare function createRuntimeDebugTools(options: CreateRuntimeDebugToolsOptions): {
+    dumpAtlasForCodepoint: (cp: number) => void;
+    setupDebugExpose: () => void;
+};

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

@@ -0,0 +1,39 @@
+import { type FontEntry, type FontManagerState } from "../../fonts";
+import type { WebGLState, WebGPUState } from "../../renderer";
+import type { PtyTransport } from "../../pty";
+import type { ResttyWasm } from "../../wasm";
+import type { ResttyAppCallbacks } from "../types";
+import type { CellMetrics, FontConfigRef, GridStateRef, ResizeStateRef } from "./font-runtime-helpers.types";
+type CreateFontRuntimeGridHelpersOptions = {
+    fontState: FontManagerState;
+    fontConfig: FontConfigRef;
+    gridState: GridStateRef;
+    callbacks?: ResttyAppCallbacks;
+    gridEl: HTMLElement | null;
+    cellEl: HTMLElement | null;
+    getCanvas: () => HTMLCanvasElement;
+    getCurrentDpr: () => number;
+    getActiveState: () => WebGPUState | WebGLState | null;
+    getWasmReady: () => boolean;
+    getWasm: () => ResttyWasm | null;
+    getWasmHandle: () => number;
+    ptyTransport: PtyTransport;
+    setNeedsRender: () => void;
+    resizeState: ResizeStateRef;
+    resizeActiveMs: number;
+    resizeCommitDebounceMs: number;
+    onSyncKittyOverlaySize: () => void;
+    shapeClusterWithFont: (entry: FontEntry, text: string) => {
+        advance: number;
+    };
+};
+export declare function createFontRuntimeGridHelpers(options: CreateFontRuntimeGridHelpersOptions): {
+    computeCellMetrics: () => CellMetrics | null;
+    updateGrid: () => void;
+    flushPendingTerminalResize: () => void;
+    scheduleTerminalResizeCommit: (cols: number, rows: number, options?: {
+        immediate?: boolean;
+    }) => void;
+    resetTerminalResizeScheduler: () => void;
+};
+export {};

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

@@ -0,0 +1,20 @@
+import type { CreateRuntimeFontRuntimeHelpersOptions } from "./font-runtime-helpers.types";
+export type { CreateRuntimeFontRuntimeHelpersOptions } from "./font-runtime-helpers.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("../atlas-builder").GlyphConstraintMeta>, constraintContext?: import("../atlas-builder").AtlasConstraintContext | null) => boolean;
+    computeCellMetrics: () => import("./font-runtime-helpers.types").CellMetrics | null;
+    updateGrid: () => void;
+    flushPendingTerminalResize: () => void;
+    scheduleTerminalResizeCommit: (cols: number, rows: number, options?: {
+        immediate?: boolean;
+    }) => void;
+    resetTerminalResizeScheduler: () => 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-helpers.types.d.ts

@@ -0,0 +1,108 @@
+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 } from "../types";
+import type { AtlasOptions, GlyphBuffer, GlyphRasterizeOptions, Matrix2D, Matrix3x3, RasterizedGlyph, UnicodeBuffer } from "text-shaper";
+export type GridStateRef = {
+    cols: number;
+    rows: number;
+    cellW: number;
+    cellH: number;
+    fontSizePx: number;
+    scale: number;
+    lineHeight: number;
+    baselineOffset: number;
+    yPad: number;
+};
+export type FontConfigRef = {
+    sizePx: number;
+};
+export type ResizeStateRef = {
+    lastAt: number;
+};
+export type ShapeClusterResult = {
+    glyphs: ShapedGlyph[];
+    advance: number;
+};
+export type AtlasBuilderOptions = Omit<AtlasOptions, "sizeMode"> & {
+    sizeMode?: FontSizeMode;
+};
+export type BuildColorEmojiAtlasWithCanvasOptions = {
+    font: Font;
+    fontEntry: FontEntry;
+    glyphIds: number[];
+    fontSize: number;
+    sizeMode: FontSizeMode;
+    padding: number;
+    maxWidth: number;
+    maxHeight: number;
+    pixelMode: number;
+};
+export type BuildColorEmojiAtlasWithCanvas = (options: BuildColorEmojiAtlasWithCanvasOptions) => {
+    atlas: FontAtlas;
+    constrainedGlyphWidths?: Map<number, number> | null;
+} | null;
+export type AtlasBitmapToRGBA = (atlas: FontAtlas) => Uint8Array | null;
+export type PadAtlasRGBAFn = (rgba: Uint8Array, atlas: FontAtlas, padding: number) => Uint8Array;
+export type BuildAtlasFn = (font: Font, glyphIds: number[], options: AtlasBuilderOptions) => FontAtlas;
+export type ResolveGlyphPixelMode = (entry: FontEntry) => number;
+export type ShapeFn = (font: Font, buffer: UnicodeBuffer) => GlyphBuffer;
+export type GlyphBufferToShapedGlyphsFn = (glyphBuffer: GlyphBuffer) => ShapedGlyph[];
+export type UnicodeBufferCtor = new () => UnicodeBuffer;
+export type RasterizeGlyphFn = (font: Font, glyphId: number, fontSize: number, options?: GlyphRasterizeOptions) => RasterizedGlyph | null;
+export type RasterizeGlyphTransformOptions = GlyphRasterizeOptions & {
+    offsetX26?: number;
+    offsetY26?: number;
+};
+export type GlyphTransformMatrix = Matrix2D | Matrix3x3;
+export type RasterizeGlyphWithTransformFn = (font: Font, glyphId: number, fontSize: number, matrix: GlyphTransformMatrix, options?: RasterizeGlyphTransformOptions) => RasterizedGlyph | null;
+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;
+    getWasmReady: () => boolean;
+    getWasm: () => ResttyWasm | null;
+    getWasmHandle: () => number;
+    ptyTransport: PtyTransport;
+    setNeedsRender: () => void;
+    resizeState: ResizeStateRef;
+    resizeActiveMs: number;
+    resizeCommitDebounceMs: number;
+    onSyncKittyOverlaySize: () => void;
+    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;
+    glyphShapeCacheLimit: number;
+    fontPickCacheLimit: number;
+    UnicodeBuffer: UnicodeBufferCtor;
+    shape: ShapeFn;
+    glyphBufferToShapedGlyphs: GlyphBufferToShapedGlyphsFn;
+};
+export type CellMetrics = {
+    cellW: number;
+    cellH: number;
+    fontSizePx: number;
+    scale: number;
+    lineHeight: number;
+    baselineOffset: number;
+    yPad: number;
+};

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

@@ -0,0 +1,21 @@
+import { type Font, type FontEntry, type FontManagerState } from "../../fonts";
+import type { GlyphBufferToShapedGlyphsFn, ShapeFn, UnicodeBufferCtor } from "./font-runtime-helpers.types";
+type CreateFontRuntimeTextHelpersOptions = {
+    fontState: FontManagerState;
+    glyphShapeCacheLimit: number;
+    fontPickCacheLimit: number;
+    UnicodeBuffer: UnicodeBufferCtor;
+    shape: ShapeFn;
+    glyphBufferToShapedGlyphs: GlyphBufferToShapedGlyphsFn;
+};
+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;
+};
+export {};

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

@@ -0,0 +1,26 @@
+import { type FontEntry, type FontManagerState } from "../../fonts";
+import type { WebGPUState } from "../../renderer";
+import { type AtlasConstraintContext, type GlyphConstraintMeta } from "../atlas-builder";
+import type { AtlasBitmapToRGBA, BuildAtlasFn, BuildColorEmojiAtlasWithCanvas, PadAtlasRGBAFn, RasterizeGlyphFn, RasterizeGlyphWithTransformFn, ResolveGlyphPixelMode } from "./font-runtime-helpers.types";
+type CreateRuntimeWebGPUAtlasHelpersOptions = {
+    fontState: FontManagerState;
+    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;
+};
+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;
+};
+export {};

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

@@ -0,0 +1,2 @@
+export declare function formatPasteText(text: string, bracketedPasteEnabled: boolean): string;
+export declare function formatCodepoint(cp: number): string;

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

@@ -0,0 +1,12 @@
+import type { ResttyAppInputPayload } from "../types";
+type RuntimeInputHook = ((payload: ResttyAppInputPayload) => string | null | void) | null | undefined;
+export type CreateRuntimeInputHooksOptions = {
+    beforeInputHook?: RuntimeInputHook;
+    beforeRenderOutputHook?: RuntimeInputHook;
+};
+export type RuntimeInputHooks = {
+    runBeforeInputHook: (text: string, source: string) => string | null;
+    runBeforeRenderOutputHook: (text: string, source: string) => string | null;
+};
+export declare function createRuntimeInputHooks(options: CreateRuntimeInputHooksOptions): RuntimeInputHooks;
+export {};

package/dist/runtime/create-runtime/interaction-runtime/bind-ime-events.d.ts

@@ -0,0 +1,12 @@
+import type { BindCanvasEventsOptions, RuntimeImeState } from "./types";
+export type BindImeEventsOptions = {
+    bindOptions: BindCanvasEventsOptions;
+    imeInput: HTMLTextAreaElement;
+    imeState: RuntimeImeState;
+    cleanupCanvasFns: Array<() => void>;
+    getWasmReady: () => boolean;
+    getWasmHandle: () => number;
+    setPreedit: (text: string, updateInput?: boolean) => void;
+    syncImeSelection: () => void;
+};
+export declare function bindImeEvents(options: BindImeEventsOptions): void;

package/dist/runtime/create-runtime/interaction-runtime/bind-pointer-aux-handlers.d.ts

@@ -0,0 +1,28 @@
+import type { InputHandler } from "../../../input";
+import type { RuntimeCell, RuntimeDesktopSelectionState, RuntimeGridState, RuntimeScrollbarDragState, RuntimeSelectionState, RuntimeTouchSelectionState } from "./types";
+type CreatePointerAuxHandlersOptions = {
+    inputHandler: InputHandler;
+    shouldRoutePointerToAppMouse: (shiftKey: boolean) => boolean;
+    scrollViewportByLines: (lines: number) => void;
+    getWasmReady: () => boolean;
+    getWasmHandle: () => number;
+    getGridState: () => RuntimeGridState;
+    updateLinkHover: (cell: RuntimeCell | null) => void;
+    clearPendingDesktopSelection: () => void;
+    clearPendingTouchSelection: () => void;
+    isTouchPointer: (event: PointerEvent) => boolean;
+    selectionState: RuntimeSelectionState;
+    touchSelectionState: RuntimeTouchSelectionState;
+    desktopSelectionState: RuntimeDesktopSelectionState;
+    scrollbarDragState: RuntimeScrollbarDragState;
+    updateCanvasCursor: () => void;
+    markNeedsRender: () => void;
+};
+export type PointerAuxHandlers = {
+    onPointerCancel: (event: PointerEvent) => void;
+    onWheel: (event: WheelEvent) => void;
+    onContextMenu: (event: MouseEvent) => void;
+    onPointerLeave: () => void;
+};
+export declare function createPointerAuxHandlers(options: CreatePointerAuxHandlersOptions): PointerAuxHandlers;
+export {};

package/dist/runtime/create-runtime/interaction-runtime/bind-pointer-events.d.ts

@@ -0,0 +1,41 @@
+import { type OverlayScrollbarLayout } from "../../overlay-scrollbar";
+import type { BindCanvasEventsOptions, RuntimeCell, RuntimeDesktopSelectionState, RuntimeGridState, RuntimeLinkState, RuntimeScrollbarDragState, RuntimeSelectionState, RuntimeTouchSelectionState } from "./types";
+export type BindPointerEventsOptions = {
+    canvas: HTMLCanvasElement;
+    bindOptions: BindCanvasEventsOptions;
+    touchSelectionMode: "off" | "drag" | "long-press";
+    touchSelectionLongPressMs: number;
+    touchSelectionMoveThresholdPx: number;
+    selectionState: RuntimeSelectionState;
+    touchSelectionState: RuntimeTouchSelectionState;
+    desktopSelectionState: RuntimeDesktopSelectionState;
+    scrollbarDragState: RuntimeScrollbarDragState;
+    linkState: RuntimeLinkState;
+    cleanupCanvasFns: Array<() => void>;
+    isTouchPointer: (event: PointerEvent) => boolean;
+    clearPendingTouchSelection: () => void;
+    clearPendingDesktopSelection: () => void;
+    tryActivatePendingTouchSelection: (pointerId: number) => boolean;
+    beginSelectionDrag: (cell: RuntimeCell, pointerId: number) => void;
+    noteScrollActivity: () => void;
+    getOverlayScrollbarLayout: () => OverlayScrollbarLayout | null;
+    pointerToCanvasPx: (event: PointerEvent) => {
+        x: number;
+        y: number;
+    };
+    setViewportScrollOffset: (nextOffset: number) => void;
+    normalizeSelectionCell: (cell: RuntimeCell) => RuntimeCell;
+    positionToCell: (event: {
+        clientX: number;
+        clientY: number;
+    }) => RuntimeCell;
+    scrollViewportByLines: (lines: number) => void;
+    clearSelection: () => void;
+    updateCanvasCursor: () => void;
+    markNeedsRender: () => void;
+    updateLinkHover: (cell: RuntimeCell | null) => void;
+    getGridState: () => RuntimeGridState;
+    getWasmReady: () => boolean;
+    getWasmHandle: () => number;
+};
+export declare function bindPointerEvents(options: BindPointerEventsOptions): void;

package/dist/runtime/create-runtime/interaction-runtime/bind-pointer-up-handler.d.ts

@@ -0,0 +1,28 @@
+import type { InputHandler } from "../../../input";
+import type { RuntimeCell, RuntimeDesktopSelectionState, RuntimeLinkState, RuntimeScrollbarDragState, RuntimeSelectionState, RuntimeTouchSelectionState } from "./types";
+type CreatePointerUpHandlerOptions = {
+    inputHandler: InputHandler;
+    sendKeyInput: (text: string) => void;
+    openLink: (url: string) => void;
+    scrollbarDragState: RuntimeScrollbarDragState;
+    isTouchPointer: (event: PointerEvent) => boolean;
+    touchSelectionState: RuntimeTouchSelectionState;
+    selectionState: RuntimeSelectionState;
+    normalizeSelectionCell: (cell: RuntimeCell) => RuntimeCell;
+    positionToCell: (event: {
+        clientX: number;
+        clientY: number;
+    }) => RuntimeCell;
+    clearPendingTouchSelection: () => void;
+    clearPendingDesktopSelection: () => void;
+    desktopSelectionState: RuntimeDesktopSelectionState;
+    clearSelection: () => void;
+    updateCanvasCursor: () => void;
+    markNeedsRender: () => void;
+    shouldRoutePointerToAppMouse: (shiftKey: boolean) => boolean;
+    shouldPreferLocalPrimarySelection: (event: PointerEvent) => boolean;
+    linkState: RuntimeLinkState;
+    updateLinkHover: (cell: RuntimeCell | null) => void;
+};
+export declare function createPointerUpHandler(options: CreatePointerUpHandlerOptions): (event: PointerEvent) => void;
+export {};

package/dist/runtime/create-runtime/interaction-runtime/kitty-image-cache.d.ts

@@ -0,0 +1,18 @@
+import type { KittyPlacement, ResttyWasm } from "../../../wasm";
+type KittyDecodedImage = {
+    key: string;
+    width: number;
+    height: number;
+    source: CanvasImageSource;
+};
+export type KittyImageCache = {
+    resolveKittyImage: (placement: KittyPlacement) => KittyDecodedImage | null;
+    clearKittyImageCache: () => void;
+    pruneInactiveImages: (activeImageIds: Set<number>) => boolean;
+};
+export type CreateKittyImageCacheOptions = {
+    getWasm: () => ResttyWasm | null;
+    markNeedsRender: () => void;
+};
+export declare function createKittyImageCache(options: CreateKittyImageCacheOptions): KittyImageCache;
+export {};

package/dist/runtime/create-runtime/interaction-runtime/kitty-overlay-runtime.d.ts

@@ -0,0 +1,15 @@
+import type { KittyPlacement } from "../../../wasm";
+import type { KittyImageCache } from "./kitty-image-cache";
+type CreateKittyOverlayRuntimeOptions = {
+    getCanvas: () => HTMLCanvasElement;
+    kittyOverlayDebugEnabled: boolean;
+    kittyImageCache: KittyImageCache;
+};
+export type KittyOverlayRuntime = {
+    syncKittyOverlaySize: () => void;
+    clearKittyOverlay: () => void;
+    drawKittyOverlay: (placements: KittyPlacement[], cellW: number, cellH: number) => void;
+    detachKittyOverlayCanvas: () => void;
+};
+export declare function createKittyOverlayRuntime(options: CreateKittyOverlayRuntimeOptions): KittyOverlayRuntime;
+export {};

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

@@ -0,0 +1,30 @@
+import { type OverlayScrollbarLayout } from "../../overlay-scrollbar";
+import type { RuntimeGridState, RuntimeLinkState, RuntimeScrollbarState, RuntimeSelectionState } from "./types";
+import type { ResttyWasm, ResttyWasmExports } from "../../../wasm";
+export type CreateScrollbarRuntimeOptions = {
+    showOverlayScrollbar: boolean;
+    scrollbarState: RuntimeScrollbarState;
+    selectionState: RuntimeSelectionState;
+    linkState: RuntimeLinkState;
+    getCanvas: () => HTMLCanvasElement;
+    getCurrentDpr: () => number;
+    getGridState: () => RuntimeGridState;
+    getWasmReady: () => boolean;
+    getWasm: () => ResttyWasm | null;
+    getWasmHandle: () => number;
+    getWasmExports: () => ResttyWasmExports | null;
+    updateLinkHover: (cell: null) => void;
+    markNeedsRender: () => void;
+};
+export type ScrollbarRuntime = {
+    noteScrollActivity: () => void;
+    scrollViewportByLines: (lines: number) => void;
+    setViewportScrollOffset: (nextOffset: number) => void;
+    pointerToCanvasPx: (event: PointerEvent) => {
+        x: number;
+        y: number;
+    };
+    getOverlayScrollbarLayout: () => OverlayScrollbarLayout | null;
+    appendOverlayScrollbar: (overlayData: number[], total: number, offset: number, len: number) => void;
+};
+export declare function createScrollbarRuntime(options: CreateScrollbarRuntimeOptions): ScrollbarRuntime;

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

@@ -0,0 +1,110 @@
+import type { InputHandler } from "../../../input";
+import type { createSelectionState } from "../../../selection";
+import type { KittyPlacement, RenderState, ResttyWasm, ResttyWasmExports } from "../../../wasm";
+export type RuntimeCell = {
+    row: number;
+    col: number;
+};
+export type RuntimeGridState = {
+    cols: number;
+    rows: number;
+    cellW: number;
+    cellH: number;
+};
+export type RuntimeImeState = {
+    composing: boolean;
+    preedit: string;
+    selectionStart: number;
+    selectionEnd: number;
+};
+export type RuntimeTouchSelectionState = {
+    pendingPointerId: number | null;
+    activePointerId: number | null;
+    panPointerId: number | null;
+    pendingCell: RuntimeCell | null;
+    pendingStartedAt: number;
+    pendingStartX: number;
+    pendingStartY: number;
+    panLastY: number;
+    pendingTimer: number;
+};
+export type RuntimeDesktopSelectionState = {
+    pendingPointerId: number | null;
+    pendingCell: RuntimeCell | null;
+    startedWithActiveSelection: boolean;
+};
+export type RuntimeLinkState = {
+    hoverId: number;
+    hoverUri: string;
+};
+export type RuntimeScrollbarState = {
+    lastInputAt: number;
+    lastTotal: number;
+    lastOffset: number;
+    lastLen: number;
+};
+export type RuntimeScrollbarDragState = {
+    pointerId: number | null;
+    thumbGrabRatio: number;
+};
+export type RuntimeSelectionState = ReturnType<typeof createSelectionState>;
+export type BindCanvasEventsOptions = {
+    inputHandler: InputHandler;
+    sendKeyInput: (text: string) => void;
+    sendPasteText: (text: string) => void;
+    sendPastePayloadFromDataTransfer: (dataTransfer: DataTransfer | null | undefined) => boolean;
+    getLastKeydownSeq: () => string;
+    getLastKeydownSeqAt: () => number;
+    keydownBeforeinputDedupeMs: number;
+    openLink: (url: string) => void;
+};
+export type CreateRuntimeInteractionOptions = {
+    attachCanvasEvents: boolean;
+    touchSelectionMode: "off" | "drag" | "long-press";
+    touchSelectionLongPressMs: number;
+    touchSelectionMoveThresholdPx: number;
+    showOverlayScrollbar: boolean;
+    kittyOverlayDebugEnabled: boolean;
+    imeInput: HTMLTextAreaElement | null;
+    cleanupCanvasFns: Array<() => void>;
+    getCanvas: () => HTMLCanvasElement;
+    getCurrentDpr: () => number;
+    getGridState: () => RuntimeGridState;
+    getLastRenderState: () => RenderState | null;
+    getWasmReady: () => boolean;
+    getWasm: () => ResttyWasm | null;
+    getWasmHandle: () => number;
+    getWasmExports: () => ResttyWasmExports | null;
+    updateLinkHover: (cell: RuntimeCell | null) => void;
+    markNeedsRender: () => void;
+};
+export type RuntimeInteraction = {
+    selectionState: RuntimeSelectionState;
+    linkState: RuntimeLinkState;
+    scrollbarState: RuntimeScrollbarState;
+    imeState: RuntimeImeState;
+    updateCanvasCursor: () => void;
+    syncKittyOverlaySize: () => void;
+    clearKittyOverlay: () => void;
+    drawKittyOverlay: (placements: KittyPlacement[], cellW: number, cellH: number) => void;
+    positionToCell: (event: {
+        clientX: number;
+        clientY: number;
+    }) => RuntimeCell;
+    positionToPixel: (event: {
+        clientX: number;
+        clientY: number;
+    }) => {
+        x: number;
+        y: number;
+    };
+    clearSelection: () => void;
+    updateImePosition: (cursor: {
+        row: number;
+        col: number;
+    } | null | undefined, cellW: number, cellH: number) => void;
+    appendOverlayScrollbar: (overlayData: number[], total: number, offset: number, len: number) => void;
+    bindCanvasEvents: (bindOptions: BindCanvasEventsOptions) => void;
+    detachKittyOverlayCanvas: () => void;
+    clearKittyImageCache: () => void;
+};

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

@@ -0,0 +1,3 @@
+import type { CreateRuntimeInteractionOptions, RuntimeInteraction } from "./interaction-runtime/types";
+export type { BindCanvasEventsOptions, CreateRuntimeInteractionOptions, RuntimeCell, RuntimeInteraction, } from "./interaction-runtime/types";
+export declare function createRuntimeInteraction(options: CreateRuntimeInteractionOptions): RuntimeInteraction;

package/dist/runtime/create-runtime/kitty-overlay-utils.d.ts

@@ -0,0 +1,26 @@
+import type { KittyPlacement } from "../../wasm";
+export type KittyDecodedImageLike = {
+    width: number;
+    height: number;
+};
+export type KittySlice = {
+    sx: number;
+    sy: number;
+    sw: number;
+    sh: number;
+    rawSw: number;
+    rawSh: number;
+    dx: number;
+    dy: number;
+    dw: number;
+    dh: number;
+};
+export declare function kittyHashInt(hash: number, value: number): number;
+export declare function kittyHashString(hash: number, value: string): number;
+export declare function toKittySlice(placement: KittyPlacement, decoded: KittyDecodedImageLike, cellW: number, cellH: number): KittySlice | null;
+export declare function computeKittyPartialVirtualFallback(placements: KittyPlacement[], slices: KittySlice[], decoded: KittyDecodedImageLike, cellW: number, cellH: number): {
+    dx: number;
+    dy: number;
+    dw: number;
+    dh: number;
+} | null;

package/dist/runtime/create-runtime/lifecycle-theme-size-canvas.d.ts

@@ -0,0 +1,13 @@
+import type { LifecycleThemeSizeDeps } from "./lifecycle-theme-size.types";
+export declare function createLifecycleCanvasHandlers(deps: LifecycleThemeSizeDeps): {
+    replaceCanvas: () => void;
+    updateSize: (force?: boolean) => void;
+    resize: (cols: number, rows: number) => void;
+    scheduleSizeUpdate: () => void;
+    focusTypingInput: () => void;
+    focus: () => void;
+    blur: () => void;
+    bindFocusEvents: () => void;
+    bindAutoResizeEvents: () => void;
+    cancelScheduledSizeUpdate: () => void;
+};

package/dist/runtime/create-runtime/lifecycle-theme-size-theme.d.ts

@@ -0,0 +1,6 @@
+import { type GhosttyTheme } from "../../theme";
+import type { LifecycleThemeSizeDeps } from "./lifecycle-theme-size.types";
+export declare function createLifecycleThemeHandlers(deps: LifecycleThemeSizeDeps): {
+    applyTheme: (theme: GhosttyTheme | null | undefined, sourceLabel?: string) => void;
+    resetTheme: () => void;
+};