insomni 0.2.0-alpha.0

package/dist/spatial-Bd3Ay8I2.d.mts

@@ -0,0 +1,85 @@
+import { r as Renderer2D$1, vt as Layer } from "./renderer-DzZqd1bY.mjs";
+import { N as FrameRect } from "./camera-view-DHmMiKvP.mjs";
+import { Damage, DamageKind, DirtyRegion, FrameTiming as SpatialFrameTiming, PointerHandler, PointerRouter, Rect, Rect as Rect$1, RectSpace, Renderer2D, Renderer2D as SpatialRenderer2D, SceneNode, SceneNode as SceneNode$1, SceneNodeOptions, SceneRoot, SceneRoot as SceneRoot$1, SceneRootOptions, SceneRootOptions as SceneRootOptions$1, SpatialPointerEvent, pointInRect, rectClamp, rectEquals, rectOverlaps, unionRects } from "@dirtytalk/spatial";
+import { DirtyChannel, ManualScheduler, MicrotaskScheduler, Observable, RAFScheduler, Scheduler, Signal, Space, SyncScheduler } from "@dirtytalk/engine";
+
+//#region src/spatial.d.ts
+/** Convert an insomni `FrameRect` ({x,y,width,height}) to a spatial `Rect`. */
+declare function frameToRect(frame: FrameRect): Rect;
+/** Convert a spatial `Rect` to an insomni `FrameRect`. */
+declare function rectToFrame(rect: Rect): FrameRect;
+/** Build a `Rect` from loose x/y/width/height fields. */
+declare function rectOf(x: number, y: number, width: number, height: number): Rect;
+interface LayerRendererOptions {
+  /**
+   * Clear `layer` at the start of every frame. Default `true` (full-canvas
+   * model — nodes re-emit each frame). Set `false` only for retained layers
+   * that you mutate incrementally and never want auto-cleared.
+   */
+  clearLayer?: boolean;
+  /**
+   * Extra layers submitted after the scene layer, in order (e.g. a HUD
+   * overlay). Re-read each frame so the list can change between frames.
+   */
+  extraLayers?: () => readonly Layer[];
+  /** Hook invoked at the top of every frame, before the paint walk. */
+  onBeginFrame?: (regions: readonly Rect[]) => void;
+  /** Hook invoked after the paint walk, before the GPU submit. */
+  onEndFrame?: () => void;
+  /**
+   * Thunk reporting whether the owning root is in `fullFrame` mode. When it
+   * returns `true`, the GPU frame is submitted as a full clear+repaint; when
+   * `false`, the damage rects drive a partial redraw (on a `persistent`
+   * renderer). Lets {@link GpuSceneRoot} pass its live `fullFrame` flag without
+   * a construction-order cycle. Defaults to always-full.
+   */
+  isFullFrame?: () => boolean;
+}
+/**
+ * A spatial `Renderer2D` that records the most recent damage regions (for a
+ * future scissor path) and drives `gpu.render([...])` on `endFrame`.
+ */
+interface LayerRenderer extends Renderer2D {
+  /** Damage rects handed to the most recent `beginFrame`. */
+  readonly lastRegions: readonly Rect[];
+}
+declare function createLayerRenderer(gpu: Renderer2D$1, layer: Layer, options?: LayerRendererOptions): LayerRenderer;
+declare abstract class GpuSceneNode extends SceneNode {
+  /** Emit this node's geometry into the GPU layer. */
+  abstract drawSelf(layer: Layer): void;
+  paint(_layer: unknown): void;
+  /** Walk the parent chain to the owning GpuSceneRoot, or null if detached. */
+  protected gpuRoot(): GpuSceneRoot | null;
+  /** Mark a visual-only change: repaint, no data/layout rebuild. */
+  invalidatePaint(rect?: Rect): void;
+  /** Mark a layout change (bounds/children moved). Triggers doLayout + paint. */
+  invalidateLayout(rect?: Rect): void;
+  /** Mark a data change (inputs replaced). Triggers rebuildData → layout → paint. */
+  invalidateData(rect?: Rect): void;
+}
+interface GpuSceneRootOptions extends SceneRootOptions, LayerRendererOptions {
+  /**
+   * Repaint every node on any damage and ignore the per-node cull. Default
+   * `true` for the full-canvas model (the scene layer is cleared each frame,
+   * so culled-out nodes would otherwise vanish). Set `false` only when the
+   * scene layer / its children are retained between frames.
+   */
+  fullFrame?: boolean;
+}
+declare class GpuSceneRoot extends SceneRoot {
+  /** The scene layer that descendant nodes paint into. */
+  readonly layer: Layer;
+  /** The underlying WebGPU renderer. */
+  readonly gpu: Renderer2D$1;
+  constructor(gpu: Renderer2D$1, layer: Layer, options?: GpuSceneRootOptions);
+  paint(_layer: unknown): void;
+  /**
+   * Force a full repaint on the next scheduled frame. Use when widget internals
+   * are mutated outside a damage-tracked setter; normal state changes mark their
+   * own damage and don't need this. (`setBounds` to the same rect is a no-op, so
+   * it can't be used for this.)
+   */
+  requestPaint(): void;
+}
+//#endregion
+export { frameToRect as A, Signal as C, SpatialRenderer2D as D, SpatialPointerEvent as E, rectOverlaps as F, rectToFrame as I, unionRects as L, rectClamp as M, rectEquals as N, SyncScheduler as O, rectOf as P, Scheduler as S, SpatialFrameTiming as T, RectSpace as _, GpuSceneNode as a, SceneRoot$1 as b, LayerRenderer as c, MicrotaskScheduler as d, Observable as f, Rect$1 as g, RAFScheduler as h, DirtyRegion as i, pointInRect as j, createLayerRenderer as k, LayerRendererOptions as l, PointerRouter as m, DamageKind as n, GpuSceneRoot as o, PointerHandler as p, DirtyChannel as r, GpuSceneRootOptions as s, Damage as t, ManualScheduler as u, SceneNode$1 as v, Space as w, SceneRootOptions$1 as x, SceneNodeOptions as y };

