restty 0.1.16 → 0.1.18

package/dist/pty/kitty-media.d.ts

@@ -1,5 +1,8 @@
+/** State for streaming Kitty file-based media rewriting (tracks remainder across chunks). */
 export type KittyMediaRewriteState = {
     remainder?: string;
 };
+/** Callback to read file contents for Kitty file-based media payloads. */
 export type KittyMediaReadFile = (path: string) => Uint8Array;
+/** Rewrite Kitty file-based media sequences (f=...) to direct base64 payloads (t=d). */
 export declare function rewriteKittyFileMediaToDirect(chunk: string, state: KittyMediaRewriteState, readFile: KittyMediaReadFile): string;

package/dist/pty/pty.d.ts

@@ -1,9 +1,20 @@
 import type { PtyCallbacks, PtyConnectionState, PtyConnectOptions, PtyTransport } from "./types";
+/** Decode a binary WebSocket frame into a UTF-8 string using a streaming TextDecoder. */
 export declare function decodePtyBinary(decoder: TextDecoder, payload: ArrayBuffer | Uint8Array, stream?: boolean): string;
+/** Create a fresh idle PTY connection state. */
 export declare function createPtyConnection(): PtyConnectionState;
+/**
+ * Open a WebSocket connection to a PTY server. Returns false if the
+ * connection is already active or the URL is empty.
+ */
 export declare function connectPty(state: PtyConnectionState, options: Pick<PtyConnectOptions, "url" | "cols" | "rows">, callbacks: PtyCallbacks): boolean;
+/** Gracefully close the PTY WebSocket connection and reset state to idle. */
 export declare function disconnectPty(state: PtyConnectionState): void;
+/** Send terminal input data to the PTY server. Returns false if the socket is not open. */
 export declare function sendPtyInput(state: PtyConnectionState, data: string): boolean;
+/** Send a resize notification to the PTY server. Returns false if the socket is not open. */
 export declare function sendPtyResize(state: PtyConnectionState, cols: number, rows: number): boolean;
+/** Check whether the PTY WebSocket is currently open and connected. */
 export declare function isPtyConnected(state: PtyConnectionState): boolean;
+/** Create a PtyTransport backed by a WebSocket connection. */
 export declare function createWebSocketPtyTransport(state?: PtyConnectionState): PtyTransport;

