restty 0.1.24 → 0.1.26

package/dist/renderer/shapes/box-drawing/dashed-lines.d.ts

@@ -0,0 +1,3 @@
+import type { Color, RectData } from "../types";
+export declare function drawDashedHorizontal(count: number, thickness: number, desiredGap: number, x: number, y: number, cellWInt: number, cellHInt: number, color: Color, out: RectData): void;
+export declare function drawDashedVertical(count: number, thickness: number, desiredGap: number, x: number, y: number, cellWInt: number, cellHInt: number, color: Color, out: RectData): void;

package/dist/renderer/shapes/box-drawing/diagonal.d.ts

@@ -0,0 +1,2 @@
+import type { Color, RectData } from "../types";
+export declare function drawDiagonal(dir: "ul_lr" | "ur_ll", x: number, y: number, cellW: number, cellH: number, light: number, color: Color, out: RectData): void;

package/dist/renderer/shapes/box-drawing/draw-box-drawing.d.ts

@@ -0,0 +1,6 @@
+import type { Color, RectData } from "../types";
+/**
+ * Rasterize a Unicode Box Drawing character (U+2500-U+257F) into rect instances.
+ * Handles straight segments, dashed lines, rounded corners, and diagonal lines.
+ */
+export declare function drawBoxDrawing(cp: number, x: number, y: number, cellW: number, cellH: number, color: Color, out: RectData, boxThicknessPx?: number): boolean;

package/dist/renderer/shapes/box-drawing/fallback.d.ts

@@ -0,0 +1,2 @@
+import type { Color, RectData } from "../types";
+export declare function drawFallbackBoxDrawing(cp: number, x: number, y: number, cellW: number, cellH: number, color: Color, out: RectData, light: number, heavy: number): boolean;

package/dist/renderer/shapes/box-drawing/mapped.d.ts

@@ -0,0 +1,2 @@
+import { type Color, type RectData } from "../types";
+export declare function drawMappedBoxDrawing(spec: readonly [number, number, number, number], x: number, y: number, cellW: number, cellH: number, color: Color, out: RectData, lightStroke: number, heavyStroke: number): boolean;

package/dist/renderer/shapes/box-drawing/rounded-corner.d.ts

@@ -0,0 +1,2 @@
+import type { Color, RectData } from "../types";
+export declare function drawRoundedCorner(cornerCp: 0x256d | 0x256e | 0x256f | 0x2570, x: number, y: number, cellW: number, cellH: number, light: number, color: Color, out: RectData): void;

package/dist/renderer/shapes/braille.d.ts

@@ -0,0 +1,3 @@
+import type { Color, RectData } from "./types";
+/** Rasterize a Unicode Braille Pattern (U+2800-U+28FF) into rect dot instances. */
+export declare function drawBraille(cp: number, x: number, y: number, cellW: number, cellH: number, color: Color, out: RectData): boolean;

package/dist/renderer/shapes/classify.d.ts

@@ -0,0 +1,18 @@
+/** Test whether a codepoint falls in a Unicode Private Use Area. */
+export declare function isPrivateUse(cp: number): boolean;
+/** Test whether a codepoint is a space-like character (NUL, SP, or EN SPACE). */
+export declare function isSpaceCp(cp: number): boolean;
+/** Test whether a codepoint is in the Box Drawing block (U+2500-U+257F). */
+export declare function isBoxDrawing(cp: number): boolean;
+/** Test whether a codepoint is in the Block Elements block (U+2580-U+259F). */
+export declare function isBlockElement(cp: number): boolean;
+/** Test whether a codepoint is in the Legacy Computing Symbols blocks. */
+export declare function isLegacyComputing(cp: number): boolean;
+/** Test whether a codepoint is a Powerline symbol (U+E0B0-U+E0D7). */
+export declare function isPowerline(cp: number): boolean;
+/** Test whether a codepoint is in the Braille Patterns block (U+2800-U+28FF). */
+export declare function isBraille(cp: number): boolean;
+/** Test whether a codepoint is any GPU-drawable graphics element (box, block, legacy, powerline). */
+export declare function isGraphicsElement(cp: number): boolean;
+/** Test whether a codepoint is a symbol that may need special rendering (PUA or graphics). */
+export declare function isSymbolCp(cp: number): boolean;

