restty 0.1.23 → 0.1.25

package/dist/renderer/{shaders.d.ts → shaders/glyph-wgsl.d.ts}

@@ -1,13 +1,3 @@
-/** WebGPU WGSL shader for rendering solid-color rectangles. */
-export declare const RECT_SHADER = "\nstruct Uniforms {\n  res: vec2f,\n  _pad: vec2f,\n  blend: vec2f,\n  _pad2: vec2f,\n};\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n\nstruct VSIn {\n  @location(0) quad: vec2f,\n  @location(1) pos: vec2f,\n  @location(2) size: vec2f,\n  @location(3) color: vec4f,\n};\n\nstruct VSOut {\n  @builtin(position) position: vec4f,\n  @location(0) color: vec4f,\n};\n\n// sRGB to linear conversion for proper blending\nfn srgbToLinear(c: f32) -> f32 {\n  if (c <= 0.04045) {\n    return c / 12.92;\n  }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfn srgbToLinear3(c: vec3f) -> vec3f {\n  return vec3f(srgbToLinear(c.x), srgbToLinear(c.y), srgbToLinear(c.z));\n}\n\n@vertex\nfn vsMain(input: VSIn) -> VSOut {\n  let pixel = input.pos + input.quad * input.size;\n  let clip = vec2f(\n    (pixel.x / uniforms.res.x) * 2.0 - 1.0,\n    1.0 - (pixel.y / uniforms.res.y) * 2.0\n  );\n\n  var out: VSOut;\n  out.position = vec4f(clip.x, clip.y, 0.0, 1.0);\n  out.color = input.color;\n  return out;\n}\n\n@fragment\nfn fsMain(input: VSOut) -> @location(0) vec4f {\n  let useLinear = uniforms.blend.x > 0.5;\n  var color = input.color;\n  if (useLinear) {\n    color = vec4f(srgbToLinear3(color.rgb), color.a);\n  }\n  color = vec4f(color.rgb * color.a, color.a);\n  return color;\n}\n";
-/** WebGL2 vertex shader for rendering solid-color rectangles. */
-export declare const RECT_SHADER_GL_VERT = "#version 300 es\nprecision highp float;\n\nuniform vec2 u_resolution;\n\nlayout(location = 0) in vec2 a_quad;\nlayout(location = 1) in vec2 a_pos;\nlayout(location = 2) in vec2 a_size;\nlayout(location = 3) in vec4 a_color;\n\nout vec4 v_color;\n\nvoid main() {\n  vec2 pixel = a_pos + a_quad * a_size;\n  vec2 clip = vec2(\n    (pixel.x / u_resolution.x) * 2.0 - 1.0,\n    1.0 - (pixel.y / u_resolution.y) * 2.0\n  );\n  gl_Position = vec4(clip, 0.0, 1.0);\n  v_color = a_color;\n}\n";
-/** WebGL2 fragment shader for rendering solid-color rectangles with alpha blending. */
-export declare const RECT_SHADER_GL_FRAG = "#version 300 es\nprecision highp float;\n\nuniform vec2 u_blend;\n\nin vec4 v_color;\nout vec4 fragColor;\n\n// sRGB to linear conversion for proper blending\nfloat srgbToLinear(float c) {\n  if (c <= 0.04045) {\n    return c / 12.92;\n  }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nvec3 srgbToLinear(vec3 c) {\n  return vec3(srgbToLinear(c.r), srgbToLinear(c.g), srgbToLinear(c.b));\n}\n\nvoid main() {\n  bool useLinear = u_blend.x > 0.5;\n  vec4 color = v_color;\n  if (useLinear) {\n    color.rgb = srgbToLinear(color.rgb);\n  }\n  color.rgb *= color.a;\n  fragColor = color;\n}\n";
-/** WebGL2 vertex shader for rendering textured glyph quads. */
-export declare const GLYPH_SHADER_GL_VERT = "#version 300 es\nprecision highp float;\n\nuniform vec2 u_resolution;\n\nlayout(location = 0) in vec2 a_quad;\nlayout(location = 1) in vec2 a_pos;\nlayout(location = 2) in vec2 a_size;\nlayout(location = 3) in vec2 a_uv0;\nlayout(location = 4) in vec2 a_uv1;\nlayout(location = 5) in vec4 a_color;\nlayout(location = 6) in vec4 a_bg;\nlayout(location = 7) in float a_slant;\nlayout(location = 8) in float a_mode;\n\nout vec2 v_uv;\nout vec4 v_color;\nout vec4 v_bg;\nout float v_mode;\n\nvoid main() {\n  vec2 pixel = a_pos + vec2(a_quad.x * a_size.x + a_slant * (1.0 - a_quad.y), a_quad.y * a_size.y);\n  vec2 clip = vec2(\n    (pixel.x / u_resolution.x) * 2.0 - 1.0,\n    1.0 - (pixel.y / u_resolution.y) * 2.0\n  );\n  v_uv = a_uv0 + (a_uv1 - a_uv0) * a_quad;\n  gl_Position = vec4(clip, 0.0, 1.0);\n  v_color = a_color;\n  v_bg = a_bg;\n  v_mode = a_mode;\n}\n";
-/** WebGL2 fragment shader for sampling glyph atlas textures with linear filtering. */
-export declare const GLYPH_SHADER_GL_FRAG = "#version 300 es\nprecision highp float;\n\nuniform sampler2D u_atlas;\nuniform vec2 u_blend;\n\nin vec2 v_uv;\nin vec4 v_color;\nin vec4 v_bg;\nin float v_mode;\nout vec4 fragColor;\n\n// sRGB to linear conversion for proper blending\nfloat srgbToLinear(float c) {\n  if (c <= 0.04045) {\n    return c / 12.92;\n  }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\n// Linear to sRGB conversion\nfloat linearToSrgb(float c) {\n  if (c <= 0.0031308) {\n    return c * 12.92;\n  }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nvec3 srgbToLinear(vec3 c) {\n  return vec3(srgbToLinear(c.r), srgbToLinear(c.g), srgbToLinear(c.b));\n}\n\nvec3 linearToSrgb(vec3 c) {\n  return vec3(linearToSrgb(c.r), linearToSrgb(c.g), linearToSrgb(c.b));\n}\n\nfloat luminance(vec3 color) {\n  return dot(color, vec3(0.2126, 0.7152, 0.0722));\n}\n\nvoid main() {\n  vec4 atlasSample = texture(u_atlas, v_uv);\n  bool useLinear = u_blend.x > 0.5;\n  bool useCorrection = u_blend.y > 0.5;\n\n  if (v_mode > 0.5) {\n    vec4 color = atlasSample;\n    if (useLinear) {\n      color.rgb = srgbToLinear(color.rgb);\n    }\n    color.rgb *= color.a;\n    fragColor = color;\n    return;\n  }\n\n  vec4 fg = v_color;\n  vec4 bg = v_bg;\n  if (useLinear) {\n    fg.rgb = srgbToLinear(fg.rgb);\n    bg.rgb = srgbToLinear(bg.rgb);\n  }\n  fg.rgb *= fg.a;\n  bg.rgb *= bg.a;\n\n  float alpha = atlasSample.a;\n  if (useCorrection && useLinear) {\n    float fg_l = luminance(fg.rgb);\n    float bg_l = luminance(bg.rgb);\n    if (abs(fg_l - bg_l) > 0.001) {\n      float blend_l = srgbToLinear(linearToSrgb(fg_l) * alpha + linearToSrgb(bg_l) * (1.0 - alpha));\n      alpha = clamp((blend_l - bg_l) / (fg_l - bg_l), 0.0, 1.0);\n    }\n  }\n\n  vec4 color = fg * alpha;\n  fragColor = color;\n}\n";
 /** WebGPU WGSL shader for rendering textured glyph quads with linear atlas sampling. */
 export declare const GLYPH_SHADER = "\nstruct Uniforms {\n  res: vec2f,\n  _pad: vec2f,\n  blend: vec2f,\n  _pad2: vec2f,\n};\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n@group(0) @binding(1) var atlasSampler: sampler;\n@group(0) @binding(2) var atlasTex: texture_2d<f32>;\n\nstruct VSIn {\n  @location(0) quad: vec2f,\n  @location(1) pos: vec2f,\n  @location(2) size: vec2f,\n  @location(3) uv0: vec2f,\n  @location(4) uv1: vec2f,\n  @location(5) color: vec4f,\n  @location(6) bg: vec4f,\n  @location(7) slant: f32,\n  @location(8) mode: f32,\n};\n\nstruct VSOut {\n  @builtin(position) position: vec4f,\n  @location(0) uv: vec2f,\n  @location(1) color: vec4f,\n  @location(2) bg: vec4f,\n  @location(3) mode: f32,\n};\n\n@vertex\nfn vsMain(input: VSIn) -> VSOut {\n  let pixel = input.pos +\n    vec2f(input.quad.x * input.size.x + input.slant * (1.0 - input.quad.y), input.quad.y * input.size.y);\n  let clip = vec2f(\n    (pixel.x / uniforms.res.x) * 2.0 - 1.0,\n    1.0 - (pixel.y / uniforms.res.y) * 2.0\n  );\n  let uv = input.uv0 + (input.uv1 - input.uv0) * input.quad;\n\n  var out: VSOut;\n  out.position = vec4f(clip.x, clip.y, 0.0, 1.0);\n  out.uv = uv;\n  out.color = input.color;\n  out.bg = input.bg;\n  out.mode = input.mode;\n  return out;\n}\n\n// sRGB to linear conversion for proper blending\nfn srgbToLinear(c: f32) -> f32 {\n  if (c <= 0.04045) {\n    return c / 12.92;\n  }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\n// Linear to sRGB conversion\nfn linearToSrgb(c: f32) -> f32 {\n  if (c <= 0.0031308) {\n    return c * 12.92;\n  }\n  return 1.055 * pow(c, 1.0 / 2.4) - 0.055;\n}\n\nfn srgbToLinear3(c: vec3f) -> vec3f {\n  return vec3f(srgbToLinear(c.x), srgbToLinear(c.y), srgbToLinear(c.z));\n}\n\nfn linearToSrgb3(c: vec3f) -> vec3f {\n  return vec3f(linearToSrgb(c.x), linearToSrgb(c.y), linearToSrgb(c.z));\n}\n\nfn luminance(color: vec3f) -> f32 {\n  return dot(color, vec3f(0.2126, 0.7152, 0.0722));\n}\n\n@fragment\nfn fsMain(input: VSOut) -> @location(0) vec4f {\n  let atlasSample = textureSample(atlasTex, atlasSampler, input.uv);\n  let useLinear = uniforms.blend.x > 0.5;\n  let useCorrection = uniforms.blend.y > 0.5;\n\n  if (input.mode > 0.5) {\n    var color = atlasSample;\n    if (useLinear) {\n      color = vec4f(srgbToLinear3(color.rgb), color.a);\n    }\n    return vec4f(color.rgb * color.a, color.a);\n  }\n\n  var alpha = atlasSample.a;\n\n  var fg = input.color;\n  var bg = input.bg;\n  if (useLinear) {\n    fg = vec4f(srgbToLinear3(fg.rgb), fg.a);\n    bg = vec4f(srgbToLinear3(bg.rgb), bg.a);\n  }\n  fg = vec4f(fg.rgb * fg.a, fg.a);\n  bg = vec4f(bg.rgb * bg.a, bg.a);\n\n  if (useCorrection && useLinear) {\n    let fg_l = luminance(fg.rgb);\n    let bg_l = luminance(bg.rgb);\n    if (abs(fg_l - bg_l) > 0.001) {\n      let blend_l = srgbToLinear(linearToSrgb(fg_l) * alpha + linearToSrgb(bg_l) * (1.0 - alpha));\n      alpha = clamp((blend_l - bg_l) / (fg_l - bg_l), 0.0, 1.0);\n    }\n  }\n\n  var color = fg * alpha;\n  return color;\n}\n";
 /** WebGPU WGSL shader for rendering textured glyph quads with nearest-neighbor atlas sampling. */

