restty 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wiedy Mi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# restty
+
+![CI](https://img.shields.io/badge/CI-GitHub%20Actions-2088FF?logo=githubactions&logoColor=white)
+![Bun](https://img.shields.io/badge/Bun-%3E%3D1.2.0-f9f1e1?logo=bun&logoColor=000)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+
+Experimental project: browser terminal rendering with a WASM terminal core, GPU rendering (WebGPU + WebGL2 fallback), and TypeScript text shaping.
+
+restty combines a Zig/WASM VT engine, modern browser rendering pipelines, and a local playground + PTY server to iterate quickly on terminal behavior.
+
+## Why
+
+- Build a browser terminal stack with explicit control over rendering and input.
+- Keep terminal state logic in WASM while using TS/JS for browser integration.
+- Validate behavior with focused tests (input mapping, UTF-8 handling, kitty graphics, glyph rendering).
+- Iterate visually via a local playground without heavy framework overhead.
+
+## How it works
+
+1. PTY output bytes are fed into the WASM terminal core.
+2. WASM exposes render/cell state to the TypeScript runtime.
+3. Text shaping and glyph atlas generation happen in TS.
+4. Renderer draws frames via WebGPU (or WebGL2 fallback).
+5. Input (keyboard/mouse/IME) is encoded and sent back to PTY.
+
+## Documentation
+
+- Start here: `docs/README.md`
+- Initial goals and scope: `docs/goals.md`
+- End-to-end runtime flow: `docs/how-it-works.md`
+- Integration and usage: `docs/usage.md`
+- Internal architecture notes: `docs/internals/`
+
+## Repository layout
+
+- `src/` - Main library/runtime code (renderer, input, PTY bridge, app integration).
+- `tests/` - Bun test suite.
+- `playground/` - Browser playground app and local PTY websocket server.
+- `playground/public/` - Playground static assets (fonts/wasm bundles).
+- `assets/themes/` - Source-of-truth Ghostty theme files.
+- `scripts/` - Setup helper scripts.
+- `wasm/` - Zig source and build config for the WASM core.
+- `docs/` - User docs, architecture notes, and development references.
+- `reference/ghostty` - Upstream Ghostty reference (submodule).
+- `reference/text-shaper` - Upstream text-shaper reference (submodule).
+
+## Requirements
+
+- Bun `>=1.2.0`
+- Git with submodule support
+- Optional: Zig (if rebuilding WASM artifacts from source)
+
+## Quick start
+
+```bash
+git submodule update --init --recursive
+bun install
+bun run build:themes
+bun run build:assets
+bun run playground
+```
+
+Open `http://localhost:5173`.
+
+## Commands
+
+```bash
+# Run all tests
+bun run test
+
+# Start PTY websocket server (default ws://localhost:8787/pty)
+bun run pty
+
+# Build playground/runtime bundles
+bun run build:assets
+
+# Regenerate embedded built-in theme catalog for the library
+bun run build:themes
+
+# Lint + format checks
+bun run lint
+bun run format:check
+
+# Serve playground static files only
+bun run playground:static
+```
+
+## Testing
+
+Current suite covers:
+
+- key/input encoding (`tests/input-keymap.test.ts`, `tests/input-kitty.test.ts`)
+- PTY UTF-8 stream behavior (`tests/pty-utf8.test.ts`)
+- output filtering and kitty graphics (`tests/output-filter.test.ts`, `tests/kitty-*.test.ts`)
+- renderer/glyph checks (`tests/box-drawing.test.ts`, `tests/webgpu-glyph.test.ts`)
+
+## Notes
+
+- `tests/webgpu-glyph.test.ts` can bootstrap polyfill artifacts via `scripts/setup-wgpu-polyfill.ts`.
+- Built-in themes are embedded in `src/theme/builtin-themes.ts` (generated via `scripts/generate-builtin-themes.ts`).
+- Some generated playground assets are intentionally committed for reproducible local runs.

package/dist/app/atlas-builder.d.ts

@@ -0,0 +1,81 @@
+export type GlyphConstraintMeta = {
+    cp: number;
+    constraintWidth: number;
+    variable?: boolean;
+    widths?: Set<number>;
+};
+export type AtlasConstraintContext = {
+    cellW: number;
+    cellH: number;
+    yPad: number;
+    baselineOffset: number;
+    baselineAdjust: number;
+    fontScale: number;
+    nerdMetrics: {
+        cellWidth: number;
+        cellHeight: number;
+        faceWidth: number;
+        faceHeight: number;
+        faceY: number;
+        iconHeight: number;
+        iconHeightSingle: number;
+    };
+    fontEntry: any;
+};
+type BuildAtlasDeps = {
+    fontScaleOverrides: Array<{
+        match: RegExp;
+        scale: number;
+    }>;
+    sizeMode: string;
+    isSymbolFont: (entry: any) => boolean;
+    fontScaleOverride: (entry: any, overrides: Array<{
+        match: RegExp;
+        scale: number;
+    }>) => number;
+    resolveGlyphPixelMode: (entry: any) => number;
+    atlasBitmapToRGBA: (atlas: any) => Uint8Array | null;
+    padAtlasRGBA: (rgba: Uint8Array, atlas: any, padding: number) => Uint8Array;
+    buildAtlas: (font: any, glyphIds: number[], options: any) => any;
+    buildGlyphAtlasWithConstraints: (options: any) => {
+        atlas: any;
+        constrainedGlyphWidths?: any;
+    } | null;
+    buildColorEmojiAtlasWithCanvas: (options: any) => {
+        atlas: any;
+    } | null;
+    rasterizeGlyph?: any;
+    rasterizeGlyphWithTransform?: any;
+    nerdConstraintSignature: (glyphMeta: Map<number, GlyphConstraintMeta> | undefined, constraintContext: AtlasConstraintContext | null | undefined) => string;
+    constants: {
+        atlasPadding: number;
+        symbolAtlasPadding: number;
+        symbolAtlasMaxSize: number;
+        defaultAtlasMaxSize: number;
+        pixelModeRgbaValue: number;
+    };
+    resolvePreferNearest: (params: {
+        fontIndex: number;
+        isSymbol: boolean;
+        atlasScale: number;
+    }) => boolean;
+};
+export type BuildFontAtlasParams = {
+    entry: any;
+    neededGlyphIds: Set<number>;
+    glyphMeta?: Map<number, GlyphConstraintMeta>;
+    fontSizePx: number;
+    atlasScale: number;
+    fontIndex: number;
+    constraintContext?: AtlasConstraintContext | null;
+    deps: BuildAtlasDeps;
+};
+export type BuildFontAtlasResult = {
+    rebuilt: boolean;
+    atlas: any | null;
+    rgba: Uint8Array | null;
+    colorGlyphs?: Set<number>;
+    preferNearest: boolean;
+};
+export declare function buildFontAtlasIfNeeded(params: BuildFontAtlasParams): BuildFontAtlasResult;
+export {};

package/dist/app/index.d.ts

@@ -0,0 +1,3 @@
+import type { ResttyApp, ResttyAppOptions } from "./types";
+export type { TextShaper, ResttyAppElements, ResttyAppCallbacks, FontSource, ResttyAppOptions, ResttyApp, } from "./types";
+export declare function createResttyApp(options: ResttyAppOptions): ResttyApp;

package/dist/app/types.d.ts

@@ -0,0 +1,133 @@
+import type { InputHandler } from "../input";
+import type { GhosttyTheme } from "../theme";
+export type TextShaper = {
+    Font: {
+        loadAsync: (buffer: ArrayBuffer) => Promise<any>;
+        collection?: (buffer: ArrayBuffer) => {
+            names: () => Array<{
+                index: number;
+                fullName?: string;
+                family?: string;
+                postScriptName?: string;
+            }>;
+            get: (index: number) => any;
+        } | null;
+    };
+    UnicodeBuffer: new () => {
+        addStr: (text: string) => void;
+    };
+    shape: (font: any, buffer: any) => any;
+    glyphBufferToShapedGlyphs: (glyphBuffer: any) => Array<{
+        glyphId: number;
+        xAdvance: number;
+        xOffset: number;
+        yOffset: number;
+    }>;
+    buildAtlas: (font: any, glyphIds: number[], options: any) => any;
+    atlasToRGBA: (atlas: any) => Uint8Array | null;
+    rasterizeGlyph?: (font: any, glyphId: number, fontSize: number, options?: any) => {
+        bitmap: any;
+        bearingX: number;
+        bearingY: number;
+    } | null;
+    rasterizeGlyphWithTransform?: (font: any, glyphId: number, fontSize: number, matrix: number[] | number[][], options?: any) => {
+        bitmap: any;
+        bearingX: number;
+        bearingY: number;
+    } | null;
+    PixelMode: {
+        Gray: any;
+        RGBA?: any;
+    };
+};
+export type ResttyAppElements = {
+    backendEl?: HTMLElement | null;
+    fpsEl?: HTMLElement | null;
+    dprEl?: HTMLElement | null;
+    sizeEl?: HTMLElement | null;
+    gridEl?: HTMLElement | null;
+    cellEl?: HTMLElement | null;
+    termSizeEl?: HTMLElement | null;
+    cursorPosEl?: HTMLElement | null;
+    inputDebugEl?: HTMLElement | null;
+    dbgEl?: HTMLElement | null;
+    ptyStatusEl?: HTMLElement | null;
+    mouseStatusEl?: HTMLElement | null;
+    termDebugEl?: HTMLElement | null;
+    logEl?: HTMLElement | null;
+    atlasInfoEl?: HTMLElement | null;
+    atlasCanvas?: HTMLCanvasElement | null;
+};
+export type ResttyAppCallbacks = {
+    onLog?: (line: string) => void;
+    onBackend?: (backend: string) => void;
+    onFps?: (fps: number) => void;
+    onDpr?: (dpr: number) => void;
+    onCanvasSize?: (width: number, height: number) => void;
+    onGridSize?: (cols: number, rows: number) => void;
+    onCellSize?: (cellW: number, cellH: number) => void;
+    onTermSize?: (cols: number, rows: number) => void;
+    onCursor?: (col: number, row: number) => void;
+    onDebug?: (text: string) => void;
+    onInputDebug?: (text: string) => void;
+    onPtyStatus?: (status: string) => void;
+    onMouseStatus?: (status: string) => void;
+};
+export type FontSource = {
+    name: string;
+    url?: string;
+    buffer?: ArrayBuffer;
+    matchers?: string[];
+};
+export type ResttyAppOptions = {
+    canvas: HTMLCanvasElement;
+    imeInput?: HTMLTextAreaElement | null;
+    textShaper: TextShaper;
+    elements?: ResttyAppElements;
+    callbacks?: ResttyAppCallbacks;
+    renderer?: "auto" | "webgpu" | "webgl2";
+    fontSize?: number;
+    assetBaseUrl?: string;
+    alphaBlending?: "native" | "linear" | "linear-corrected";
+    fontSources?: {
+        primary?: {
+            url?: string;
+            buffer?: ArrayBuffer;
+            matchers?: string[];
+        };
+        fallbacks?: FontSource[];
+    };
+    maxSymbolAtlasScale?: number;
+    fontScaleOverrides?: {
+        match: RegExp;
+        scale: number;
+    }[];
+    nerdIconScale?: number;
+    autoResize?: boolean;
+    attachWindowEvents?: boolean;
+    attachCanvasEvents?: boolean;
+    debugExpose?: boolean;
+};
+export type ResttyApp = {
+    init: () => Promise<void>;
+    destroy: () => void;
+    setRenderer: (value: "auto" | "webgpu" | "webgl2") => void;
+    setPaused: (value: boolean) => void;
+    togglePause: () => void;
+    setFontSize: (value: number) => void;
+    applyTheme: (theme: GhosttyTheme, sourceLabel?: string) => void;
+    resetTheme: () => void;
+    sendInput: (text: string, source?: string) => void;
+    sendKeyInput: (text: string, source?: string) => void;
+    clearScreen: () => void;
+    connectPty: (url: string) => void;
+    disconnectPty: () => void;
+    isPtyConnected: () => boolean;
+    setMouseMode: (value: string) => void;
+    getMouseStatus: () => ReturnType<InputHandler["getMouseStatus"]>;
+    copySelectionToClipboard: () => Promise<boolean>;
+    pasteFromClipboard: () => Promise<boolean>;
+    dumpAtlasForCodepoint: (cp: number) => void;
+    updateSize: (force?: boolean) => void;
+    getBackend: () => string;
+};

package/dist/fonts/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./manager";
+export * from "./nerd-ranges";
+export * from "./nerd-constraints";

package/dist/fonts/manager.d.ts

@@ -0,0 +1,21 @@
+import type { FontEntry, FontManagerState, ShapedCluster, FallbackFontSource, FontScaleOverride } from "./types";
+export declare function isSymbolFont(entry: FontEntry | null | undefined): boolean;
+export declare function isNerdSymbolFont(entry: FontEntry | null | undefined): boolean;
+export declare function isColorEmojiFont(entry: FontEntry | null | undefined): boolean;
+export declare function fontMaxCellSpan(entry: FontEntry | null | undefined): number;
+export declare function fontScaleOverride(entry: FontEntry | null | undefined, overrides?: FontScaleOverride[]): number;
+export declare function fontRasterScale(entry: FontEntry | null | undefined, fontIndex: number, maxSymbolAtlasScale: number, overrides?: FontScaleOverride[]): number;
+export declare function createFontEntry(font: any, label: string): FontEntry;
+export declare function resetFontEntry(entry: FontEntry): void;
+export declare function createFontManagerState(): FontManagerState;
+export declare function fontHasGlyph(font: any, ch: string): boolean;
+export declare function fontAdvanceUnits(entry: FontEntry, shapeClusterWithFont: (entry: FontEntry, text: string) => ShapedCluster): number;
+export declare function glyphWidthUnits(entry: FontEntry, glyphId: number | undefined | null): number;
+export declare function pickFontIndexForText(state: FontManagerState, text: string, expectedSpan: number, shapeClusterWithFont: (entry: FontEntry, text: string) => ShapedCluster): number;
+export declare function tryFetchFontBuffer(url: string): Promise<ArrayBuffer | null>;
+export declare function tryLocalFontBuffer(matchers: string[]): Promise<ArrayBuffer | null>;
+export declare function loadPrimaryFontBuffer(localMatchers: string[], fallbackUrl: string, fallbackLocalMatchers: string[]): Promise<ArrayBuffer>;
+export declare function loadFallbackFontBuffers(sources: FallbackFontSource[]): Promise<{
+    name: string;
+    buffer: ArrayBuffer;
+}[]>;

package/dist/fonts/nerd-constraints.d.ts

@@ -0,0 +1,23 @@
+export type NerdConstraint = {
+    size?: "none" | "fit" | "cover" | "fit_cover1" | "stretch";
+    align_horizontal?: "none" | "start" | "end" | "center" | "center1";
+    align_vertical?: "none" | "start" | "end" | "center" | "center1";
+    height?: "cell" | "icon";
+    pad_left?: number;
+    pad_right?: number;
+    pad_top?: number;
+    pad_bottom?: number;
+    relative_width?: number;
+    relative_height?: number;
+    relative_x?: number;
+    relative_y?: number;
+    max_xy_ratio?: number;
+    max_constraint_width?: number;
+};
+export type NerdConstraintRange = {
+    start: number;
+    end: number;
+    constraint: NerdConstraint;
+};
+export declare const NERD_CONSTRAINTS: NerdConstraintRange[];
+export declare function getNerdConstraint(cp: number): NerdConstraint | null;

package/dist/fonts/nerd-ranges.d.ts

@@ -0,0 +1,2 @@
+export declare const NERD_SYMBOL_RANGES: Array<[number, number]>;
+export declare function isNerdSymbolCodepoint(cp: number): boolean;

package/dist/fonts/types.d.ts

@@ -0,0 +1,40 @@
+export type FontEntry = {
+    font: any;
+    label: string;
+    glyphCache: Map<string, ShapedCluster>;
+    boundsCache: Map<number, number>;
+    colorGlyphTexts: Map<number, string>;
+    glyphIds: Set<number>;
+    atlas: any | null;
+    fontSizePx: number;
+    atlasScale: number;
+    advanceUnits: number;
+    constraintSignature?: string;
+};
+export type ShapedCluster = {
+    glyphs: ShapedGlyph[];
+    advance: number;
+};
+export type ShapedGlyph = {
+    glyphId: number;
+    xAdvance: number;
+    yAdvance: number;
+    xOffset: number;
+    yOffset: number;
+};
+export type FontManagerState = {
+    font: any | null;
+    fonts: FontEntry[];
+    fontSizePx: number;
+    sizeMode: "height" | "width" | "upem";
+    fontPickCache: Map<string, number>;
+};
+export type FallbackFontSource = {
+    name: string;
+    url: string;
+    matchers: string[];
+};
+export type FontScaleOverride = {
+    match: RegExp;
+    scale: number;
+};

package/dist/grid/grid.d.ts

@@ -0,0 +1,22 @@
+import type { CellMetrics, GridConfig, GridState } from "./types";
+export type FontMetricsProvider = {
+    scaleForSize(sizePx: number, sizeMode: string): number;
+    glyphIdForChar(char: string): number | undefined | null;
+    advanceWidth(glyphId: number): number;
+    readonly ascender: number;
+    readonly descender?: number;
+    readonly height?: number;
+    readonly upem: number;
+};
+export type ShapeResult = {
+    advance: number;
+};
+export declare function fontHeightUnits(font: FontMetricsProvider): number;
+export declare function computeCellMetrics(font: FontMetricsProvider, config: GridConfig, dpr: number, shapeCluster: (text: string) => ShapeResult): CellMetrics | null;
+export declare function createGridState(): GridState;
+export declare function updateGridState(state: GridState, metrics: CellMetrics, canvasWidth: number, canvasHeight: number): {
+    changed: boolean;
+    cols: number;
+    rows: number;
+};
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/grid/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./grid";

package/dist/grid/types.d.ts

@@ -0,0 +1,24 @@
+export type GridState = {
+    cols: number;
+    rows: number;
+    cellW: number;
+    cellH: number;
+    fontSizePx: number;
+    scale: number;
+    lineHeight: number;
+    baselineOffset: number;
+    yPad: number;
+};
+export type CellMetrics = {
+    cellW: number;
+    cellH: number;
+    fontSizePx: number;
+    scale: number;
+    lineHeight: number;
+    baselineOffset: number;
+    yPad: number;
+};
+export type GridConfig = {
+    fontSize: number;
+    sizeMode: "height" | "width" | "upem";
+};

package/dist/ime/ime.d.ts

@@ -0,0 +1,14 @@
+import type { ImeState, CursorPosition } from "./types";
+export declare function createImeState(): ImeState;
+export declare function setPreedit(state: ImeState, text: string, imeInput?: HTMLInputElement | null): void;
+export declare function clearPreedit(state: ImeState, imeInput?: HTMLInputElement | null): void;
+export declare function startComposition(state: ImeState, data: string, imeInput?: HTMLInputElement | null): void;
+export declare function updateComposition(state: ImeState, data: string, imeInput?: HTMLInputElement | null): void;
+export declare function endComposition(state: ImeState): string;
+export declare function syncImeSelection(state: ImeState, imeInput: HTMLInputElement | null): void;
+export declare function updateImePosition(imeInput: HTMLInputElement | null, cursor: CursorPosition | null, cellW: number, cellH: number, dpr: number, canvasRect: DOMRect): void;
+export declare const PREEDIT_BG: readonly [0.16, 0.16, 0.2, 0.9];
+export declare const PREEDIT_ACTIVE_BG: readonly [0.3, 0.32, 0.42, 0.95];
+export declare const PREEDIT_FG: readonly [0.95, 0.95, 0.98, 1];
+export declare const PREEDIT_UL: readonly [0.7, 0.7, 0.8, 0.9];
+export declare const PREEDIT_CARET: readonly [0.95, 0.95, 0.98, 1];

package/dist/ime/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./ime";

package/dist/ime/types.d.ts

@@ -0,0 +1,10 @@
+export type ImeState = {
+    composing: boolean;
+    preedit: string;
+    selectionStart: number;
+    selectionEnd: number;
+};
+export type CursorPosition = {
+    row: number;
+    col: number;
+};

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { type Color, type RectData, type GlyphBox, type NerdMetrics, type WebGPUState, type WebGLState, type WebGLAtlasState, type AtlasState, type RendererState, type RendererConfig, type ResizeState, type ScrollbarState, BOX_STYLE_NONE, BOX_STYLE_LIGHT, BOX_STYLE_HEAVY, BOX_STYLE_DOUBLE, BOX_LINE_MAP, RECT_SHADER, GLYPH_SHADER, isPrivateUse, isSpaceCp, isBoxDrawing, isBlockElement, isLegacyComputing, isPowerline, isBraille, isGraphicsElement, isSymbolCp, applyAlpha, pushRect, pushRectSnapped, pushRectBox, drawBlockElement, drawBoxDrawing, drawBraille, drawPowerline, constrainGlyphBox, initWebGPU, initWebGL, ensureInstanceBuffer, ensureGLInstanceBuffer, configureContext, createResizeState, createScrollbarState, } from "./renderer";
+export { type GridState, type CellMetrics, type GridConfig, type FontMetricsProvider, type ShapeResult, fontHeightUnits, computeCellMetrics, createGridState, updateGridState, clamp, } from "./grid";
+export { type FontEntry, type FontManagerState, type ShapedCluster, type ShapedGlyph, type FallbackFontSource, type FontScaleOverride, type NerdConstraint, type NerdConstraintRange, isSymbolFont, isNerdSymbolFont, fontMaxCellSpan, fontScaleOverride, fontRasterScale, createFontEntry, resetFontEntry, createFontManagerState, fontHasGlyph, fontAdvanceUnits, glyphWidthUnits, pickFontIndexForText, tryFetchFontBuffer, tryLocalFontBuffer, loadPrimaryFontBuffer, loadFallbackFontBuffers, isNerdSymbolCodepoint, NERD_SYMBOL_RANGES, getNerdConstraint, NERD_CONSTRAINTS, } from "./fonts";
+export { type SelectionState, type SelectionRange, type CellTextGetter, createSelectionState, clearSelection, startSelection, updateSelection, endSelection, selectionForRow, getSelectionText, normalizeSelectionCell, positionToCell, copyToClipboard, pasteFromClipboard, } from "./selection";
+export type { CellPosition } from "./selection";
+export { type ImeState, createImeState, setPreedit, clearPreedit, startComposition, updateComposition, endComposition, syncImeSelection, updateImePosition, PREEDIT_BG, PREEDIT_ACTIVE_BG, PREEDIT_FG, PREEDIT_UL, PREEDIT_CARET, } from "./ime";
+export type { CursorPosition } from "./ime";
+export { type PtyMessage, type PtyStatusMessage, type PtyErrorMessage, type PtyExitMessage, type PtyServerMessage, type PtyConnectionState, type PtyCallbacks, createPtyConnection, connectPty, disconnectPty, sendPtyInput, sendPtyResize, isPtyConnected, } from "./pty";
+export { createInputHandler } from "./input";
+export type { InputHandler, InputHandlerConfig, InputHandlerOptions, MouseMode, MouseStatus, } from "./input";
+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 { createResttyApp } from "./app";
+export type { ResttyApp, ResttyAppOptions, ResttyAppElements, ResttyAppCallbacks, TextShaper, } from "./app";