package/dist/renderer/shapes/geometry.d.ts

@@ -0,0 +1,9 @@
+import type { Color, RectData } from "./types";
+/** Return a new color with its alpha channel multiplied by the given factor. */
+export declare function applyAlpha(color: Color, alpha: number): Color;
+/** Append a rect instance (position, size, color) to the output array. */
+export declare function pushRect(out: RectData, x: number, y: number, w: number, h: number, color: Color): void;
+/** Append a rect snapped to pixel boundaries (floor origin, ceil extent). */
+export declare function pushRectSnapped(out: RectData, x: number, y: number, w: number, h: number, color: Color): void;
+/** Append a rect with rounded position and at-least-1px dimensions for box drawing. */
+export declare function pushRectBox(out: RectData, x: number, y: number, w: number, h: number, color: Color): void;

package/dist/renderer/shapes/glyph-box.d.ts

@@ -0,0 +1,7 @@
+import type { NerdConstraint } from "../../fonts/nerd-constraints";
+import type { GlyphBox, NerdMetrics } from "./types";
+/**
+ * Apply a Nerd Font constraint to a glyph bounding box, adjusting size and
+ * alignment to fit within the cell according to the constraint rules.
+ */
+export declare function constrainGlyphBox(glyph: GlyphBox, constraint: NerdConstraint, metrics: NerdMetrics, constraintWidth: number): GlyphBox;

package/dist/renderer/shapes/powerline.d.ts

@@ -0,0 +1,3 @@
+import type { Color, RectData } from "./types";
+/** Rasterize a Powerline glyph (U+E0B0-U+E0D7) into rect scanline instances. */
+export declare function drawPowerline(cp: number, x: number, y: number, cellW: number, cellH: number, color: Color, out: RectData): boolean;

package/dist/renderer/shapes/types.d.ts

@@ -0,0 +1,38 @@
+/** RGBA color tuple with components in 0-1 range. */
+export type Color = [number, number, number, number];
+/** Flat array of rect instance data (x, y, w, h, r, g, b, a per rect). */
+export type RectData = number[];
+/**
+ * Font metrics used for Nerd Font glyph constraint calculations.
+ */
+export type NerdMetrics = {
+    /** Cell width in pixels. */
+    cellWidth: number;
+    /** Cell height in pixels. */
+    cellHeight: number;
+    /** Font face bounding-box width. */
+    faceWidth: number;
+    /** Font face bounding-box height. */
+    faceHeight: number;
+    /** Vertical offset of the font face within the cell. */
+    faceY: number;
+    /** Target icon height for multi-cell-width glyphs. */
+    iconHeight: number;
+    /** Target icon height for single-cell-width glyphs. */
+    iconHeightSingle: number;
+};
+/** Positioned bounding box for a rendered glyph. */
+export type GlyphBox = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** Box-drawing line style: no line. */
+export declare const BOX_STYLE_NONE = 0;
+/** Box-drawing line style: thin/light stroke. */
+export declare const BOX_STYLE_LIGHT = 1;
+/** Box-drawing line style: thick/heavy stroke. */
+export declare const BOX_STYLE_HEAVY = 2;
+/** Box-drawing line style: double parallel strokes. */
+export declare const BOX_STYLE_DOUBLE = 3;

package/dist/renderer/shapes.d.ts