package/dist/spatial-hash-C1crBjTo.mjs

@@ -0,0 +1,77 @@
+//#region src/gpu/spatial-hash.ts
+const SPATIAL_HASH_WORKGROUP_SIZE = 64;
+const SPATIAL_HASH_PARAMS_BYTES = 32;
+const SPATIAL_HASH_PARAMS_WGSL = `
+struct SpatialHashParams {
+  rangeStart: u32,
+  rangeCount: u32,
+  bucketMask: u32,
+  bucketCount: u32,
+  invCellSize: f32,
+  weight: f32,
+  _pad0: f32,
+  _pad1: f32,
+};
+
+const EMPTY_SLOT: u32 = 0xffffffffu;
+const DEAD_CELL_COORD: i32 = 2147483647;
+
+fn hashCell(cell: vec2i, mask: u32) -> u32 {
+  let x = bitcast<u32>(cell.x);
+  let y = bitcast<u32>(cell.y);
+  var h = x * 0x9e3779b9u;
+  h = (h << 6u) ^ (h >> 2u) ^ (y * 0x85ebca6bu);
+  return h & mask;
+}
+
+fn worldCell(pos: vec2f, invCellSize: f32) -> vec2i {
+  return vec2i(floor(pos * invCellSize));
+}
+`;
+const CLEAR_SPATIAL_HASH_WGSL = `${SPATIAL_HASH_PARAMS_WGSL}
+@group(0) @binding(0) var<storage, read_write> heads: array<atomic<u32>>;
+@group(0) @binding(1) var<uniform> params: SpatialHashParams;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+  let i = gid.x;
+  if (i >= params.bucketCount) {
+    return;
+  }
+  atomicStore(&heads[i], EMPTY_SLOT);
+}
+`;
+const BUILD_SPATIAL_HASH_WGSL = `${SPATIAL_HASH_PARAMS_WGSL}
+@group(0) @binding(0) var<storage, read_write> heads: array<atomic<u32>>;
+@group(0) @binding(1) var<storage, read_write> next: array<u32>;
+@group(0) @binding(2) var<storage, read_write> cells: array<vec2i>;
+@group(0) @binding(3) var<storage, read> nodeIds: array<u32>;
+@group(0) @binding(4) var<storage, read> positions: array<vec4f>;
+@group(0) @binding(5) var<storage, read> alive: array<u32>;
+@group(0) @binding(6) var<uniform> params: SpatialHashParams;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) gid: vec3u) {
+  let role = gid.x;
+  if (role >= params.rangeCount) {
+    return;
+  }
+
+  let entry = params.rangeStart + role;
+  let nodeId = nodeIds[entry];
+  next[entry] = EMPTY_SLOT;
+
+  if (alive[nodeId] == 0u) {
+    cells[entry] = vec2i(DEAD_CELL_COORD);
+    return;
+  }
+
+  let cell = worldCell(positions[nodeId].xy, params.invCellSize);
+  cells[entry] = cell;
+  let bucket = hashCell(cell, params.bucketMask);
+  let prev = atomicExchange(&heads[bucket], entry);
+  next[entry] = prev;
+}
+`;
+//#endregion
+export { SPATIAL_HASH_WORKGROUP_SIZE as a, SPATIAL_HASH_PARAMS_WGSL as i, CLEAR_SPATIAL_HASH_WGSL as n, SPATIAL_HASH_PARAMS_BYTES as r, BUILD_SPATIAL_HASH_WGSL as t };