package/dist/renderer/shaders/rect.d.ts

@@ -0,0 +1,6 @@
+/** WebGPU WGSL shader for rendering solid-color rectangles. */
+export declare const RECT_SHADER = "\nstruct Uniforms {\n  res: vec2f,\n  _pad: vec2f,\n  blend: vec2f,\n  _pad2: vec2f,\n};\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n\nstruct VSIn {\n  @location(0) quad: vec2f,\n  @location(1) pos: vec2f,\n  @location(2) size: vec2f,\n  @location(3) color: vec4f,\n};\n\nstruct VSOut {\n  @builtin(position) position: vec4f,\n  @location(0) color: vec4f,\n};\n\n// sRGB to linear conversion for proper blending\nfn srgbToLinear(c: f32) -> f32 {\n  if (c <= 0.04045) {\n    return c / 12.92;\n  }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nfn srgbToLinear3(c: vec3f) -> vec3f {\n  return vec3f(srgbToLinear(c.x), srgbToLinear(c.y), srgbToLinear(c.z));\n}\n\n@vertex\nfn vsMain(input: VSIn) -> VSOut {\n  let pixel = input.pos + input.quad * input.size;\n  let clip = vec2f(\n    (pixel.x / uniforms.res.x) * 2.0 - 1.0,\n    1.0 - (pixel.y / uniforms.res.y) * 2.0\n  );\n\n  var out: VSOut;\n  out.position = vec4f(clip.x, clip.y, 0.0, 1.0);\n  out.color = input.color;\n  return out;\n}\n\n@fragment\nfn fsMain(input: VSOut) -> @location(0) vec4f {\n  let useLinear = uniforms.blend.x > 0.5;\n  var color = input.color;\n  if (useLinear) {\n    color = vec4f(srgbToLinear3(color.rgb), color.a);\n  }\n  color = vec4f(color.rgb * color.a, color.a);\n  return color;\n}\n";
+/** WebGL2 vertex shader for rendering solid-color rectangles. */
+export declare const RECT_SHADER_GL_VERT = "#version 300 es\nprecision highp float;\n\nuniform vec2 u_resolution;\n\nlayout(location = 0) in vec2 a_quad;\nlayout(location = 1) in vec2 a_pos;\nlayout(location = 2) in vec2 a_size;\nlayout(location = 3) in vec4 a_color;\n\nout vec4 v_color;\n\nvoid main() {\n  vec2 pixel = a_pos + a_quad * a_size;\n  vec2 clip = vec2(\n    (pixel.x / u_resolution.x) * 2.0 - 1.0,\n    1.0 - (pixel.y / u_resolution.y) * 2.0\n  );\n  gl_Position = vec4(clip, 0.0, 1.0);\n  v_color = a_color;\n}\n";
+/** WebGL2 fragment shader for rendering solid-color rectangles with alpha blending. */
+export declare const RECT_SHADER_GL_FRAG = "#version 300 es\nprecision highp float;\n\nuniform vec2 u_blend;\n\nin vec4 v_color;\nout vec4 fragColor;\n\n// sRGB to linear conversion for proper blending\nfloat srgbToLinear(float c) {\n  if (c <= 0.04045) {\n    return c / 12.92;\n  }\n  return pow((c + 0.055) / 1.055, 2.4);\n}\n\nvec3 srgbToLinear(vec3 c) {\n  return vec3(srgbToLinear(c.r), srgbToLinear(c.g), srgbToLinear(c.b));\n}\n\nvoid main() {\n  bool useLinear = u_blend.x > 0.5;\n  vec4 color = v_color;\n  if (useLinear) {\n    color.rgb = srgbToLinear(color.rgb);\n  }\n  color.rgb *= color.a;\n  fragColor = color;\n}\n";

package/dist/renderer/shapes/block-elements.d.ts

@@ -0,0 +1,3 @@
+import type { Color, RectData } from "./types";
+/** 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;

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-mkkhfg0z.js";
+} from "./chunk-pab3ge3d.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;