@@ -1,81 +1,8 @@
-import type { NerdConstraint } from "../fonts/nerd-constraints";
-/** RGBA color tuple with components in 0-1 range. */
-export type Color = [number, number, number, number];
-/** Flat array of rect instance data (x, y, w, h, r, g, b, a per rect). */
-export type RectData = number[];
-/**
- * Font metrics used for Nerd Font glyph constraint calculations.
- */
-export type NerdMetrics = {
-    /** Cell width in pixels. */
-    cellWidth: number;
-    /** Cell height in pixels. */
-    cellHeight: number;
-    /** Font face bounding-box width. */
-    faceWidth: number;
-    /** Font face bounding-box height. */
-    faceHeight: number;
-    /** Vertical offset of the font face within the cell. */
-    faceY: number;
-    /** Target icon height for multi-cell-width glyphs. */
-    iconHeight: number;
-    /** Target icon height for single-cell-width glyphs. */
-    iconHeightSingle: number;
-};
-/** Positioned bounding box for a rendered glyph. */
-export type GlyphBox = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-/** Box-drawing line style: no line. */
-export declare const BOX_STYLE_NONE = 0;
-/** Box-drawing line style: thin/light stroke. */
-export declare const BOX_STYLE_LIGHT = 1;
-/** Box-drawing line style: thick/heavy stroke. */
-export declare const BOX_STYLE_HEAVY = 2;
-/** Box-drawing line style: double parallel strokes. */
-export declare const BOX_STYLE_DOUBLE = 3;
-/** Test whether a codepoint falls in a Unicode Private Use Area. */
-export declare function isPrivateUse(cp: number): boolean;
-/** Test whether a codepoint is a space-like character (NUL, SP, or EN SPACE). */
-export declare function isSpaceCp(cp: number): boolean;
-/** Test whether a codepoint is in the Box Drawing block (U+2500-U+257F). */
-export declare function isBoxDrawing(cp: number): boolean;
-/** Test whether a codepoint is in the Block Elements block (U+2580-U+259F). */
-export declare function isBlockElement(cp: number): boolean;
-/** Test whether a codepoint is in the Legacy Computing Symbols blocks. */
-export declare function isLegacyComputing(cp: number): boolean;
-/** Test whether a codepoint is a Powerline symbol (U+E0B0-U+E0D7). */
-export declare function isPowerline(cp: number): boolean;
-/** Test whether a codepoint is in the Braille Patterns block (U+2800-U+28FF). */
-export declare function isBraille(cp: number): boolean;
-/** Test whether a codepoint is any GPU-drawable graphics element (box, block, legacy, powerline). */
-export declare function isGraphicsElement(cp: number): boolean;
-/** Test whether a codepoint is a symbol that may need special rendering (PUA or graphics). */
-export declare function isSymbolCp(cp: number): boolean;
-/** Return a new color with its alpha channel multiplied by the given factor. */
-export declare function applyAlpha(color: Color, alpha: number): Color;
-/** Append a rect instance (position, size, color) to the output array. */
-export declare function pushRect(out: RectData, x: number, y: number, w: number, h: number, color: Color): void;
-/** Append a rect snapped to pixel boundaries (floor origin, ceil extent). */
-export declare function pushRectSnapped(out: RectData, x: number, y: number, w: number, h: number, color: Color): void;
-/** Append a rect with rounded position and at-least-1px dimensions for box drawing. */
-export declare function pushRectBox(out: RectData, x: number, y: number, w: number, h: number, color: Color): void;
-/** Rasterize a Unicode Block Element (U+2580-U+259F) into rect instances. */
-export declare function drawBlockElement(cp: number, x: number, y: number, cellW: number, cellH: number, color: Color, out: RectData): boolean;
-/**
- * Rasterize a Unicode Box Drawing character (U+2500-U+257F) into rect instances.
- * Handles straight segments, dashed lines, rounded corners, and diagonal lines.
- */
-export declare function drawBoxDrawing(cp: number, x: number, y: number, cellW: number, cellH: number, color: Color, out: RectData, boxThicknessPx?: number): boolean;
-/** Rasterize a Unicode Braille Pattern (U+2800-U+28FF) into rect dot instances. */
-export declare function drawBraille(cp: number, x: number, y: number, cellW: number, cellH: number, color: Color, out: RectData): boolean;
-/** Rasterize a Powerline glyph (U+E0B0-U+E0D7) into rect scanline instances. */
-export declare function drawPowerline(cp: number, x: number, y: number, cellW: number, cellH: number, color: Color, out: RectData): boolean;
-/**
- * Apply a Nerd Font constraint to a glyph bounding box, adjusting size and
- * alignment to fit within the cell according to the constraint rules.
- */
-export declare function constrainGlyphBox(glyph: GlyphBox, constraint: NerdConstraint, metrics: NerdMetrics, constraintWidth: number): GlyphBox;
+export * from "./shapes/types";
+export * from "./shapes/classify";
+export * from "./shapes/geometry";
+export * from "./shapes/block-elements";
+export * from "./shapes/box-drawing/draw-box-drawing";
+export * from "./shapes/braille";
+export * from "./shapes/powerline";
+export * from "./shapes/glyph-box";