package/dist/spatial.d.mts

@@ -0,0 +1,2 @@
+import { A as frameToRect, C as Signal, D as SpatialRenderer2D, E as SpatialPointerEvent, F as rectOverlaps, I as rectToFrame, L as unionRects, M as rectClamp, N as rectEquals, O as SyncScheduler, P as rectOf, S as Scheduler, T as SpatialFrameTiming, _ as RectSpace, a as GpuSceneNode, b as SceneRoot, c as LayerRenderer, d as MicrotaskScheduler, f as Observable, g as Rect, h as RAFScheduler, i as DirtyRegion, j as pointInRect, k as createLayerRenderer, l as LayerRendererOptions, m as PointerRouter, n as DamageKind, o as GpuSceneRoot, p as PointerHandler, r as DirtyChannel, s as GpuSceneRootOptions, t as Damage, u as ManualScheduler, v as SceneNode, w as Space, x as SceneRootOptions, y as SceneNodeOptions } from "./spatial-Bd3Ay8I2.mjs";
+export { Damage, DamageKind, DirtyChannel, DirtyRegion, GpuSceneNode, GpuSceneRoot, GpuSceneRootOptions, LayerRenderer, LayerRendererOptions, ManualScheduler, MicrotaskScheduler, Observable, PointerHandler, PointerRouter, RAFScheduler, Rect, RectSpace, SceneNode, SceneNodeOptions, SceneRoot, SceneRootOptions, Scheduler, Signal, Space, SpatialFrameTiming, SpatialPointerEvent, SpatialRenderer2D, SyncScheduler, createLayerRenderer, frameToRect, pointInRect, rectClamp, rectEquals, rectOf, rectOverlaps, rectToFrame, unionRects };

package/dist/spatial.mjs