package/dist/pty/types.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Messages sent from the client to the PTY server.
+ * - input: terminal keystrokes or pasted text
+ * - resize: window size change notification
+ */
 export type PtyMessage = {
     type: "input";
     data: string;
@@ -6,47 +11,91 @@ export type PtyMessage = {
     cols: number;
     rows: number;
 };
+/** Server notification that the PTY session is ready, with the active shell name. */
 export type PtyStatusMessage = {
     type: "status";
     shell?: string;
 };
+/** Server notification of an error during PTY operation. */
 export type PtyErrorMessage = {
     type: "error";
     message?: string;
     errors?: string[];
 };
+/** Server notification that the PTY process has exited. */
 export type PtyExitMessage = {
     type: "exit";
     code?: number;
 };
+/** Union of all message types sent from the PTY server to the client. */
 export type PtyServerMessage = PtyStatusMessage | PtyErrorMessage | PtyExitMessage;
+/**
+ * PTY connection lifecycle phase.
+ * - idle: no active connection
+ * - connecting: WebSocket handshake in progress
+ * - connected: session is live
+ * - closing: teardown in progress
+ */
 export type PtyLifecycleState = "idle" | "connecting" | "connected" | "closing";
+/**
+ * Internal state of a PTY WebSocket connection.
+ */
 export type PtyConnectionState = {
+    /** Active WebSocket instance, or null when disconnected. */
     socket: WebSocket | null;
+    /** Current lifecycle phase of the connection. */
     status: PtyLifecycleState;
+    /** WebSocket endpoint URL. */
     url: string;
+    /** Decoder for binary WebSocket frames, or null before connection. */
     decoder: TextDecoder | null;
+    /** Monotonic ID used to discard stale connection callbacks. */
     connectId: number;
 };
+/**
+ * Event callbacks for PTY connection lifecycle and data flow.
+ */
 export type PtyCallbacks = {
+    /** Called when the WebSocket connection is established. */
     onConnect?: () => void;
+    /** Called when the connection is closed or lost. */
     onDisconnect?: () => void;
+    /** Called with terminal output data received from the PTY. */
     onData?: (data: string) => void;
+    /** Called with the shell name when the PTY reports its status. */
     onStatus?: (shell: string) => void;
+    /** Called when the PTY server reports an error. */
     onError?: (message: string, errors?: string[]) => void;
+    /** Called with the exit code when the PTY process terminates. */
     onExit?: (code: number) => void;
 };
+/**
+ * Options for establishing a PTY connection.
+ */
 export type PtyConnectOptions = {
+    /** WebSocket endpoint URL to connect to. */
     url: string;
+    /** Initial terminal width in columns. */
     cols?: number;
+    /** Initial terminal height in rows. */
     rows?: number;
+    /** Event callbacks for connection lifecycle and data. */
     callbacks: PtyCallbacks;
 };
+/**
+ * Transport abstraction for PTY communication (WebSocket, WebContainer, etc.).
+ */
 export type PtyTransport = {
+    /** Open a connection to the PTY server. */
     connect: (options: PtyConnectOptions) => void | Promise<void>;
+    /** Close the current connection. */
     disconnect: () => void;
+    /** Send terminal input data; returns true if the data was sent. */
     sendInput: (data: string) => boolean;
+    /** Notify the PTY of a terminal resize; returns true if the message was sent. */
     resize: (cols: number, rows: number) => boolean;
+    /** Whether the transport currently has an active connection. */
     isConnected: () => boolean;
+    /** Release all resources held by the transport. */
     destroy?: () => void | Promise<void>;
 };

package/dist/renderer/box-drawing-map.d.ts

@@ -1 +1,5 @@
+/**
+ * Box drawing character line map.
+ * Maps Unicode codepoint to [up, right, down, left] line styles where 0=none, 1=light, 2=heavy, 3=double.
+ */
 export declare const BOX_LINE_MAP: Map<number, [number, number, number, number]>;

package/dist/renderer/shaders.d.ts

@@ -1,7 +1,14 @@
+/** 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. */
 export declare const GLYPH_SHADER_NEAREST = "\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";

package/dist/renderer/shapes.d.ts

@@ -1,40 +1,81 @@
 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;
-export declare function drawBoxDrawing(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;

package/dist/renderer/types.d.ts

@@ -1,4 +1,7 @@
 import type { Color } from "./shapes";
+/**
+ * Full WebGPU renderer state including device, pipelines, buffers, and atlas cache.
+ */
 export type WebGPUState = {
     core: WebGPUCoreState;
     device: GPUDevice;
@@ -17,6 +20,9 @@ export type WebGPUState = {
     glyphCapacity: number;
     glyphAtlases: Map<number, AtlasState>;
 };
+/**
+ * Shared WebGPU objects needed by sub-renderers (device, format, pipelines, vertex buffer).
+ */
 export type WebGPUCoreState = {
     device: GPUDevice;
     format: GPUTextureFormat;
@@ -26,6 +32,9 @@ export type WebGPUCoreState = {
     glyphPipelineNearest: GPURenderPipeline;
     vertexBuffer: GPUBuffer;
 };
+/**
+ * WebGPU glyph atlas state for a single font size/DPR combination.
+ */
 export type AtlasState = {
     texture: GPUTexture;
     sampler?: GPUSampler;
@@ -41,6 +50,9 @@ export type AtlasState = {
     constrainedGlyphWidths?: Map<number, number>;
     nearest?: boolean;
 };
+/**
+ * Full WebGL2 renderer state including context, programs, buffers, and atlas cache.
+ */
 export type WebGLState = {
     gl: WebGL2RenderingContext;
     rectProgram: WebGLProgram;
@@ -59,6 +71,9 @@ export type WebGLState = {
     glyphCapacity: number;
     glyphAtlases: Map<number, WebGLAtlasState>;
 };
+/**
+ * WebGL glyph atlas state for a single font size/DPR combination.
+ */
 export type WebGLAtlasState = {
     texture: WebGLTexture;
     width: number;
@@ -68,23 +83,51 @@ export type WebGLAtlasState = {
     constrainedGlyphWidths?: Map<number, number>;
     nearest?: boolean;
 };
+/**
+ * Active renderer backend state.
+ * - WebGPUState: WebGPU backend is active
+ * - WebGLState: WebGL2 fallback is active
+ * - null: no renderer initialized
+ */
 export type RendererState = WebGPUState | WebGLState | null;
+/**
+ * Renderer color configuration.
+ */
 export type RendererConfig = {
+    /** Default background color. */
     defaultBg: Color;
+    /** Default foreground color. */
     defaultFg: Color;
+    /** Selection highlight overlay color. */
     selectionColor: Color;
+    /** Cursor color used when the application does not specify one. */
     cursorFallback: Color;
 };
+/**
+ * Tracks in-progress resize operations for debouncing and state diffing.
+ */
 export type ResizeState = {
+    /** Whether a resize is currently in progress. */
     active: boolean;
+    /** Timestamp of the last resize event. */
     lastAt: number;
+    /** Column count after the last resize. */
     cols: number;
+    /** Row count after the last resize. */
     rows: number;
+    /** Device pixel ratio after the last resize. */
     dpr: number;
 };
+/**
+ * Cached scrollbar position state for change detection and fade timing.
+ */
 export type ScrollbarState = {
+    /** Timestamp of the last user scroll input. */
     lastInputAt: number;
+    /** Total number of scrollback lines at last update. */
     lastTotal: number;
+    /** Scroll offset (lines from bottom) at last update. */
     lastOffset: number;
+    /** Visible viewport length (rows) at last update. */
     lastLen: number;
 };

package/dist/renderer/webgpu.d.ts

@@ -1,12 +1,22 @@
 import type { WebGPUCoreState, WebGPUState, WebGLState } 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>;
+/** Initialize a WebGL2 fallback renderer state from a canvas. */
 export declare function initWebGL(canvas: HTMLCanvasElement): WebGLState | null;
+/** 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;
+/** Create the initial resize tracking state with default values. */
 export declare function createResizeState(): {
     active: boolean;
     lastAt: number;
@@ -14,6 +24,7 @@ export declare function createResizeState(): {
     rows: number;
     dpr: number;
 };
+/** Create the initial scrollbar position state with default values. */
 export declare function createScrollbarState(): {
     lastInputAt: number;
     lastTotal: number;

package/dist/restty.js

@@ -0,0 +1,20 @@
+import {
+  Restty,
+  ResttyPaneHandle,
+  createRestty,
+  getBuiltinTheme,
+  getBuiltinThemeSource,
+  isBuiltinThemeName,
+  listBuiltinThemeNames,
+  parseGhosttyTheme
+} from "./chunk-53vdvhe3.js";
+export {
+  parseGhosttyTheme,
+  listBuiltinThemeNames,
+  isBuiltinThemeName,
+  getBuiltinThemeSource,
+  getBuiltinTheme,
+  createRestty,
+  ResttyPaneHandle,
+  Restty
+};

package/dist/selection/selection.d.ts

@@ -1,13 +1,37 @@
 import type { CellPosition, SelectionRange, SelectionState } from "./types";
+/** Create an empty, inactive selection state. */
 export declare function createSelectionState(): SelectionState;
+/** Reset the selection state, deactivating any active selection. */
 export declare function clearSelection(state: SelectionState): void;
+/** Begin a new selection at the given cell, entering drag mode. */
 export declare function startSelection(state: SelectionState, cell: CellPosition): void;
+/** Extend the active selection to a new focus cell while dragging. */
 export declare function updateSelection(state: SelectionState, cell: CellPosition): void;
+/**
+ * Finish a drag selection at the given cell. Returns true if a non-empty
+ * selection was created, or false if anchor and focus are the same cell.
+ */
 export declare function endSelection(state: SelectionState, cell: CellPosition): boolean;
+/**
+ * Return the selected column range for a given row, or null if the row
+ * is outside the selection.
+ */
 export declare function selectionForRow(state: SelectionState, row: number, cols: number): SelectionRange | null;
+/** Callback that returns the text content of a cell by flat grid index. */
 export type CellTextGetter = (idx: number) => string;
+/**
+ * Extract the selected text as a newline-separated string, with trailing
+ * whitespace trimmed from each line.
+ */
 export declare function getSelectionText(state: SelectionState, rows: number, cols: number, getCellText: CellTextGetter): string;
+/**
+ * Clamp a cell position to the grid bounds and snap wide-character
+ * continuation cells back to the leading cell.
+ */
 export declare function normalizeSelectionCell(cell: CellPosition | null, rows: number, cols: number, wideFlags?: Uint8Array | null): CellPosition | null;
+/** Convert client pixel coordinates to a grid cell position. */
 export declare function positionToCell(clientX: number, clientY: number, canvasRect: DOMRect, dpr: number, cellW: number, cellH: number, cols: number, rows: number): CellPosition;
+/** Copy text to the system clipboard, with a legacy execCommand fallback. */
 export declare function copyToClipboard(text: string): Promise<boolean>;
+/** Read text from the system clipboard, returning null on failure. */
 export declare function pasteFromClipboard(): Promise<string | null>;

package/dist/selection/types.d.ts

@@ -1,14 +1,27 @@
+/** 0-based cell coordinates within the terminal grid. */
 export type CellPosition = {
     row: number;
     col: number;
 };
+/**
+ * Mutable state of the current text selection.
+ */
 export type SelectionState = {
+    /** Whether a selection currently exists. */
     active: boolean;
+    /** Whether the user is actively dragging to extend the selection. */
     dragging: boolean;
+    /** Cell where the selection was initiated (start point). */
     anchor: CellPosition | null;
+    /** Cell where the selection currently ends (moving point). */
     focus: CellPosition | null;
 };
+/**
+ * Column span of a selection within a single row.
+ */
 export type SelectionRange = {
+    /** Inclusive start column index. */
     start: number;
+    /** Exclusive end column index. */
     end: number;
 };

package/dist/theme/catalog.d.ts

@@ -1,7 +1,12 @@
 import { type GhosttyTheme } from "./ghostty";
 import { type BuiltinThemeName } from "./builtin-themes";
+/** String literal union of all builtin theme names. */
 export type ResttyBuiltinThemeName = BuiltinThemeName;
+/** Return an array of all builtin theme names. */
 export declare function listBuiltinThemeNames(): ResttyBuiltinThemeName[];
+/** Check if a string is a valid builtin theme name. */
 export declare function isBuiltinThemeName(name: string): name is ResttyBuiltinThemeName;
+/** Get the raw source text for a builtin theme by name. */
 export declare function getBuiltinThemeSource(name: string): string | null;
+/** Get the parsed theme object for a builtin theme by name (cached). */
 export declare function getBuiltinTheme(name: string): GhosttyTheme | null;

package/dist/theme/ghostty.d.ts

@@ -1,23 +1,41 @@
+/** RGBA color with 0-255 byte components. */
 export type ThemeColor = {
     r: number;
     g: number;
     b: number;
     a?: number;
 };
+/**
+ * Parsed Ghostty terminal theme with semantic colors and full 256-color palette.
+ */
 export type GhosttyTheme = {
+    /** Optional theme name extracted from source. */
     name?: string;
+    /** Semantic colors and ANSI palette entries. */
     colors: {
+        /** Default background color. */
         background?: ThemeColor;
+        /** Default foreground (text) color. */
         foreground?: ThemeColor;
+        /** Cursor fill color. */
         cursor?: ThemeColor;
+        /** Text color under the cursor. */
         cursorText?: ThemeColor;
+        /** Selection background color. */
         selectionBackground?: ThemeColor;
+        /** Selection foreground (text) color. */
         selectionForeground?: ThemeColor;
+        /** 256-color palette (indices 0-255). */
         palette: Array<ThemeColor | undefined>;
     };
+    /** Original key-value pairs from the theme source. */
     raw: Record<string, string>;
 };
+/** Parse a Ghostty color value (hex, rgb/rgba, or named color). */
 export declare function parseGhosttyColor(value: string): ThemeColor | null;
+/** Convert ThemeColor to normalized RGBA floats (0.0-1.0). */
 export declare function colorToFloats(color: ThemeColor, alphaOverride?: number): [number, number, number, number];
+/** Convert ThemeColor to packed 24-bit RGB integer (0xRRGGBB). */
 export declare function colorToRgbU32(color: ThemeColor): number;
+/** Parse a Ghostty theme configuration from key=value format. */
 export declare function parseGhosttyTheme(text: string): GhosttyTheme;

package/dist/unicode/ghostty-symbol-ranges.d.ts

@@ -0,0 +1 @@
+export declare const GHOSTTY_SYMBOL_RANGES: ReadonlyArray<readonly [number, number]>;

package/dist/unicode/symbols.d.ts

@@ -0,0 +1,6 @@
+/** True when cp is a Ghostty "graphics element" handled specially in renderer logic. */
+export declare function isGraphicsElementCodepoint(cp: number): boolean;
+/** True when cp is in Ghostty's generated is_symbol lookup table. */
+export declare function isGhosttySymbolCodepoint(cp: number): boolean;
+/** Symbol-like codepoint for renderer constraint/fit behavior. */
+export declare function isSymbolLikeCodepoint(cp: number): boolean;