package/dist/renderer/webgpu/buffers.d.ts

@@ -0,0 +1,7 @@
+import type { WebGLState, WebGPUState } from "../types";
+/** Grow a WebGPU instance buffer if the required byte length exceeds current capacity. */
+export declare function ensureInstanceBuffer(state: WebGPUState, kind: "rect" | "glyph", byteLength: number): void;
+/** Re-configure the WebGPU canvas context with the current device and format. */
+export declare function configureContext(state: WebGPUState): void;
+/** Grow a WebGL instance buffer if the required byte length exceeds current capacity. */
+export declare function ensureGLInstanceBuffer(state: WebGLState, kind: "rect" | "glyph", byteLength: number): void;

package/dist/renderer/webgpu/setup.d.ts

@@ -0,0 +1,10 @@
+import type { WebGPUCoreState, WebGPUState } from "../types";
+/** Initialize shared WebGPU core state (device, pipelines, vertex buffer) from a canvas. */
+export declare function initWebGPUCore(canvas: HTMLCanvasElement): Promise<WebGPUCoreState | null>;
+/**
+ * Initialize a full WebGPU renderer state for a canvas, including context,
+ * uniform buffer, and bind groups. Accepts an optional pre-initialized core.
+ */
+export declare function initWebGPU(canvas: HTMLCanvasElement, options?: {
+    core?: WebGPUCoreState | null;
+}): Promise<WebGPUState | null>;

package/dist/renderer/webgpu/state.d.ts

@@ -0,0 +1,15 @@
+/** Create the initial resize tracking state with default values. */
+export declare function createResizeState(): {
+    active: boolean;
+    lastAt: number;
+    cols: number;
+    rows: number;
+    dpr: number;
+};
+/** Create the initial scrollbar position state with default values. */
+export declare function createScrollbarState(): {
+    lastInputAt: number;
+    lastTotal: number;
+    lastOffset: number;
+    lastLen: number;
+};

package/dist/renderer/webgpu/webgl.d.ts

@@ -0,0 +1,3 @@
+import type { WebGLState } from "../types";
+/** Initialize a WebGL2 fallback renderer state from a canvas. */
+export declare function initWebGL(canvas: HTMLCanvasElement): WebGLState | null;

package/dist/restty.js