@@ -0,0 +1,121 @@
+import { PointerRouter, RectSpace, SceneNode, SceneNode as SceneNode$1, SceneRoot, SceneRoot as SceneRoot$1, pointInRect, rectClamp, rectEquals, rectOverlaps, unionRects } from "@dirtytalk/spatial";
+import { DirtyChannel, ManualScheduler, MicrotaskScheduler, RAFScheduler, Signal, SyncScheduler } from "@dirtytalk/engine";
+//#region src/spatial.ts
+/** Convert an insomni `FrameRect` ({x,y,width,height}) to a spatial `Rect`. */
+function frameToRect(frame) {
+	return {
+		x: frame.x,
+		y: frame.y,
+		w: frame.width,
+		h: frame.height
+	};
+}
+/** Convert a spatial `Rect` to an insomni `FrameRect`. */
+function rectToFrame(rect) {
+	return {
+		x: rect.x,
+		y: rect.y,
+		width: rect.w,
+		height: rect.h
+	};
+}
+/** Build a `Rect` from loose x/y/width/height fields. */
+function rectOf(x, y, width, height) {
+	return {
+		x,
+		y,
+		w: width,
+		h: height
+	};
+}
+function createLayerRenderer(gpu, layer, options = {}) {
+	const clearLayer = options.clearLayer ?? true;
+	let lastRegions = [];
+	return {
+		get lastRegions() {
+			return lastRegions;
+		},
+		beginFrame(regions) {
+			lastRegions = regions;
+			if (clearLayer) layer.clear();
+			options.onBeginFrame?.(regions);
+		},
+		endFrame() {
+			options.onEndFrame?.();
+			const extra = options.extraLayers?.() ?? [];
+			const fullFrame = options.isFullFrame?.() ?? true;
+			gpu.render([layer, ...extra], {
+				regions: lastRegions.map((r) => ({
+					minX: r.x,
+					minY: r.y,
+					maxX: r.x + r.w,
+					maxY: r.y + r.h
+				})),
+				fullFrame
+			});
+		}
+	};
+}
+var GpuSceneNode = class extends SceneNode$1 {
+	paint(_layer) {
+		const root = this.gpuRoot();
+		if (!root) return;
+		this.drawSelf(root.layer);
+		for (const child of this.children) child.paint(void 0);
+	}
+	/** Walk the parent chain to the owning GpuSceneRoot, or null if detached. */
+	gpuRoot() {
+		let n = this;
+		while (n) {
+			if (n instanceof GpuSceneRoot) return n;
+			n = n.parent;
+		}
+		return null;
+	}
+	/** Mark a visual-only change: repaint, no data/layout rebuild. */
+	invalidatePaint(rect) {
+		this.markDamaged("paint", rect);
+	}
+	/** Mark a layout change (bounds/children moved). Triggers doLayout + paint. */
+	invalidateLayout(rect) {
+		this.markDamaged("layout", rect);
+	}
+	/** Mark a data change (inputs replaced). Triggers rebuildData → layout → paint. */
+	invalidateData(rect) {
+		this.markDamaged("data", rect);
+	}
+};
+var GpuSceneRoot = class extends SceneRoot$1 {
+	/** The scene layer that descendant nodes paint into. */
+	layer;
+	/** The underlying WebGPU renderer. */
+	gpu;
+	constructor(gpu, layer, options = {}) {
+		let self = null;
+		super(createLayerRenderer(gpu, layer, {
+			...options,
+			isFullFrame: () => self?.fullFrame ?? true
+		}), options);
+		self = this;
+		this.gpu = gpu;
+		this.layer = layer;
+		this.fullFrame = options.fullFrame ?? true;
+	}
+	paint(_layer) {
+		for (const child of this.children) child.paint(void 0);
+	}
+	/**
+	* Force a full repaint on the next scheduled frame. Use when widget internals
+	* are mutated outside a damage-tracked setter; normal state changes mark their
+	* own damage and don't need this. (`setBounds` to the same rect is a no-op, so
+	* it can't be used for this.)
+	*/
+	requestPaint() {
+		this._emitDamage({
+			rect: this.bounds,
+			kind: "paint"
+		});
+	}
+};
+//#endregion
+export { DirtyChannel, GpuSceneNode, GpuSceneRoot, ManualScheduler, MicrotaskScheduler, PointerRouter, RAFScheduler, RectSpace, SceneNode, SceneRoot, Signal, SyncScheduler, createLayerRenderer, frameToRect, pointInRect, rectClamp, rectEquals, rectOf, rectOverlaps, rectToFrame, unionRects };

package/dist/text-font-D7GGDtTK.d.mts