@@ -8,7 +8,7 @@ import {
   isBuiltinThemeName,
   listBuiltinThemeNames,
   parseGhosttyTheme
-} from "./chunk-68qdtczc.js";
+} from "./chunk-y290zh3e.js";
 export {
   parseGhosttyTheme,
   listBuiltinThemeNames,

package/dist/{app → runtime}/atlas-builder.d.ts

@@ -1,3 +1,5 @@
+import type { Font, FontAtlas, FontEntry, FontSizeMode } from "../fonts";
+import type { AtlasOptions, GlyphRasterizeOptions, Matrix2D, Matrix3x3, RasterizedGlyph } from "text-shaper";
 /**
  * Metadata for constrained glyph rendering.
  * - cp: Unicode code point
@@ -38,32 +40,65 @@ export type AtlasConstraintContext = {
         iconHeight: number;
         iconHeightSingle: number;
     };
-    fontEntry: any;
+    fontEntry: FontEntry;
+};
+type RasterizeGlyphTransformOptions = GlyphRasterizeOptions & {
+    offsetX26?: number;
+    offsetY26?: number;
+};
+type RasterizeGlyphFn = (font: Font, glyphId: number, fontSize: number, options?: GlyphRasterizeOptions) => RasterizedGlyph | null;
+type RasterizeGlyphWithTransformFn = (font: Font, glyphId: number, fontSize: number, matrix: Matrix2D | Matrix3x3, options?: RasterizeGlyphTransformOptions) => RasterizedGlyph | null;
+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;
+};
+type BuildGlyphAtlasWithConstraintsResult = {
+    atlas: FontAtlas | null;
+    constrainedGlyphWidths?: Map<number, number> | null;
+};
+type BuildColorEmojiAtlasWithCanvasOptions = {
+    font: Font;
+    fontEntry: FontEntry;
+    glyphIds: number[];
+    fontSize: number;
+    sizeMode: FontSizeMode;
+    padding: number;
+    maxWidth: number;
+    maxHeight: number;
+    pixelMode: number;
 };
 type BuildAtlasDeps = {
     fontScaleOverrides: Array<{
         match: RegExp;
         scale: number;
     }>;
-    sizeMode: string;
-    isSymbolFont: (entry: any) => boolean;
-    fontScaleOverride: (entry: any, overrides: Array<{
+    sizeMode: FontSizeMode;
+    isSymbolFont: (entry: FontEntry | null | undefined) => boolean;
+    fontScaleOverride: (entry: FontEntry | null | undefined, 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;
+    resolveGlyphPixelMode: (entry: FontEntry) => number;
+    atlasBitmapToRGBA: (atlas: FontAtlas) => Uint8Array | null;
+    padAtlasRGBA: (rgba: Uint8Array, atlas: FontAtlas, padding: number) => Uint8Array;
+    buildAtlas: (font: Font, glyphIds: number[], options: AtlasOptions) => FontAtlas;
+    buildGlyphAtlasWithConstraints: (options: BuildGlyphAtlasWithConstraintsOptions) => BuildGlyphAtlasWithConstraintsResult | null;
+    buildColorEmojiAtlasWithCanvas: (options: BuildColorEmojiAtlasWithCanvasOptions) => {
+        atlas: FontAtlas;
     } | null;
-    rasterizeGlyph?: any;
-    rasterizeGlyphWithTransform?: any;
+    rasterizeGlyph?: RasterizeGlyphFn;
+    rasterizeGlyphWithTransform?: RasterizeGlyphWithTransformFn;
     nerdConstraintSignature: (glyphMeta: Map<number, GlyphConstraintMeta> | undefined, constraintContext: AtlasConstraintContext | null | undefined) => string;
     constants: {
         atlasPadding: number;
@@ -90,7 +125,7 @@ type BuildAtlasDeps = {
  * - deps: external dependencies for atlas building
  */
 export type BuildFontAtlasParams = {
-    entry: any;
+    entry: FontEntry;
     neededGlyphIds: Set<number>;
     glyphMeta?: Map<number, GlyphConstraintMeta>;
     fontSizePx: number;
@@ -109,7 +144,7 @@ export type BuildFontAtlasParams = {
  */
 export type BuildFontAtlasResult = {
     rebuilt: boolean;
-    atlas: any | null;
+    atlas: FontAtlas | null;
     rgba: Uint8Array | null;
     colorGlyphs?: Set<number>;
     preferNearest: boolean;

package/dist/runtime/codepoint-utils.d.ts

@@ -0,0 +1,12 @@
+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;
+export declare function isEmojiModifierCodepoint(cp: number): boolean;
+export declare function isCoverageIgnorableCodepoint(cp: number): boolean;
+export declare function shouldMergeTrailingClusterCodepoint(cp: number): boolean;
+export declare function resolvePresentationPreference(text: string, chars: string[]): "emoji" | "text" | "auto";
+export declare function stylePreferenceFromFlags(bold: boolean, italic: boolean): "regular" | "bold" | "italic" | "bold_italic";
+export declare function isAppleSymbolsFont(entry: FontEntry | undefined | null): boolean;
+export declare function fontEntryHasBoldStyle(entry: FontEntry | undefined | null): boolean;
+export declare function fontEntryHasItalicStyle(entry: FontEntry | undefined | null): boolean;

package/dist/runtime/create-app-io-utils.d.ts

@@ -0,0 +1,9 @@
+export declare function openLink(uri: string): void;
+export declare function sourceLabelFromUrl(url: string, index: number): string;
+export declare function sourceBufferFromView(view: ArrayBufferView): ArrayBuffer;
+export declare function normalizeNewlines(text: string): string;
+export declare function fitTextTailToWidth(text: string, maxWidthPx: number, measureWidthPx: (value: string) => number): {
+    text: string;
+    offset: number;
+    widthPx: number;
+};

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

@@ -0,0 +1,11 @@
+import { type NerdConstraint } from "../fonts";
+import type { ResttyTouchSelectionMode } from "./types";
+export declare const DEFAULT_SYMBOL_CONSTRAINT: NerdConstraint;
+export declare const DEFAULT_APPLE_SYMBOLS_CONSTRAINT: NerdConstraint;
+export declare const DEFAULT_EMOJI_CONSTRAINT: NerdConstraint;
+export declare function normalizeTouchSelectionMode(value: ResttyTouchSelectionMode | undefined): ResttyTouchSelectionMode;
+export declare function clampFiniteNumber(value: number | undefined, fallback: number, min: number, max: number, round?: boolean): number;
+export declare function isRenderSymbolLike(cp: number): boolean;
+export declare function resolveSymbolConstraint(cp: number): NerdConstraint | null;
+export declare function isRendererSymbolFallbackRange(cp: number): boolean;
+export declare function rendererSymbolFallbackRanges(): ReadonlyArray<readonly [number, number]>;

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

@@ -0,0 +1,72 @@
+import type { ResttyShaderStage } from "./types";
+export type LocalFontsPermissionDescriptor = PermissionDescriptor & {
+    name: "local-fonts";
+};
+export type LocalFontFaceData = {
+    family?: string;
+    fullName?: string;
+    postscriptName?: string;
+    blob: () => Promise<Blob>;
+};
+export type NavigatorWithLocalFontAccess = Navigator & {
+    queryLocalFonts?: () => Promise<LocalFontFaceData[]>;
+    permissions?: {
+        query?: (permissionDesc: LocalFontsPermissionDescriptor) => Promise<PermissionStatus>;
+    };
+};
+export type GlobalWithLocalFontAccess = typeof globalThis & {
+    queryLocalFonts?: () => Promise<LocalFontFaceData[]>;
+    navigator?: NavigatorWithLocalFontAccess;
+};
+export type ResttyDebugWindow = Window & typeof globalThis & {
+    diagnoseCodepoint?: (cp: number) => void;
+    dumpGlyphMetrics?: (cp: number) => {
+        fontIndex: number;
+        glyphId: number;
+    } | null;
+    dumpAtlasRegion?: (fontIndex: number, x: number, y: number, width: number, height: number) => Promise<ImageData | null>;
+    dumpGlyphRender?: (cp: number, constraintWidth?: number) => Promise<unknown>;
+};
+export type CompiledWebGPUShaderStage = {
+    stage: ResttyShaderStage;
+    pipeline: GPURenderPipeline;
+    uniformBuffer: GPUBuffer;
+    uniformData: Float32Array;
+    params: Float32Array;
+    sampler: GPUSampler;
+    bindGroupScene: GPUBindGroup | null;
+    bindGroupPing: GPUBindGroup | null;
+    bindGroupPong: GPUBindGroup | null;
+};
+export type WebGPUStageTargets = {
+    width: number;
+    height: number;
+    sceneTexture: GPUTexture;
+    sceneView: GPUTextureView;
+    pingTexture: GPUTexture;
+    pingView: GPUTextureView;
+    pongTexture: GPUTexture;
+    pongView: GPUTextureView;
+};
+export type CompiledWebGLShaderStage = {
+    stage: ResttyShaderStage;
+    program: WebGLProgram;
+    sourceLoc: WebGLUniformLocation;
+    resolutionLoc: WebGLUniformLocation;
+    timeLoc: WebGLUniformLocation;
+    params0Loc: WebGLUniformLocation;
+    params1Loc: WebGLUniformLocation;
+    params: Float32Array;
+};
+export type WebGLStageTargets = {
+    width: number;
+    height: number;
+    quadVao: WebGLVertexArrayObject;
+    quadBuffer: WebGLBuffer;
+    sceneTexture: WebGLTexture;
+    sceneFramebuffer: WebGLFramebuffer;
+    pingTexture: WebGLTexture;
+    pongTexture: WebGLTexture;
+    pingFramebuffer: WebGLFramebuffer;
+    pongFramebuffer: WebGLFramebuffer;
+};

package/dist/runtime/create-runtime/atlas-debug-utils.d.ts

@@ -0,0 +1,5 @@
+import type { FontAtlas, FontEntry } from "../../fonts";
+export declare function atlasRegionToImageData(atlas: FontAtlas, x: number, y: number, width: number, height: number, pixelModeGray: number, pixelModeRgba: number): ImageData;
+export declare function padAtlasRGBA(rgba: Uint8Array, atlas: FontAtlas, padding: number): Uint8Array;
+export declare function resolveGlyphPixelMode(entry: FontEntry, pixelModeGray: number, pixelModeRgba: number, isColorEmojiFont: (entry: FontEntry) => boolean): number;
+export declare function atlasBitmapToRGBA(atlas: FontAtlas, pixelModeRgba: number, atlasToRGBA: (atlas: FontAtlas) => Uint8Array): Uint8Array | null;

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

@@ -0,0 +1,11 @@
+import type { Color } from "../../renderer";
+export type AlphaBlendingMode = "native" | "linear" | "linear-corrected";
+export declare function srgbChannelToLinear(channel: number): number;
+export declare function srgbToLinearColor(color: Color): Color;
+export declare function resolveBlendFlags(alphaBlending: AlphaBlendingMode, backendType: "webgpu" | "webgl2", state?: {
+    srgbSwapchain?: boolean;
+}): {
+    useLinearBlending: boolean;
+    useLinearCorrection: boolean;
+};
+export declare function floatsToRgb(color: number[]): [number, number, number];

package/dist/runtime/create-runtime/color-glyph-atlas.d.ts

@@ -0,0 +1,11 @@
+import type { FontAtlas } from "../../fonts";
+import type { BuildColorEmojiAtlasWithCanvas } from "./font-runtime-helpers.types";
+type CreateColorGlyphAtlasHelpersOptions = {
+    pixelModeRgba: number;
+    atlasToRGBA: (atlas: FontAtlas) => Uint8Array;
+};
+export declare function createColorGlyphAtlasHelpers(options: CreateColorGlyphAtlasHelpersOptions): {
+    atlasBitmapToRGBA: (atlas: FontAtlas) => Uint8Array | null;
+    buildColorEmojiAtlasWithCanvas: BuildColorEmojiAtlasWithCanvas;
+};
+export {};

package/dist/runtime/create-runtime/debug-tools/create-dump-glyph-render.d.ts

@@ -0,0 +1,2 @@
+import type { CreateRuntimeDebugToolsOptions } from "./types";
+export declare function createDumpGlyphRender(options: CreateRuntimeDebugToolsOptions): (cp: number, constraintWidth?: number) => Promise<ImageData>;

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

@@ -0,0 +1,2 @@
+import type { CreateRuntimeDebugToolsOptions } from "./types";
+export declare function createDiagnoseCodepoint(options: CreateRuntimeDebugToolsOptions): (cp: number) => void;

package/dist/runtime/create-runtime/debug-tools/dump-atlas-for-codepoint.d.ts

@@ -0,0 +1,2 @@
+import type { CreateRuntimeDebugToolsOptions } from "./types";
+export declare function createDumpAtlasForCodepoint(options: CreateRuntimeDebugToolsOptions): (cp: number) => void;

package/dist/runtime/create-runtime/debug-tools/read-texture-to-image-data.d.ts

@@ -0,0 +1 @@
+export declare function readTextureToImageData(device: GPUDevice, texture: GPUTexture, width: number, height: number, origin?: GPUOrigin3D): Promise<ImageData>;

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

@@ -0,0 +1,2 @@
+import type { CreateRuntimeDebugToolsOptions } from "./types";
+export declare function createSetupDebugExpose(options: CreateRuntimeDebugToolsOptions, diagnoseCodepoint: (cp: number) => void): () => void;

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;
+};