@@ -0,0 +1,185 @@
+import { TgpuRoot } from "typegpu";
+import { MsdfGlyph } from "insomni-msdf-text";
+
+//#region src/core/root.d.ts
+interface RootBacked {
+  device: GPUDevice;
+  root?: TgpuRoot;
+}
+type GPUOwner = GPUDevice | TgpuRoot | RootBacked;
+declare function resolveRoot(owner: GPUOwner): TgpuRoot;
+//#endregion
+//#region src/shared/texture.d.ts
+/** Borrowed sub-region of a caller-owned {@link Texture}. */
+interface TextureRegion {
+  readonly texture: Texture;
+  readonly uvMin: readonly [number, number];
+  readonly uvMax: readonly [number, number];
+}
+/**
+ * Caller-owned GPU texture wrapper used by sprite APIs.
+ *
+ * `Layer`, `SpriteAtlas`, `GridAtlas`, and `Renderer2D` may retain references
+ * to a `Texture`, but none of them take ownership of it or destroy it on the caller's behalf.
+ */
+declare class Texture {
+  readonly id: number;
+  readonly gpuTexture: GPUTexture;
+  readonly view: GPUTextureView;
+  readonly width: number;
+  readonly height: number;
+  private _destroyed;
+  constructor(gpuTexture: GPUTexture, width: number, height: number);
+  /** Sub-region by pixel coordinates. */
+  region(x: number, y: number, w: number, h: number): TextureRegion;
+  /** Sub-region by normalized UV coordinates. */
+  regionUV(u0: number, v0: number, u1: number, v1: number): TextureRegion;
+  get destroyed(): boolean;
+  /**
+   * Release the underlying GPU texture.
+   *
+   * Destroying a texture that is still referenced by a `Layer` is a caller error.
+   * Future sprite draws that still reference it will throw a clear runtime error.
+   */
+  destroy(): void;
+  private ensureAlive;
+}
+interface SpriteAtlasRegionDef {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+declare class SpriteAtlas {
+  private readonly _regions;
+  constructor(texture: Texture, regions: Record<string, SpriteAtlasRegionDef>);
+  region(name: string): TextureRegion;
+}
+interface GridAtlasOptions {
+  /** Cell size in pixels [width, height]. */
+  cell: [number, number];
+  rows?: number;
+  cols?: number;
+}
+declare class GridAtlas {
+  private readonly texture;
+  private readonly cellW;
+  private readonly cellH;
+  private readonly cols;
+  private readonly rows;
+  constructor(texture: Texture, options: GridAtlasOptions);
+  /** Get a frame by linear index, or by (row, col). */
+  frame(indexOrRow: number, col?: number): TextureRegion;
+}
+interface LoadTextureOptions {
+  /** GPUTextureFormat for the created texture. Default: 'rgba8unorm'. */
+  format?: GPUTextureFormat;
+  label?: string;
+}
+/**
+ * Load a texture from a URL or any ImageBitmapSource.
+ * The result is in premultiplied alpha format, matching the renderer's blend state.
+ *
+ * The returned `Texture` remains caller-owned. The renderer may cache per-texture bind groups
+ * while it is in use, but it will never destroy the texture for you.
+ */
+declare function loadTexture(owner: GPUOwner, src: string | ImageBitmapSource, options?: LoadTextureOptions): Promise<Texture>;
+interface SamplerDescriptor {
+  /** Mag/min filter. Default: 'linear'. */
+  filter?: "linear" | "nearest";
+  /** UV addressing mode. Default: 'clamp-to-edge'. */
+  addressMode?: GPUAddressMode;
+  /** Mipmap filter. Default: 'linear'. */
+  mipmapFilter?: GPUMipmapFilterMode;
+}
+//#endregion
+//#region src/text/text-font.d.ts
+interface GlyphAtlasOptions {
+  /** Side length of the square atlas texture. Default 2048. */
+  atlasSize?: number;
+  /**
+   * Em size in atlas texels — the base resolution at which glyphs are
+   * rasterized. Larger = sharper rendering at high zoom, more atlas pressure.
+   * Default 64.
+   */
+  atlasFontSize?: number;
+  /**
+   * Distance range in atlas texels. Wider = thicker outlines / softer
+   * shadows but lower precision. Default 8.
+   */
+  pxRange?: number;
+  label?: string;
+}
+interface MeasureTextOptions {
+  fontSize: number;
+  maxWidth?: number;
+  lineHeight?: number;
+  fontFamily?: string;
+  fontWeight?: string | number;
+  fontStyle?: string;
+  /**
+   * Skip kerning, multi-line splits, and wrap. Pairs with the same flag on
+   * `TextShape` so a measured width matches what `pushText` will lay out.
+   */
+  simple?: boolean;
+}
+interface TextMetrics {
+  width: number;
+  height: number;
+}
+/**
+ * Common interface for both TTF (`Font`) and system (`RasterFont`) fonts.
+ *
+ * Em-relative metrics are normalized so the shaper works identically across
+ * kinds. Kerning is optional — `RasterFont` always returns 0.
+ */
+interface TextFont {
+  readonly family: string;
+  readonly unitsPerEm: number;
+  /** Em-relative; positive Y up. */
+  readonly ascender: number;
+  /** Em-relative; negative. */
+  readonly descender: number;
+  /** Em-relative gap added between successive baselines. */
+  readonly lineGap: number;
+  getKerning(left: number, right: number): number;
+}
+/**
+ * Glyph atlas — owns the GPU atlas texture and lazily rasterizes glyphs on
+ * first request. Both MSDF (TTF) and SDF (raster) implementations satisfy
+ * this interface.
+ */
+interface GlyphAtlas {
+  readonly font: TextFont;
+  readonly pxRange: number;
+  readonly atlasFontSize: number;
+  readonly atlasSize: number;
+  readonly texture: Texture;
+  readonly glyphCount: number;
+  readonly destroyed: boolean;
+  /** Approximate fill percentage based on shelf cursor position. */
+  readonly fillPercent: number;
+  /**
+   * Monotonic counter incremented every time a new glyph is allocated.
+   * External GPU mirrors of the atlas (e.g. a metrics LUT) compare against
+   * a stored value to detect when a re-sync is needed.
+   */
+  readonly version: number;
+  /**
+   * Return the glyph entry for `codepoint`, generating it on first request.
+   * Returns null when the font lacks the glyph or the atlas is full.
+   */
+  getGlyph(codepoint: number): MsdfGlyph | null;
+  /**
+   * Fetch a glyph by its `atlasGlyphId` (the sequential id assigned at
+   * allocation time). Returns `undefined` for unknown ids. Used by GPU
+   * mirrors to walk newly added entries on sync.
+   */
+  getGlyphById(id: number): MsdfGlyph | undefined;
+  measureText(text: string, options: MeasureTextOptions): TextMetrics;
+  /** Pre-generate a string of glyphs. Useful for warming the atlas at startup. */
+  preload(text: string): void;
+  destroy(): void;
+}
+//#endregion
+export { resolveRoot as _, TextMetrics as a, GridAtlasOptions as c, SpriteAtlas as d, SpriteAtlasRegionDef as f, GPUOwner as g, loadTexture as h, TextFont as i, LoadTextureOptions as l, TextureRegion as m, GlyphAtlasOptions as n, MsdfGlyph as o, Texture as p, MeasureTextOptions as r, GridAtlas as s, GlyphAtlas as t, SamplerDescriptor as u };

package/dist/text-ttf.d.mts

@@ -0,0 +1,91 @@
+import { a as TextMetrics, g as GPUOwner, n as GlyphAtlasOptions, o as MsdfGlyph, p as Texture, r as MeasureTextOptions, t as GlyphAtlas } from "./text-font-D7GGDtTK.mjs";
+import { Font, Font as Font$1, FontOptions, FontSource, loadFont, parseFont } from "insomni-msdf-text";
+
+//#region src/text/msdf-adapter.d.ts
+declare class MsdfGlyphAtlas implements GlyphAtlas {
+  readonly font: Font$1;
+  private readonly _atlas;
+  private readonly _texture;
+  private measureCache;
+  private measureCacheVersion;
+  constructor(owner: GPUOwner, font: Font$1, options?: GlyphAtlasOptions);
+  get pxRange(): number;
+  get atlasFontSize(): number;
+  get atlasSize(): number;
+  get texture(): Texture;
+  get glyphCount(): number;
+  get destroyed(): boolean;
+  get fillPercent(): number;
+  get version(): number;
+  getGlyph(codepoint: number): MsdfGlyph | null;
+  getGlyphById(id: number): MsdfGlyph | undefined;
+  measureText(text: string, options: MeasureTextOptions): TextMetrics;
+  preload(text: string): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/text/cpu-glyph-atlas.d.ts
+declare class CpuGlyphAtlas implements GlyphAtlas {
+  readonly font: Font$1;
+  readonly pxRange: number;
+  readonly atlasFontSize: number;
+  readonly atlasSize: number;
+  private readonly cache;
+  /** Glyphs indexed by `atlasGlyphId`. Append-only; mirrors MsdfGlyphAtlas. */
+  private readonly _glyphList;
+  /** Bumps every time `_glyphList` grows. */
+  private _version;
+  private readonly measureCache;
+  private _destroyed;
+  constructor(font: Font$1, options?: GlyphAtlasOptions);
+  get version(): number;
+  get glyphCount(): number;
+  get destroyed(): boolean;
+  /** Always 0 — no shelf packer needed (no texture). */
+  get fillPercent(): number;
+  /**
+   * CPU atlas has no GPU texture. Throws if accessed so misuse is loud, not
+   * silent corruption. The SVG renderer never reads `texture` — it gates on
+   * `layer.atlas` and decodes via `getGlyphById` (`svg-renderer.ts:285`).
+   */
+  get texture(): Texture;
+  /**
+   * Return the glyph entry for `codepoint`, computing metrics from the font
+   * outline on first request. UVs are set to 0 (no texture).
+   *
+   * Mirrors `MsdfGlyphAtlas.getGlyph` (atlas.ts:133-232) with the
+   * shelf-packer, `generate()`, and UV-from-origin math removed.
+   */
+  getGlyph(codepoint: number): MsdfGlyph | null;
+  /**
+   * Fetch a glyph by its `atlasGlyphId` (allocation order). O(1) array lookup.
+   * This is the decode contract: `svg-renderer.ts:512` calls this to reconstruct
+   * the original codepoint from a glyph-pack instance.
+   */
+  getGlyphById(id: number): MsdfGlyph | undefined;
+  /**
+   * Verbatim copy of `msdf-adapter.ts:75-109` — depends only on `this.font`
+   * and `this` as the GlyphAtlas shaper arg (no GPU involvement).
+   */
+  measureText(text: string, options: MeasureTextOptions): TextMetrics;
+  /** Pre-warm the glyph cache for a string of text. No GPU work. */
+  preload(text: string): void;
+  /** Clear caches and mark as destroyed. */
+  destroy(): void;
+}
+declare function sharedCpuGlyphAtlas(): CpuGlyphAtlas;
+/**
+ * Create a non-singleton `CpuGlyphAtlas`, optionally with a custom font.
+ *
+ * - Pass `font` (an already-parsed `Font`) for zero-overhead construction.
+ * - Pass `fontBytes` (ArrayBuffer or Uint8Array) to parse on construction.
+ * - Pass neither to fall back to the embedded Lato subset (same font as the
+ *   shared singleton, but a fresh atlas instance).
+ */
+declare function createCpuGlyphAtlas(opts?: {
+  font?: Font$1;
+  fontBytes?: ArrayBuffer | Uint8Array;
+  options?: GlyphAtlasOptions;
+}): CpuGlyphAtlas;
+//#endregion
+export { CpuGlyphAtlas, Font, type FontOptions, type FontSource, MsdfGlyphAtlas, createCpuGlyphAtlas, loadFont, parseFont, sharedCpuGlyphAtlas };