insomni 0.2.0-alpha.0

package/dist/index-DkJfpntS.d.mts

@@ -0,0 +1,2417 @@
+import { At as TextStyleTable, Dt as TextOutline, Et as TextGradient, Ot as TextShadow, _r as Color, gn as Logger, r as Renderer2D, vt as Layer, yt as LayerOptions, z as AABB } from "./renderer-DzZqd1bY.mjs";
+import { N as FrameRect, R as Vec2, S as Mat3, f as CameraViewport, g as Viewport, i as ResolvedCameraState, n as CameraState, r as FitCameraToBoundsOptions, t as Bounds2D } from "./camera-view-DHmMiKvP.mjs";
+import { a as TextMetrics, g as GPUOwner, i as TextFont, n as GlyphAtlasOptions, o as MsdfGlyph, p as Texture, r as MeasureTextOptions, t as GlyphAtlas } from "./text-font-D7GGDtTK.mjs";
+import { a as ReadableSignal } from "./index-CmMZCMJT.mjs";
+import { TgpuBindGroup, TgpuRoot } from "typegpu";
+
+//#region src/core/device.d.ts
+interface GPUHandle {
+  adapter: GPUAdapter;
+  device: GPUDevice;
+  root: TgpuRoot;
+  /** Features the adapter granted. Subset of the caller's `requiredFeatures`. */
+  features: ReadonlySet<GPUFeatureName>;
+  destroy(): void;
+}
+interface InitGPUOptions extends GPURequestAdapterOptions {
+  maxAdapterAttempts?: number;
+  retryDelayMs?: number;
+  /**
+   * Features to enable if the adapter exposes them. Unsupported entries are
+   * silently dropped — no rejection, no warning. Use `handle.features.has(...)`
+   * on the returned handle to branch at runtime.
+   */
+  requiredFeatures?: readonly GPUFeatureName[];
+  /**
+   * Limits to request on the device. Each entry is clamped to the adapter's
+   * supported maximum — unsupported keys or over-max values are silently
+   * lowered rather than rejected. Pass `"adapter-max"` as the value to opt
+   * into whatever ceiling the adapter exposes for that limit.
+   */
+  requiredLimits?: Record<string, number | "adapter-max">;
+  /**
+   * Diagnostic logger for library output (device-loss / GPU validation errors,
+   * warnings). Installed process-wide via {@link setLogger} so the diagnostic
+   * sites in unrelated modules pick it up too. Defaults to `console`.
+   */
+  logger?: Logger;
+  /**
+   * Invoked when the device is lost for a reason OTHER than an intentional
+   * {@link GPUHandle.destroy} (`info.reason !== "destroyed"`) — e.g. a GPU
+   * reset, driver crash, or TDR. This is a NOTIFY-ONLY seam for alpha: insomni
+   * does NOT auto-recreate the device or rebuild GPU resources. Callers wanting
+   * recovery should tear down their renderer and re-run `initGPU` from this
+   * hook. (Auto-reinit is deferred — it requires re-uploading every retained
+   * buffer and re-binding pipelines, which the renderer does not yet support.)
+   */
+  onDeviceLost?: (info: GPUDeviceLostInfo) => void;
+  /**
+   * Invoked for each uncaptured GPU error (`device.onuncapturederror`) in
+   * addition to logging it via {@link logger}. Use to surface GPU validation /
+   * out-of-memory errors to the host app. Cheap: a single event listener, no
+   * per-frame error-scope wrapping.
+   */
+  onUncapturedError?: (error: GPUError) => void;
+}
+declare function initGPU(options?: InitGPUOptions): Promise<GPUHandle>;
+declare function getLastGPUHandle(): GPUHandle | null;
+//#endregion
+//#region src/svg-renderer.d.ts
+interface SVGRendererOptions {
+  width?: number;
+  height?: number;
+  camera?: CameraState;
+  /**
+   * Device-pixel ratio used to scale `space: "ui"` layers into the SVG viewBox.
+   * Default: 1.
+   */
+  dpr?: number;
+}
+/**
+ * CPU-only SVG export backend for the v3 renderer. Consumes the same
+ * `readonly Layer[]` as `Renderer2D.render()` and produces an SVG string.
+ *
+ * Supported: rect / circle / ellipse (`<rect>` / `<circle>` / `<ellipse>`),
+ * segment (`<line>`), curve (`<path>` cubic), arc (`<path>` arc), triangle /
+ * polygon (`<polygon>`), and text (`<text>`, recovered from the glyph atlas).
+ * Honors per-layer `space` (world / ui / device), the camera, per-shape group
+ * transforms (folded — see note), and per-layer clip rects.
+ *
+ * NOT supported (warn-and-skip): sprites / textures (`TYPE_SPRITE` is a
+ * Phase-4 concern — see `kinds/kind.ts`), BufferLayer compute output (no CPU
+ * introspection of GPU buffers).
+ */
+declare class SVGRenderer {
+  private _width;
+  private _height;
+  private _dpr;
+  private _camera;
+  private _background;
+  private _lastSvg;
+  private readonly warned;
+  constructor(options?: SVGRendererOptions);
+  get width(): number;
+  get height(): number;
+  get dpr(): number;
+  setDpr(dpr: number): void;
+  resize(width: number, height: number): void;
+  setBackground(color: Color): void;
+  setCamera(state: CameraState): void;
+  getCamera(): ResolvedCameraState;
+  fitCameraToBounds(bounds: Bounds2D, options?: FitCameraToBoundsOptions): void;
+  getViewMatrix(): Mat3;
+  screenToWorld(sx: number, sy: number): Vec2;
+  worldToScreen(wx: number, wy: number): Vec2;
+  /** SVG has no GPU compute phase. */
+  compute(_dispatch: (pass: GPUComputePassEncoder) => void): void;
+  /**
+   * Render `layers` to an SVG document and return it as a string. Layers are
+   * composited in array order. The returned string is also cached and exposed
+   * via `svg()` / `element()`.
+   */
+  render(layers: readonly Layer[]): string;
+  /** The SVG produced by the most recent `render()` call (empty before the first). */
+  svg(): string;
+  /**
+   * Parse the most recent `render()` output into an `SVGSVGElement`. Requires a
+   * DOM (`DOMParser`); throws in a pure-Node environment. Use `svg()` for the
+   * string form in Node.
+   */
+  element(): SVGSVGElement;
+  destroy(): void;
+  /** Build the `<g>` body for one layer (base VP + shape commands + glyphs). */
+  private renderLayerBody;
+  private emitCommand;
+  private emitShapes;
+  private rectEl;
+  private emitSegments;
+  private emitCurves;
+  private emitArcs;
+  private emitTriangles;
+  /**
+   * Emit `<text>` elements recovered from glyph instances. The GlyphPack does
+   * NOT retain the original strings, so we reconstruct text by walking the
+   * glyph instances in pack order, grouping consecutive glyphs that share a
+   * baseline (same packed `y` and color) into one run, and mapping each glyph's
+   * `atlasGlyphId` (lane0) back to its codepoint via the atlas. The run's left
+   * edge (min x) and the first glyph's top set the `<text>` origin.
+   *
+   * `anchored` glyphs hold a world anchor in geom0.xy (the live GPU path
+   * projects them per-frame); here we leave them in the layer's base VP like
+   * any other glyph, which is correct for `world` layers (the base VP already
+   * carries the camera projection).
+   */
+  private emitGlyphs;
+  private wrapWithClip;
+  private warnOnce;
+}
+declare function createSVGRenderer(options?: SVGRendererOptions): SVGRenderer;
+//#endregion
+//#region src/layers/mirror-layer.d.ts
+/**
+ * LOD options for a simplified mirror. Skipping categories cuts CPU→GPU
+ * upload and draw-call overhead for overview / minimap renders where the
+ * primary's fine details are unreadable or invisible at the reduced scale.
+ *
+ * A bare `true` enables a sensible default preset:
+ * `{ skipTriangles: true, skipSprites: true }`.
+ */
+interface MirrorSimplify {
+  /**
+   * Omit triangle draws — polygon fills, polyline tessellations, and filled
+   * line strokes. Shape rects/circles/ellipses are unaffected. Default: false.
+   */
+  skipTriangles?: boolean;
+  /**
+   * Omit sprite commands (raster images / MSDF text glyphs). Default: false.
+   */
+  skipSprites?: boolean;
+  /**
+   * Strip stroke color and stroke-width from SDF shape records
+   * (rect, circle, ellipse). Shapes render fill-only. Outline-only shapes
+   * (fill alpha 0, stroke alpha > 0) are preserved and their stroke width is
+   * multiplied by {@link outlineBoost} so they stay readable at minimap scale.
+   * Default: false.
+   */
+  stripStrokes?: boolean;
+  /**
+   * Multiplier applied to the stroke width of preserved outline-only shapes
+   * when {@link stripStrokes} is on. Default: 1.
+   */
+  outlineBoost?: number;
+}
+interface MirrorLayerOptions {
+  /**
+   * CSS-pixel scissor / crop rect. Passed as `clip` to the Layer super
+   * constructor. Defaults to `undefined` (full viewport).
+   */
+  clip?: LayerOptions["clip"];
+  /**
+   * Enable LOD simplification. When set, the mirror owns a derived pack built
+   * by filtering the primary's draw commands. Call {@link MirrorLayer.refresh}
+   * after mutating the primary to rebuild. Without this option (default), the
+   * mirror shares the primary's pack by reference and auto-tracks primary pushes.
+   */
+  simplify?: MirrorSimplify | true;
+}
+/**
+ * A {@link Layer} that re-renders another layer's packed shapes through a
+ * different viewport / clip rect. By default shares the primary's `_pack`
+ * by reference, so any push to the primary appears in the mirror on the next
+ * frame at zero CPU cost.
+ *
+ * Pass `simplify` to enable LOD: the mirror then owns a derived pack built by
+ * filtering the primary's draw commands by kind. Call
+ * {@link MirrorLayer.refresh} after mutating the primary to rebuild.
+ *
+ * Push and clear methods throw — mutate the primary instead.
+ */
+declare class MirrorLayer extends Layer {
+  /** Primary layer this mirror tracks. */
+  readonly primary: Layer;
+  private readonly _simplify;
+  private _lastVersion;
+  constructor(primary: Layer, options?: MirrorLayerOptions);
+  /**
+   * In simplify mode: rebuild the derived pack from the primary if the
+   * primary's pack version has advanced since the last refresh. No-op
+   * otherwise. Calling this on a non-simplify mirror is always a no-op.
+   */
+  refresh(): this;
+  clear(): this;
+  pushRect(): this;
+  pushCircle(): this;
+  pushEllipse(): this;
+  pushSegment(): this;
+  pushLine(): this;
+  pushCurve(): this;
+  pushArc(): this;
+  pushTriangle(): this;
+  pushPolygon(): this;
+}
+/**
+ * Construct a {@link MirrorLayer} that renders `primary`'s shapes through a
+ * different viewport. See {@link MirrorLayer} for constraints.
+ */
+declare function mirrorLayer(primary: Layer, options?: MirrorLayerOptions): MirrorLayer;
+//#endregion
+//#region src/interaction/constants.d.ts
+/**
+ * Movement in CSS pixels a pointer may travel between press and release
+ * while still firing onPress (above this → drag).
+ */
+declare const PRESS_MOVEMENT_THRESHOLD_PX = 4;
+/** Default zIndex for user-registered nodes. */
+declare const USER_DEFAULT_Z = 0;
+/** Viewport-scoped interactions (data viewports) register below user nodes. */
+declare const VIEWPORT_Z = -100;
+/** Camera viewports register below data viewports. */
+declare const CAMERA_Z = -200;
+//#endregion
+//#region src/interaction/node.d.ts
+interface Mods {
+  shift: boolean;
+  ctrl: boolean;
+  meta: boolean;
+  alt: boolean;
+}
+interface PointerInfo {
+  pointerId: number;
+  type: "mouse" | "touch" | "pen";
+  /** Element-local CSS pixels. */
+  x: number;
+  y: number;
+  /**
+   * Node-space coords.
+   * - `space: 'ui'` → same as `x` / `y` (element-local CSS px).
+   * - `space: 'world'` on a camera viewport → world units (post camera transform).
+   * - `space: 'world'` on a data viewport → CSS px local to `viewport.absoluteFrame`
+   *   (no axis-domain transform; use `viewport.screenToData` for that).
+   */
+  localX: number;
+  localY: number;
+  buttons: number;
+  mods: Mods;
+  stopPropagation(): void;
+}
+interface ScrollInfo {
+  pointerId: number;
+  /** Element-local CSS pixels. */
+  x: number;
+  y: number;
+  /** Wheel deltas in CSS pixels. */
+  dx: number;
+  dy: number;
+  mods: Mods;
+  stopPropagation(): void;
+}
+interface PinchInfo {
+  phase: "start" | "move" | "end";
+  /** Cumulative scale relative to start (1 at start and end). */
+  scaleFactor: number;
+  /** Incremental scale since the previous move (1 at start). */
+  deltaScale: number;
+  /** Midpoint of the two pointers, element-local CSS px. */
+  focalX: number;
+  focalY: number;
+  /** Focal-point delta since the previous move (0 at start), CSS px. */
+  deltaX: number;
+  deltaY: number;
+  mods: Mods;
+  stopPropagation(): void;
+}
+interface DragPointerInfo extends PointerInfo {
+  /** Delta from the previous pointermove, CSS pixels. */
+  dx: number;
+  dy: number;
+}
+interface InteractionNodeSpec {
+  /** Higher wins hit-test. Ties break by insertion order (later = on top). */
+  zIndex?: number;
+  /** `'world'` = transformed by viewport's camera; `'ui'` = CSS-pixel local. Default `'ui'`. */
+  space?: "world" | "ui";
+  /** Required when `space === 'world'`. Optional frame for `'ui'`. */
+  viewport?: Viewport;
+  /** Cheap bounds test. Coordinates are element-local CSS px. */
+  bounds?: () => FrameRect;
+  /** Fine-grained test in node-space coords. Called only if `bounds` passed. */
+  contains?: (x: number, y: number) => boolean;
+  /**
+   * If true, this node is skipped during hit-testing entirely (events fall
+   * through to nodes below). v1 treats passthrough as "decorative / never
+   * claims." True fan-out (claim AND continue) is v2.
+   */
+  passthrough?: boolean;
+  /** Cursor applied while hovering this node. */
+  cursor?: string;
+  /** Cursor applied while actively dragging this node. Defaults to `cursor`. */
+  dragCursor?: string;
+  /** Whether the node responds to events. Default: true. */
+  enabled?: boolean;
+  /**
+   * Extra hit radius (CSS px) added to bounds/contains checks for touch
+   * pointers only. Defaults to 0. Recommended: 10–20 for small marks.
+   * Mouse and pen hit-testing is never affected.
+   */
+  touchHitSlop?: number;
+  onHoverEnter?(evt: PointerInfo): void;
+  onHoverMove?(evt: PointerInfo): void;
+  onHoverLeave?(evt: PointerInfo): void;
+  onPress?(evt: PointerInfo): void;
+  onDragStart?(evt: PointerInfo): void;
+  onDragMove?(evt: DragPointerInfo): void;
+  onDragEnd?(evt: PointerInfo): void;
+  /** Wheel only. Pinch is delivered via `onPinch`. */
+  onScroll?(evt: ScrollInfo): void;
+  onPinch?(evt: PinchInfo): void;
+}
+interface InteractionNode {
+  readonly id: symbol;
+  /** Patch the spec in place (e.g., toggle enabled, swap bounds). */
+  update(patch: Partial<InteractionNodeSpec>): void;
+  /** Unregister. Fires pending onDragEnd / onHoverLeave / onPinch end as needed. */
+  destroy(): void;
+}
+//#endregion
+//#region src/interaction/point-cloud.d.ts
+interface PointCloudSpec {
+  /** `[x0, y0, x1, y1, ...]` in the declared `space`. */
+  points: ReadonlyArray<number> | Float32Array;
+  /**
+   * Coordinate space the points live in.
+   * - `'ui'` → element-local CSS px.
+   * - `'world'` → world units (requires a camera viewport).
+   * Defaults to `'ui'`.
+   */
+  space?: "world" | "ui";
+  /** Required when `space: 'world'` and the viewport is a camera viewport. */
+  viewport?: Viewport;
+  /**
+   * Nearest-within selection radius, CSS pixels. When set, the nearest point
+   * within this radius of the pointer is hovered.
+   */
+  nearestWithin?: number;
+  /**
+   * Exact hit radius per point (CSS pixels) when `nearestWithin` is not set.
+   * First point found within radius wins.
+   */
+  hitRadius?: number;
+  /**
+   * Distance metric for nearest-point queries.
+   * - `"xy"` (default) — Euclidean distance, picks point closest in 2D.
+   * - `"x"` — only x-axis distance counts; the off-axis y is ignored. Useful
+   *   for "nearest x" hover modes on lines/areas where the cursor's vertical
+   *   position shouldn't influence which vertex is selected.
+   * - `"y"` — symmetric, x ignored.
+   */
+  pickAxis?: "x" | "y" | "xy";
+  /** Higher wins hit-test. */
+  zIndex?: number;
+  /** Disable without tearing down state. */
+  enabled?: boolean;
+  onHoverEnter?(index: number, evt: PointerInfo): void;
+  onHoverLeave?(index: number, evt: PointerInfo): void;
+  onPress?(index: number, evt: PointerInfo): void;
+}
+interface PointCloudNode extends InteractionNode {
+  /** Replace the point array. Triggers a grid rebuild. */
+  setPoints(points: ReadonlyArray<number> | Float32Array): void;
+  /** Enable / disable without tearing down the grid. */
+  setEnabled(enabled: boolean): void;
+}
+/**
+ * Registers a point cloud as a single InteractionNode. The manager delegates
+ * hit-testing through a uniform spatial grid keyed on the declared `space`.
+ *
+ * World-space point clouds on camera viewports:
+ *   - Points are stored in world units.
+ *   - The pointer is transformed into world coords at query time (no rebuild
+ *     on camera change).
+ *   - The CSS-px `nearestWithin` radius is converted to world units via
+ *     `radius / camera.zoom`.
+ */
+declare function registerPointCloud(manager: InteractionManager, element: HTMLElement, spec: PointCloudSpec): PointCloudNode;
+//#endregion
+//#region src/interaction/manager.d.ts
+interface BackgroundTapInfo {
+  /** Element-local CSS pixel coordinates at pointerup. */
+  x: number;
+  y: number;
+  pointerId: number;
+  type: "mouse" | "touch" | "pen";
+  mods: Mods;
+}
+interface GestureEventInfo {
+  /** Element-local CSS pixel coordinates. */
+  x: number;
+  y: number;
+  source: "mouse" | "touch" | "pen" | "keyboard";
+  mods: Mods;
+  originalEvent: Event | null;
+}
+interface ContextMenuOpts {
+  /** Touch hold duration before contextMenuRequest fires. Default 500ms. */
+  holdMs?: number;
+  /** Max pointer movement during hold (CSS px) before cancellation. Default 5. */
+  slopPx?: number;
+}
+interface DoubleTapOpts {
+  /** Max interval between the two taps. Default 300ms. */
+  withinMs?: number;
+  /** Max distance between the two taps (CSS px). Default 5. */
+  slopPx?: number;
+}
+interface InteractionManager {
+  /** Element whose listeners and touch-behavior this manager owns. */
+  readonly element: HTMLElement;
+  add(spec: InteractionNodeSpec): InteractionNode;
+  addPointCloud(spec: PointCloudSpec): PointCloudNode;
+  /**
+   * Subscribe to background taps — press-without-drag releases where no
+   * press-capable node claimed the press. Fires for genuine clicks on empty
+   * space (the common "click to deselect" pattern).
+   *
+   * Returns an unsubscribe function. The threshold for "not a drag" is the
+   * same as elsewhere ({@link PRESS_MOVEMENT_THRESHOLD_PX}).
+   */
+  onBackgroundTap(handler: (info: BackgroundTapInfo) => void): () => void;
+  /**
+   * Subscribe to context-menu requests — fires for native `contextmenu`
+   * events (right-click / Ctrl-click), touch long-press (≥holdMs hold,
+   * ≤slopPx movement), and keyboard synthesis (Shift+F10 or the dedicated
+   * ContextMenu key). The manager calls `preventDefault()` on the native
+   * `contextmenu` and on keyboard events while at least one listener is
+   * registered. The most recently passed `opts` win — multiple listeners
+   * with conflicting timings is not a supported configuration.
+   */
+  onContextMenuRequest(handler: (info: GestureEventInfo) => void, opts?: ContextMenuOpts): () => void;
+  /**
+   * Subscribe to double-tap / double-click. Fires on two `pointerup` events
+   * within `withinMs` and `slopPx`, where neither leg promoted to a drag.
+   * Does NOT suppress the underlying single-tap callbacks — consumers that
+   * need true "either-or" semantics should debounce in user code.
+   */
+  onDoubleTap(handler: (info: GestureEventInfo) => void, opts?: DoubleTapOpts): () => void;
+  /**
+   * Subscribe to any user-callback invocation by the manager (press, drag,
+   * hover, scroll, pinch, background tap). Pair with an `Invalidator` to
+   * drive on-demand rendering without reacting to pointer motion over inert
+   * areas. Fires synchronously each time a user callback runs; multiple
+   * invocations per DOM event are normal and idempotent for typical dirty-flag
+   * listeners.
+   */
+  onChange(cb: () => void): () => void;
+  /** Check if a point at local CSS-px coordinates hits any active node. */
+  hitTest(cssX: number, cssY: number): boolean;
+  /** Drop all nodes and listeners. The element loses its manager binding. */
+  destroy(): void;
+}
+declare function createInteractionManager(element: HTMLElement): InteractionManager;
+//#endregion
+//#region src/interaction/region-cloud.d.ts
+interface RegionCloudSpec {
+  /**
+   * Per-slot rects in element-local CSS pixels.
+   * Layout: `[x0, y0, w0, h0, x1, y1, w1, h1, ...]`.
+   */
+  rects: ReadonlyArray<number> | Float32Array;
+  /** Higher wins hit-test. */
+  zIndex?: number;
+  /** Disable without tearing down state. */
+  enabled?: boolean;
+  onHoverEnter?(index: number, evt: PointerInfo): void;
+  onHoverLeave?(index: number, evt: PointerInfo): void;
+  onPress?(index: number, evt: PointerInfo): void;
+}
+interface RegionCloudNode extends InteractionNode {
+  /** Replace the rect array. Triggers a grid rebuild. */
+  setRects(rects: ReadonlyArray<number> | Float32Array): void;
+  setEnabled(enabled: boolean): void;
+}
+/**
+ * Registers a rect cloud as a single InteractionNode. The manager delegates
+ * hit-testing through a uniform spatial grid in element-local CSS pixels.
+ */
+declare function registerRegionCloud(manager: InteractionManager, element: HTMLElement, spec: RegionCloudSpec): RegionCloudNode;
+//#endregion
+//#region src/interaction/hit-fanout.d.ts
+/**
+ * Opaque slot descriptor. Either `positions` (point cloud) or `rects` (region
+ * cloud) must be set — slots flip between the two by changing which is
+ * populated. `id` is for slot identity across syncs (stable id → fast path;
+ * different id → rebuild) and for state survival across in-place updates.
+ */
+interface HitSlot {
+  /** Stable identity. Used for fast-path matching across sync calls. */
+  id: string | number;
+  /** Flat `[x0,y0,x1,y1,...]` in element-local CSS px. Required for point slots. */
+  positions?: Float32Array;
+  /** Flat `[x,y,w,h, x,y,w,h, ...]` in element-local CSS px. Required for region slots. */
+  rects?: Float32Array;
+  /** Hit radius in element-local CSS px. Ignored for region slots. */
+  pickRadius: number;
+  /** Axis to restrict distance computation to. Default `"xy"` (Euclidean). */
+  pickAxis?: "x" | "y" | "xy";
+}
+interface HitFanOutEventContext {
+  /** Position of the dispatched hit, derived from the slot's geometry. */
+  position: {
+    x: number;
+    y: number;
+  };
+  /** Index of the slot the hit belongs to (in current sync's order). */
+  slotIdx: number;
+  /** Snapshot of the slot at dispatch time (the live ref the fan-out holds). */
+  slot: HitSlot;
+  /** Index into the slot's positions / rects array. */
+  hitIndex: number;
+  /** Raw pointer event that produced the hit. */
+  pointer: PointerInfo;
+}
+interface HitFanOutSubscriber {
+  /** Stable key for debugging — shown in dev-tools / error traces. */
+  key: string;
+  onHoverEnter?(ctx: HitFanOutEventContext): void;
+  onHoverLeave?(ctx: HitFanOutEventContext): void;
+  onPress?(ctx: HitFanOutEventContext): void;
+}
+/**
+ * Live snapshot of the dispatched hit. `slot` is read fresh on every `state()`
+ * call so consumers see in-place updates without re-subscribing — that's the
+ * whole reason this type exists separate from event ctxs.
+ */
+interface HitFanOutActive {
+  slotIdx: number;
+  slot: HitSlot;
+  hitIndex: number;
+  position: {
+    x: number;
+    y: number;
+  };
+}
+interface HitFanOutState {
+  active: HitFanOutActive | null;
+}
+interface PickAtOptions {
+  /**
+   * Slot kinds participating.
+   * - `"point"`: point slots only (pickRadius / pickAxis).
+   * - `"region"`: region slots only (rect containment).
+   * - `"any"`: both, region containment winning ties.
+   * Default `"any"`.
+   */
+  mode?: "point" | "region" | "any";
+}
+interface PickAtResult {
+  slotIdx: number;
+  slot: HitSlot;
+  hitIndex: number;
+  position: {
+    x: number;
+    y: number;
+  };
+}
+interface HitFanOutSpec {
+  manager: InteractionManager;
+  element: HTMLElement;
+  /**
+   * Base zIndex for slot hit-clouds. Each slot's cloud sits at
+   * `baseZIndex + slotIdx` so overlapping slots resolve in stable order.
+   * Defaults to `0` — pick a value above whatever else lives at that z.
+   */
+  baseZIndex?: number;
+}
+interface HitFanOut {
+  /** Replace the active slot set (typically called once per pipeline run). */
+  sync(slots: readonly HitSlot[]): void;
+  /** Register an event subscriber. Returns an unsubscribe fn. */
+  subscribe(sub: HitFanOutSubscriber): () => void;
+  /** Live view of the currently dispatched hit. */
+  state(): HitFanOutState;
+  /** Subscribe to `state()` transitions (enter / leave / sync-induced). */
+  subscribeState(fn: (state: HitFanOutState) => void): () => void;
+  /** One-shot lookup at element-local CSS coordinates. Highest-z slot wins. */
+  pickAt(x: number, y: number, opts?: PickAtOptions): PickAtResult | null;
+  dispose(): void;
+}
+declare function createHitFanOut(spec: HitFanOutSpec): HitFanOut;
+//#endregion
+//#region src/interaction/selection.d.ts
+/**
+ * Keyboard modifier policy for pointer-driven selection. Matches the common
+ * editor convention:
+ *
+ * - plain click  → replace selection with `{ id }`
+ * - shift-click  → toggle membership of `id`
+ * - meta/ctrl    → remove `id`
+ */
+type SelectionMods = Pick<Mods, "shift" | "meta" | "ctrl">;
+interface Selection<T> {
+  readonly size: number;
+  has(id: T): boolean;
+  values(): IterableIterator<T>;
+  /** Snapshot as an array. Useful when callers need a stable iteration order. */
+  toArray(): T[];
+  /** Single-selected id, if exactly one is selected; otherwise `undefined`. */
+  single(): T | undefined;
+  set(ids: Iterable<T>): void;
+  add(id: T): void;
+  delete(id: T): boolean;
+  clear(): void;
+  /**
+   * Apply a pointer gesture: plain → replace, shift → toggle, meta/ctrl → remove.
+   * Emits a change event only when the set actually changed.
+   */
+  pressFromEvent(id: T, mods: SelectionMods): void;
+  /** Subscribe to change events. Returns an unsubscribe function. */
+  onChange(handler: () => void): () => void;
+}
+declare function createSelection<T>(initial?: Iterable<T>): Selection<T>;
+//#endregion
+//#region src/interaction/hover.d.ts
+/**
+ * Tiny helper that collapses the `onHoverEnter / onHoverLeave` bookkeeping
+ * every interactive node repeats. One tracker per logical "group" of nodes
+ * (e.g. all shape nodes, all toolbar buttons). Each node registers an id —
+ * enter sets the current id, leave clears it only if still matching.
+ */
+interface HoverTracker<Id> {
+  /** Currently hovered id, or `null` if none. */
+  current(): Id | null;
+  /** True when the tracked current id equals `id`. */
+  isHovered(id: Id): boolean;
+  /**
+   * Returns `{ onHoverEnter, onHoverLeave }` handlers to spread into a
+   * {@link InteractionNodeSpec}. Works without stepping on any handlers the
+   * caller already defines; compose with your own if you need both.
+   */
+  bind(id: Id): Pick<InteractionNodeSpec, "onHoverEnter" | "onHoverLeave">;
+  /**
+   * Directly set (or clear) the current id. Useful when the hover signal
+   * comes from somewhere other than an {@link InteractionNode} — e.g. the
+   * index emitted by a {@link PointCloudNode}'s `onHoverEnter`.
+   */
+  set(id: Id | null): void;
+  /** Force the tracker to a specific state (e.g. on a global reset). */
+  reset(): void;
+}
+declare function trackHover<Id>(): HoverTracker<Id>;
+//#endregion
+//#region src/scheduler.d.ts
+interface Invalidator {
+  /** True if anything has invalidated since the last `clear()`. */
+  readonly dirty: boolean;
+  /** Mark dirty. Safe to call from event handlers. */
+  invalidate(): void;
+  /** Subscribe to invalidation edges. Useful for waking an on-demand RAF loop. */
+  onInvalidate(cb: () => void): () => void;
+  /** Clear the dirty flag. Call after a successful render. */
+  clear(): void;
+  /**
+   * Auto-invalidate whenever `source.onChange` fires. Returns an unsubscribe.
+   * The subscription is also released on `dispose()`.
+   */
+  track<T extends {
+    onChange(cb: () => void): () => void;
+  }>(source: T): () => void;
+  /**
+   * Auto-invalidate on the given DOM events. Defaults to pointer, wheel, and
+   * keyboard edges (no `pointermove` — hover-sensitive demos opt in).
+   */
+  trackElement(el: EventTarget, events?: readonly string[]): () => void;
+  /** Release every tracked subscription. */
+  dispose(): void;
+}
+declare function createInvalidator(initialDirty?: boolean): Invalidator;
+interface AnimatedValue {
+  /** Current eased value. */
+  readonly value: number;
+  /** Target the value is easing toward. */
+  readonly target: number;
+  /** True while `value` has not yet reached `target` (within `epsilon`). */
+  readonly active: boolean;
+  /**
+   * Update the target. Invalidates the paired scheduler when the target
+   * actually differs from the current value. Pass `immediate=true` to snap.
+   */
+  setTarget(value: number, immediate?: boolean): void;
+  /** Advance by `dt` seconds, easing `value` toward `target`. */
+  step(dt: number): void;
+}
+interface AnimateTowardOptions {
+  /** Starting value. Defaults to 0. */
+  initial?: number;
+  /**
+   * Easing rate. Higher = snappier. The per-frame interpolant is
+   * `1 - exp(-speed * dt)`, so behaviour is frame-rate independent.
+   */
+  speed?: number;
+  /** Distance from target below which `active` flips to false. */
+  epsilon?: number;
+  /** Optional invalidator that is flagged whenever the target moves. */
+  invalidator?: Invalidator;
+}
+declare function animateToward(opts?: AnimateTowardOptions): AnimatedValue;
+//#endregion
+//#region src/interaction/crosshair.d.ts
+interface CrosshairBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+type CrosshairAxis = "x" | "y" | "xy";
+interface CrosshairStyle {
+  color?: Color;
+  width?: number;
+  /** 0..1 — additional alpha multiplier applied to color.a. Default 1. */
+  opacity?: number;
+}
+interface CrosshairOptions {
+  /** Which guide line(s) to draw. Default "x" (vertical line tracking cursor x). */
+  axis?: CrosshairAxis;
+  /** Region in layer coordinates within which the lines are drawn. */
+  bounds: () => CrosshairBounds;
+  style?: CrosshairStyle;
+  /**
+   * Optional snap transform applied before drawing. Returns the snapped point
+   * (e.g., to the nearest data x), or `null` to suppress drawing for that
+   * frame. The unsnapped point is still exposed via `rawPosition`.
+   */
+  snap?: (p: Vec2) => Vec2 | null;
+  invalidator?: Invalidator;
+}
+interface Crosshair {
+  /** Snapped (or raw, when no snap) position currently displayed. Null when hidden. */
+  readonly position: Vec2 | null;
+  /** Raw position last passed to `setPosition`, before snap. Null when cleared. */
+  readonly rawPosition: Vec2 | null;
+  /** Set the cursor position. Pass `null` to hide the crosshair. */
+  setPosition(p: Vec2 | null): void;
+  draw(layer: Layer): void;
+  dispose(): void;
+}
+declare function createCrosshair(opts: CrosshairOptions): Crosshair;
+//#endregion
+//#region src/interaction/brush.d.ts
+interface BrushRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+type BrushAxis = "x" | "y" | "xy";
+/**
+ * Named edge or corner on a brush rect — used by `beginResize()` to identify
+ * which side(s) of the rect follow the cursor during a resize gesture. The
+ * single-letter names are the sides ("n", "s", "e", "w"); two-letter names
+ * are the corners ("ne", "nw", "se", "sw").
+ */
+type BrushEdge = "n" | "s" | "e" | "w" | "ne" | "nw" | "se" | "sw";
+interface BrushStyle {
+  fill?: Color;
+  stroke?: Color;
+  strokeWidth?: number;
+}
+interface BrushOptions {
+  /** Which axes the brush spans. Default `"xy"`. */
+  axis?: BrushAxis;
+  /** Region within which the brush is allowed; the rect is clamped to this. */
+  bounds: () => BrushRect;
+  style?: BrushStyle;
+  /** Fired when a brush gesture begins (after first update). */
+  onStart?(rect: BrushRect): void;
+  /** Fired on every position update. Receives the current normalized rect. */
+  onChange?(rect: BrushRect): void;
+  /**
+   * Fired on `end()` — after a successful drag. The committed rect (or null
+   * when the brush collapsed to zero area).
+   */
+  onEnd?(rect: BrushRect | null): void;
+  /**
+   * Optional snap transform applied after axis-lock + bounds-clamp. Returns
+   * the snapped rect (e.g. with edges snapped to nearest data values). Runs
+   * for every gesture update — including `begin`, `update`, `setRect`, and
+   * the initial state of `beginResize` / `beginTranslate` — so the live rect
+   * always reflects snapped positions.
+   */
+  snap?: (rect: BrushRect) => BrushRect;
+  invalidator?: Invalidator;
+}
+interface Brush {
+  /** Current normalized rect (or `null` when idle). */
+  readonly rect: BrushRect | null;
+  /** True between begin()/beginResize() and end()/cancel(). */
+  readonly active: boolean;
+  /** Start a brush at the given element-local coords. */
+  begin(x: number, y: number): void;
+  /**
+   * Begin a resize gesture on the existing rect. The opposite edge/corner is
+   * pinned; subsequent `update(x, y)` calls move the named edge/corner. No-op
+   * when no rect exists. Fires `onChange` (and eventually `onEnd`) like a
+   * regular brush gesture so callers see the resized rect through the same
+   * pipeline.
+   */
+  beginResize(edge: BrushEdge, x: number, y: number): void;
+  /**
+   * Begin a translate gesture on the existing rect. The rect's size is held
+   * constant; subsequent `update(x, y)` calls move the rect by the cursor
+   * delta from `(x, y)`, clamped so the rect stays within bounds. No-op when
+   * no rect exists. Off-axis movement is ignored when `axis` is `"x"` / `"y"`
+   * (the rect already spans bounds on the locked axis). Fires `onChange` /
+   * `onEnd` like other gestures.
+   */
+  beginTranslate(x: number, y: number): void;
+  /** Update the trailing corner of an active brush. No-op when idle. */
+  update(x: number, y: number): void;
+  /** Commit the active brush. Fires `onEnd` then settles into a static rect. */
+  end(): void;
+  /** Cancel an active brush and clear the rect. */
+  cancel(): void;
+  /** Imperatively set the rect (or `null` to clear). Skips begin/end callbacks. */
+  setRect(rect: BrushRect | null): void;
+  /** Push the rect into the layer. No-op when no rect is set. */
+  draw(layer: Layer): void;
+  dispose(): void;
+}
+declare function createBrush(opts: BrushOptions): Brush;
+//#endregion
+//#region src/interaction/tooltip.d.ts
+interface TooltipAnchor {
+  /** Element-space x in CSS pixels. */
+  x: number;
+  /** Element-space y in CSS pixels (Y-down to match pointer events). */
+  y: number;
+}
+interface TooltipRow {
+  label?: string;
+  value: string;
+  swatch?: Color;
+  /** Override row text color. */
+  color?: Color;
+  /** Override row font size. */
+  fontSize?: number;
+}
+interface TooltipContent {
+  title?: string;
+  rows: readonly TooltipRow[];
+}
+type TooltipPlacement = "top" | "bottom" | "left" | "right" | "auto";
+interface TooltipBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface TooltipMeasure {
+  (text: string, fontSize: number): {
+    width: number;
+    height: number;
+  };
+}
+interface TooltipStyle {
+  background?: Color;
+  border?: {
+    color: Color;
+    width: number;
+  };
+  cornerRadius?: number;
+  padding?: number;
+  rowGap?: number;
+  columnGap?: number;
+  swatchSize?: number;
+  fontSize?: number;
+  titleFontSize?: number;
+  textColor?: Color;
+  titleColor?: Color;
+  /** Gap between anchor and tooltip box in placement direction. Default 8. */
+  offset?: number;
+}
+interface TooltipOptions {
+  /** Default placement. "auto" tries top → bottom → right → left. Default "top". */
+  placement?: TooltipPlacement;
+  /** Bounds region for clamp/flip. Default: no clamp. */
+  bounds?: () => TooltipBounds;
+  /** Required: returns text size. Adapter over GlyphAtlas.measureText. */
+  measure: TooltipMeasure;
+  style?: TooltipStyle;
+  /** Hover-intent delay before showing (ms). Default 80. */
+  showDelay?: number;
+  /** Linger before hiding (ms). Default 100. */
+  hideDelay?: number;
+  /** Fade duration (ms). 0 disables fade. Default 120. */
+  fadeMs?: number;
+  /** Optional Invalidator: woken on visibility change and during fade/delay. */
+  invalidator?: Invalidator;
+}
+interface Tooltip {
+  /** Show with content at anchor. Subsequent calls update content+anchor. */
+  show(anchor: TooltipAnchor, content: TooltipContent): void;
+  /** Update only the anchor (cheaper than show when content is unchanged). */
+  move(anchor: TooltipAnchor): void;
+  /** Hide. Linger applies before fade-out. */
+  hide(): void;
+  /** Advance opacity + delays by dt seconds. */
+  step(dt: number): void;
+  /** Push tooltip into a UI/screen-space layer. No-op when fully hidden. */
+  draw(layer: Layer): void;
+  /** Logical visibility — what the caller most recently asked for. */
+  readonly visible: boolean;
+  /** Current animated opacity, 0..1. */
+  readonly opacity: number;
+  dispose(): void;
+}
+interface ResolvedStyle$1 {
+  background: Color;
+  border: {
+    color: Color;
+    width: number;
+  } | null;
+  cornerRadius: number;
+  padding: number;
+  rowGap: number;
+  columnGap: number;
+  swatchSize: number;
+  fontSize: number;
+  titleFontSize: number;
+  textColor: Color;
+  titleColor: Color;
+  offset: number;
+}
+interface TooltipRowLayout {
+  /** y of row top, relative to box's inner top-left. */
+  y: number;
+  /** Row height. */
+  height: number;
+  swatch: {
+    x: number;
+    y: number;
+    size: number;
+  } | null;
+  label: {
+    x: number;
+    y: number;
+    text: string;
+    fontSize: number;
+  } | null;
+  /** Right-aligned to inner width when label present, else left at column start. */
+  value: {
+    x: number;
+    y: number;
+    text: string;
+    fontSize: number;
+  };
+}
+interface TooltipLayout {
+  box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  innerOrigin: {
+    x: number;
+    y: number;
+  };
+  title: {
+    x: number;
+    y: number;
+    text: string;
+    fontSize: number;
+  } | null;
+  rows: TooltipRowLayout[];
+  placement: Exclude<TooltipPlacement, "auto">;
+}
+declare function layoutTooltip(anchor: TooltipAnchor, content: TooltipContent, measure: TooltipMeasure, style: ResolvedStyle$1, placement: TooltipPlacement, bounds: TooltipBounds | null): TooltipLayout;
+declare function createTooltip(opts: TooltipOptions): Tooltip;
+//#endregion
+//#region src/interaction/menu.d.ts
+interface MenuAnchor {
+  /** Element-space x in CSS pixels. */
+  x: number;
+  /** Element-space y in CSS pixels (Y-down to match pointer events). */
+  y: number;
+}
+interface MenuItem {
+  /** Stable identifier passed to `onAction`. Ignored for separators. */
+  id: string;
+  /** Display label. Ignored for separators. */
+  label: string;
+  /** Renders as a thin separator line; non-interactive. */
+  separator?: boolean;
+  /** Greyed out; hover/click ignored. */
+  disabled?: boolean;
+  /** Tinted with `dangerColor` (e.g. destructive actions). */
+  danger?: boolean;
+  /** Optional swatch rendered at the start of the row. */
+  swatch?: Color;
+  /** Optional right-aligned shortcut hint (e.g. "⌘D"). */
+  kbd?: string;
+}
+interface MenuContent {
+  items: readonly MenuItem[];
+}
+type MenuPlacement = "bottom-right" | "bottom-left" | "top-right" | "top-left" | "auto";
+interface MenuBounds {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface MenuMeasure {
+  (text: string, fontSize: number): {
+    width: number;
+    height: number;
+  };
+}
+interface MenuStyle {
+  background?: Color;
+  hoverBackground?: Color;
+  border?: {
+    color: Color;
+    width: number;
+  };
+  cornerRadius?: number;
+  paddingX?: number;
+  paddingY?: number;
+  itemHeight?: number;
+  itemPaddingX?: number;
+  fontSize?: number;
+  textColor?: Color;
+  disabledColor?: Color;
+  dangerColor?: Color;
+  separatorColor?: Color;
+  separatorHeight?: number;
+  swatchSize?: number;
+  swatchGap?: number;
+  kbdColor?: Color;
+  /** Min width for the box. Default 160. */
+  minWidth?: number;
+  /** Gap between anchor point and box. Default 4. */
+  offset?: number;
+}
+interface MenuOptions {
+  /** Default placement. "auto" tries bottom-right → bottom-left → top-right → top-left. Default "bottom-right". */
+  placement?: MenuPlacement;
+  /** Bounds region for clamp/flip. Default: no clamp. */
+  bounds?: () => MenuBounds;
+  /** Required: returns text size. Adapter over GlyphAtlas.measureText. */
+  measure: MenuMeasure;
+  style?: MenuStyle;
+  /** Fade duration (ms). 0 disables fade. Default 80. */
+  fadeMs?: number;
+  /** Optional Invalidator: woken on visibility change and during fade. */
+  invalidator?: Invalidator;
+}
+interface Menu {
+  /** Show with content at anchor. Subsequent calls update content+anchor. */
+  show(anchor: MenuAnchor, content: MenuContent): void;
+  /** Hide. Triggers fade-out. */
+  hide(): void;
+  /** Advance opacity by dt seconds. */
+  step(dt: number): void;
+  /** Push menu into a UI/screen-space layer. No-op when fully hidden. */
+  draw(layer: Layer): void;
+  /**
+   * Update which item is hovered. Pass element-local CSS px; the menu resolves
+   * to an item index internally. Pass `null` when the pointer leaves the menu
+   * box entirely so the highlight clears.
+   */
+  setHoverPosition(p: {
+    x: number;
+    y: number;
+  } | null): void;
+  /**
+   * One-shot item lookup at element-local CSS px. Returns the item id (or null
+   * if the point is outside the box, on a separator, or on a disabled item).
+   */
+  pickItemAt(x: number, y: number): string | null;
+  /**
+   * Element-local CSS rect occupied by the menu box, or null when hidden.
+   * Useful for binding an InteractionNode bounds to "the menu".
+   */
+  getBounds(): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  } | null;
+  /** Logical visibility — what the caller most recently asked for. */
+  readonly visible: boolean;
+  /** Current animated opacity, 0..1. */
+  readonly opacity: number;
+  dispose(): void;
+}
+interface ResolvedStyle {
+  background: Color;
+  hoverBackground: Color;
+  border: {
+    color: Color;
+    width: number;
+  } | null;
+  cornerRadius: number;
+  paddingX: number;
+  paddingY: number;
+  itemHeight: number;
+  itemPaddingX: number;
+  fontSize: number;
+  textColor: Color;
+  disabledColor: Color;
+  dangerColor: Color;
+  separatorColor: Color;
+  separatorHeight: number;
+  swatchSize: number;
+  swatchGap: number;
+  kbdColor: Color;
+  minWidth: number;
+  offset: number;
+}
+interface MenuItemLayout {
+  /** Index back into `content.items`. */
+  itemIndex: number;
+  /** Top-left of this row's hit region (full box width). */
+  y: number;
+  height: number;
+  /** True if this row is a separator (non-interactive). */
+  separator: boolean;
+  /** True if this row is disabled. */
+  disabled: boolean;
+  swatch: {
+    x: number;
+    y: number;
+    size: number;
+    color: Color;
+  } | null;
+  label: {
+    x: number;
+    y: number;
+    text: string;
+    fontSize: number;
+  } | null;
+  kbd: {
+    x: number;
+    y: number;
+    text: string;
+    fontSize: number;
+  } | null;
+}
+interface MenuLayout {
+  box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  items: MenuItemLayout[];
+  placement: Exclude<MenuPlacement, "auto">;
+}
+declare function layoutMenu(anchor: MenuAnchor, content: MenuContent, measure: MenuMeasure, style: ResolvedStyle, placement: MenuPlacement, bounds: MenuBounds | null): MenuLayout;
+declare function createMenu(opts: MenuOptions): Menu;
+//#endregion
+//#region src/interaction/pointer-env.d.ts
+/** Returns true when the primary input is a coarse pointer (touch/stylus). */
+declare function isCoarsePointer(): boolean;
+/** Subscribe to coarse-pointer environment changes (e.g. keyboard attach). */
+declare function watchCoarsePointer(cb: (coarse: boolean) => void): () => void;
+//#endregion
+//#region src/layers/navigator.d.ts
+/**
+ * Project a world coordinate to CSS pixels (canvas-relative) in the overview
+ * frame. Passed to the `render` callback so it can emit a fixed-weight,
+ * screen-space schematic instead of world geometry that would shrink with the
+ * overview camera. See {@link NavigatorOptions.render}.
+ */
+type NavigatorProject = (worldX: number, worldY: number) => {
+  x: number;
+  y: number;
+};
+interface NavigatorIndicatorOptions {
+  /** Indicator fill. Default: rgba(1, 1, 1, 0.08). */
+  fill?: Color;
+  /** Indicator stroke. Default: rgba(1, 1, 1, 0.85). */
+  stroke?: Color;
+  /** Stroke width in CSS pixels. Default: 1. */
+  strokeWidth?: number;
+  /** Corner radius in CSS pixels. Default: 0. */
+  cornerRadius?: number;
+}
+interface NavigatorInteractionOptions {
+  manager: InteractionManager;
+  /** Drag inside the overview to pan the source. Default: true. */
+  drag?: boolean;
+  /** Press outside the indicator to recenter the source. Default: `"center"`. */
+  click?: "center" | false;
+  /**
+   * Override the interaction-node bounds (CSS pixels, element-local). Default:
+   * the overview's `absoluteFrame` (CSS px — the camera baseline is CSS px).
+   */
+  bounds?: () => FrameRect;
+  /** Interaction node z-index. Default: 50. */
+  zIndex?: number;
+  /**
+   * Called with the desired camera state on drag/click instead of writing
+   * directly to `source`. Use this when the source is driven by a smoothed
+   * binding whose target would otherwise overwrite direct `source.setCamera`
+   * writes next frame.
+   */
+  onMove?: (camera: {
+    x?: number;
+    y?: number;
+  }) => void;
+}
+interface NavigatorOptions {
+  /** Camera viewport the user navigates in the main view. */
+  source: CameraViewport;
+  /** Camera viewport that hosts the navigator (position via its frame). */
+  overview: CameraViewport;
+  /** Layers to mirror through `overview` via {@link mirrorLayer}. */
+  content?: Layer | readonly Layer[];
+  /**
+   * Callback path: populates a navigator-owned content layer each refresh. The
+   * target is a UI (CSS-pixel) layer; use the supplied `project` to map world
+   * coordinates into the overview frame and emit fixed-size primitives so the
+   * minimap keeps constant visual weight regardless of the source camera's
+   * zoom/pan. Re-run only on content change (and overview resize) — a source
+   * pan/zoom moves only the indicator, never this layer.
+   */
+  render?: (target: Layer, project: NavigatorProject) => void;
+  indicator?: NavigatorIndicatorOptions;
+  interaction?: NavigatorInteractionOptions;
+  /**
+   * Simplify the mirrored content to reduce CPU→GPU upload and draw-call cost
+   * at overview scale. `true` enables the default preset; pass an object to
+   * customize. Rebuild is triggered on {@link Navigator.refresh}.
+   */
+  contentSimplify?: MirrorSimplify | true;
+  /**
+   * Retain the overview content in a STABLE GPU buffer via the renderer
+   * (T-CULLNAV) so a static overview is not re-uploaded every frame — the v3
+   * equivalent of v1's navigator RTT cache. Requires the `render`-callback
+   * content path (the navigator owns that layer); has no effect on the
+   * `content`-mirror path (mirrors are themselves a cheap re-emit). Set
+   * `spatialIndex: true` to build a cell-binned grid for an overview large
+   * enough to benefit from range-query culling. Re-retained on each
+   * {@link Navigator.refresh} so content changes re-upload exactly once.
+   */
+  cache?: NavigatorCacheOptions;
+}
+/** Renderer surface the navigator needs to retain its overview content. */
+interface NavigatorRetainHost {
+  retainLayer(layer: Layer, key: string, opts?: {
+    spatialIndex?: boolean;
+  }): void;
+  unretainLayer(layer: Layer): void;
+}
+interface NavigatorCacheOptions {
+  /** The renderer (or any host exposing `retainLayer`/`unretainLayer`). */
+  renderer: NavigatorRetainHost;
+  /** Build a spatial-index grid over the retained overview. Default `false`. */
+  spatialIndex?: boolean;
+}
+interface Navigator {
+  /** Layers to add to your `renderer.render([...])` call, in z-order. */
+  readonly layers: readonly Layer[];
+  /** True while the navigator is actively dragging its indicator. */
+  readonly interacting: boolean;
+  /**
+   * Re-derive content (when using the `render` callback) and the indicator.
+   * Auto-runs on relevant viewport changes; call manually when the data the
+   * `render` callback iterates has changed.
+   */
+  refresh(): void;
+  /** Tear down listeners and the interaction node. Mirrors stay valid. */
+  dispose(): void;
+}
+/**
+ * Build a Navigator: a secondary view of the same content with a rect that
+ * tracks the source camera's visible region. Drag inside the overview pans
+ * the source; pressing outside the indicator centers it.
+ *
+ * - `content`: mirrors layers via {@link mirrorLayer}, no re-emit cost.
+ * - `render`: callback populates a navigator-owned layer for dynamic content;
+ *   called on viewport changes and via {@link Navigator.refresh}.
+ */
+declare function createNavigator(opts: NavigatorOptions): Navigator;
+//#endregion
+//#region src/layers/lod-layer.d.ts
+interface LodLevel {
+  /**
+   * Minimum camera zoom (inclusive) at which this level is active. Use `0`
+   * to open-end the bottom.
+   */
+  minZoom: number;
+  /**
+   * Maximum camera zoom (exclusive) at which this level is active. Use
+   * `Infinity` to open-end the top.
+   */
+  maxZoom: number;
+  /**
+   * Layers rendered when this band is active. Multiple allowed — useful when
+   * a level mixes a world-space shape layer and a UI-space label layer.
+   */
+  layers: readonly Layer[];
+}
+/**
+ * Picks one of several pre-built layer sets based on the camera zoom. Lets
+ * consumers swap between coarse/medium/fine representations without rebuilding
+ * per frame.
+ *
+ * Levels are evaluated in the order given; the first whose `[minZoom, maxZoom)`
+ * contains `zoom` is returned. If no band matches, `resolve()` returns `[]`.
+ *
+ * Usage in a frame loop:
+ * ```ts
+ * const layers = lod.resolve(camera.zoom);
+ * renderer.render(layers);
+ * ```
+ */
+declare class LodLayer {
+  private readonly levels;
+  constructor(levels: readonly LodLevel[]);
+  /**
+   * The first band whose `[minZoom, maxZoom)` contains `zoom`, or `null` if
+   * none matches. Exposed for tests and debugging.
+   */
+  selectLevel(zoom: number): LodLevel | null;
+  /**
+   * Layers active at `zoom`. Returns `[]` when no band matches.
+   */
+  resolve(zoom: number): readonly Layer[];
+}
+/** Construct a {@link LodLayer} from a list of zoom bands. */
+declare function createLodLayer(levels: readonly LodLevel[]): LodLayer;
+//#endregion
+//#region src/layers/label-culler.d.ts
+interface LabelCullerOptions {
+  /**
+   * Grid cell size in the same coordinate unit as the AABBs passed to
+   * {@link LabelCuller.place}. Pick a value close to the typical label size —
+   * too small and buckets fragment; too large and each bucket scans more
+   * candidates. Default: 64.
+   */
+  cellSize?: number;
+}
+/**
+ * Greedy 2D overlap culler backed by a uniform hash grid.
+ *
+ * Feed AABBs in priority order (most-important first). Each call to
+ * {@link place} returns `true` when the AABB does not overlap any previously
+ * placed AABB, and adds it to the grid so later calls see it. Use to thin a
+ * large set of labels down to a screen-filling, non-overlapping subset in
+ * O(N) expected time.
+ */
+declare class LabelCuller {
+  private readonly cellSize;
+  private readonly buckets;
+  constructor(options?: LabelCullerOptions);
+  /** Drop all placed AABBs. Call between frames. */
+  reset(): void;
+  /** Number of AABBs currently placed. Diagnostic. */
+  get size(): number;
+  /**
+   * Try to place `aabb`. Returns `true` if it does not overlap any previously
+   * placed AABB (and records it for future queries). Returns `false` if it
+   * overlaps any placed AABB (in which case the grid is unchanged).
+   */
+  place(aabb: AABB): boolean;
+  /**
+   * Convenience for axis-aligned rectangles. `x, y` is the top-left corner.
+   */
+  placeRect(x: number, y: number, width: number, height: number): boolean;
+}
+//#endregion
+//#region src/shared/viewport-aabb.d.ts
+/**
+ * World-space AABB of the given camera viewport — the rectangle of world
+ * coordinates currently visible — inflated by {@link CULL_AA_EPSILON}
+ * CSS pixels (converted to world units via the current zoom) to absorb SDF
+ * AA falloff. Shape AABBs are kept tight; this is the single place the pad
+ * lives so it doesn't dominate world bounds on tiny-world content.
+ *
+ * Rotation is ignored (same caveat as `worldCullBounds`): under a rotated
+ * camera the returned AABB is a conservative over-approximation of what is
+ * on screen.
+ *
+ * Pass `rect` to query a sub-rect of the viewport (in the same CSS-pixel
+ * space as `viewport.absoluteFrame`); omit it to query the full viewport.
+ */
+declare function viewportAabb(viewport: CameraViewport, rect?: FrameRect): AABB;
+//#endregion
+//#region src/damage/region-from-aabb.d.ts
+/** Default padding (CSS px) added on every side — covers SDF anti-alias + a thin halo. */
+declare const DEFAULT_REGION_PAD = 2;
+/**
+ * Project one world-space AABB (`minX,minY,maxX,maxY`) through `viewProjection`
+ * (layer-space → NDC) into a padded CSS-px {@link Bounds2D}. All FOUR corners are
+ * transformed and re-bounded, so the result is a correct screen-space AABB even
+ * when the camera is rotated (a rotated world rect's screen AABB is larger than
+ * its two-corner projection). `pad` is added on every side.
+ */
+declare function projectAabbToBounds(minX: number, minY: number, maxX: number, maxY: number, viewProjection: Mat3, cssW: number, cssH: number, pad?: number): Bounds2D;
+/**
+ * Union the projected CSS-px regions of the instances at `indices` into a SINGLE
+ * padded {@link Bounds2D} — the focused-point halo case (one index → one padded
+ * rect) and multi-instance unions (a whole highlighted series → one bounding
+ * rect) both come out as one region.
+ *
+ * `aabbs` is the layer's flat per-instance world-AABB array (`UberPack.aabbs`):
+ * instance `i` reads `aabbs[i*4 .. i*4+3]` as `minX,minY,maxX,maxY`. Indices out
+ * of range (or a degenerate zero AABB, the cull sentinel for raw-appended spans)
+ * are skipped. Returns `null` when no in-range index contributes — the caller
+ * then has nothing to repaint.
+ *
+ * To get DISJOINT regions (several far-apart clusters) call this once per
+ * cluster; a single call always returns the one enclosing rect.
+ */
+declare function unionRegionFromAabbs(aabbs: Float32Array, indices: Iterable<number>, viewProjection: Mat3, cssW: number, cssH: number, pad?: number): Bounds2D | null;
+//#endregion
+//#region src/text/raster-font.d.ts
+/** Per-glyph metrics in em units (1 em = `samplePx` Canvas pixels at measure time). */
+interface RasterGlyphMeasure {
+  advance: number;
+  /** Tight ink bbox in em units, Y-up. Zero box for whitespace / no-ink glyphs. */
+  bbox: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  };
+}
+interface RasterFontOptions {
+  /**
+   * Em-style label for the public `family` field. Defaults to the CSS family.
+   * Useful when callers want a stable label even if the resolved font changes.
+   */
+  family?: string;
+  /**
+   * CSS pixel size used as the "1 em" reference when measuring glyph
+   * metrics. Larger = more precise sub-pixel metrics. Default 64.
+   */
+  samplePx?: number;
+  /**
+   * Optional CSS font weight passed to `ctx.font`. Default "normal".
+   */
+  weight?: string | number;
+  /**
+   * Optional CSS font style passed to `ctx.font`. Default "normal".
+   */
+  style?: string;
+}
+/**
+ * System-font glyph source. `family` is a CSS font-family string —
+ * `"sans-serif"`, `"system-ui"`, `"monospace"`, or any specific family the
+ * browser can resolve.
+ *
+ * Glyphs are measured lazily; the per-glyph SDF is rasterized only when the
+ * atlas asks for it.
+ */
+declare class RasterFont implements TextFont {
+  readonly family: string;
+  readonly cssFamily: string;
+  /** Em is unitless for raster fonts — already normalized to 1. */
+  readonly unitsPerEm = 1;
+  readonly ascender: number;
+  readonly descender: number;
+  readonly lineGap: number;
+  readonly samplePx: number;
+  readonly weight: string;
+  readonly style: string;
+  private readonly measureCanvas;
+  private readonly measureCtx;
+  private readonly measureCache;
+  constructor(cssFamily: string, options?: RasterFontOptions);
+  /** Always 0 — Canvas exposes no kerning data. */
+  getKerning(_left: number, _right: number): number;
+  /**
+   * Em-relative tight ink bbox + advance for a codepoint. Cached on first
+   * call. Returns null only for control codepoints we explicitly skip.
+   */
+  measureGlyph(codepoint: number): RasterGlyphMeasure | null;
+  /**
+   * Render a single glyph into a fresh `Uint8Array` of RGBA SDF texels of
+   * the requested atlas region size. Single-channel SDF is splat into R/G/B/A.
+   *
+   * `bbox` is the unpadded em-space ink bbox; `emPad` is the SDF half-range
+   * in em units. The glyph is drawn so em-space (minX − emPad, maxY + emPad)
+   * lands at canvas (0, 0).
+   */
+  rasterizeGlyphRegion(codepoint: number, bbox: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  }, emPad: number, width: number, height: number, atlasFontSize: number, pxRange: number): Uint8Array;
+  private cssFont;
+}
+/**
+ * Load a system font. Resolves immediately — Canvas font metrics are
+ * available synchronously once the font is set on the context. Async
+ * signature parity with `loadFont(url)` makes the two paths interchangeable
+ * in callers.
+ *
+ * `family` is a CSS font-family value: `"sans-serif"`, `"system-ui"`,
+ * `"monospace"`, or any specific family the browser can resolve.
+ */
+declare function loadSystemFont(family: string, options?: RasterFontOptions): Promise<RasterFont>;
+//#endregion
+//#region src/text/sdf-glyph-atlas.d.ts
+declare class SdfGlyphAtlas implements GlyphAtlas {
+  readonly font: RasterFont;
+  readonly atlasFontSize: number;
+  readonly pxRange: number;
+  private readonly _atlasSize;
+  private readonly device;
+  private readonly _texture;
+  private readonly cache;
+  /** Glyphs indexed by `atlasGlyphId`. Append-only; mirrors `MsdfGlyphAtlas`. */
+  private readonly _glyphList;
+  private _version;
+  private measureCache;
+  private shelfX;
+  private shelfY;
+  private shelfRowH;
+  private _overflowWarned;
+  private _destroyed;
+  constructor(owner: GPUOwner, font: RasterFont, options?: GlyphAtlasOptions);
+  get texture(): Texture;
+  get atlasSize(): number;
+  get glyphCount(): number;
+  get version(): number;
+  getGlyphById(id: number): MsdfGlyph | undefined;
+  get destroyed(): boolean;
+  get fillPercent(): number;
+  getGlyph(codepoint: number): MsdfGlyph | null;
+  measureText(text: string, options: MeasureTextOptions): TextMetrics;
+  preload(text: string): void;
+  destroy(): void;
+}
+//#endregion
+//#region src/text/shape.d.ts
+interface ShapeOptions {
+  /** World units per em. */
+  fontSize: number;
+  align?: "left" | "center" | "right";
+  /** Hard wrap width in world units. */
+  maxWidth?: number;
+  /** Line spacing in world units. Default: fontSize * 1.2. */
+  lineHeight?: number;
+  /**
+   * Skip kerning, multi-line splits, and word wrap. Single-line, ASCII-fast.
+   * Use when callers don't need exact kerned widths or `\n` handling.
+   */
+  simple?: boolean;
+}
+interface ShapedGlyph {
+  glyph: MsdfGlyph;
+  /** World-space top-left of the glyph quad (Y-up). */
+  worldX: number;
+  worldY: number;
+  /** World-space size of the glyph quad. */
+  worldW: number;
+  worldH: number;
+}
+interface ShapedBlock {
+  glyphs: ShapedGlyph[];
+  /** Content AABB in world space. Used for LOD culling + gradient extents. */
+  bbox: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  };
+  /** Total laid-out height (lines × lineHeight). */
+  height: number;
+  /** Number of laid-out lines (after wrapping). */
+  lineCount: number;
+  /** Width of the widest laid-out line, in world units. */
+  maxLineWidth: number;
+}
+/**
+ * Shape `text` starting at world-space origin (x, y).
+ *
+ * Origin convention: y is the *top* of the first line. Subsequent lines are
+ * below (higher y).
+ */
+declare function shapeText(text: string, font: TextFont, atlas: GlyphAtlas, x: number, y: number, options: ShapeOptions): ShapedBlock;
+//#endregion
+//#region src/shared/group.d.ts
+interface Group {
+  /** Mutable — update between frames. */
+  transform: Mat3;
+  /** Parent group. Immutable after creation. */
+  readonly group: Group | null;
+}
+//#endregion
+//#region src/text/text-pack.d.ts
+/**
+ * Public text shape — what callers pass to `Layer.pushText`.
+ *
+ * `font` is optional: when omitted, the layer's (or renderer's) default font
+ * is used. Effects (`outline`, `shadow`, `gradient`) all default off.
+ */
+interface TextShape {
+  text: string;
+  /** World-space x. Aligned per `align`. */
+  x: number;
+  /** World-space y of the top of the first line (Y-up). */
+  y: number;
+  font?: TextFont;
+  /** Font size in world units per em. Default 16. */
+  fontSize?: number;
+  /** Fill color. Default BLACK. */
+  color?: Color;
+  outline?: TextOutline;
+  shadow?: TextShadow;
+  gradient?: TextGradient;
+  align?: "left" | "center" | "right";
+  /** Hard wrap width in world units. */
+  maxWidth?: number;
+  /** Line spacing in world units. Default fontSize * 1.2. */
+  lineHeight?: number;
+  /**
+   * Skip kerning, multi-line splits, and wrap when laying out this shape.
+   * Significant speedup for tight inner-loop text (tip/tick labels) where
+   * exact kerned widths and `\n` handling aren't needed.
+   */
+  simple?: boolean;
+}
+/**
+ * Layout metrics returned by `Layer.pushText` / `TextPack.pushText`.
+ *
+ * Use these to advance a layout cursor without guessing line counts.
+ *
+ * - `width` / `height`: tight content AABB extents (ink bounds).
+ * - `layoutHeight`: `lineCount * lineHeight` — what to advance by when
+ *   stacking blocks vertically. Includes line gap; never zero for non-empty
+ *   input, even when no glyphs render (e.g. all-whitespace).
+ * - `bbox`: the content AABB itself, in world space.
+ */
+interface TextBlockMetrics {
+  width: number;
+  height: number;
+  layoutHeight: number;
+  lineCount: number;
+  bbox: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  };
+}
+/** A range of glyph instances in the pack, plus the group they belong to. */
+interface TextDrawCommand {
+  /** First glyph instance index. */
+  start: number;
+  /** Glyph count for this command. */
+  count: number;
+  /** Group transform applied to all glyphs in this command. */
+  group: Group | null;
+  /** Block AABB in world space — used for cull and gradient extents. */
+  bbox: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  };
+  /**
+   * Original text shape input. Retained alongside the GPU-shaped glyph stream
+   * so non-GPU consumers (SVG export, accessibility, copy-paste) can recover
+   * the source string + style without re-parsing the packed data.
+   */
+  source: TextShape;
+}
+interface TextPackOptions {
+  initialGlyphCapacity?: number;
+}
+declare class TextPack {
+  readonly atlas: GlyphAtlas;
+  readonly styles: TextStyleTable;
+  private readonly root;
+  private instanceData;
+  private instanceU32;
+  private _glyphCount;
+  private _commands;
+  private _version;
+  private gpuBuf;
+  private gpuCapacity;
+  private uploadedVersion;
+  private dataBindGroup;
+  private dataBindGlyphBuf;
+  private dataBindStyleBuf;
+  private shapeCache;
+  private shapeScratch;
+  constructor(owner: GPUOwner, atlas: GlyphAtlas, options?: TextPackOptions);
+  /** Number of glyph instances currently packed. */
+  get glyphCount(): number;
+  /** Mutates as the buffer grows; consumer should re-bind after each frame. */
+  get instanceBuffer(): Float32Array;
+  get commands(): readonly TextDrawCommand[];
+  /** Increments whenever any push mutates the pack. */
+  get version(): number;
+  /**
+   * Append one text block. The shape's `font` overrides the pack atlas only
+   * if it matches the atlas's font; otherwise the override is ignored (v1
+   * limitation — multi-font requires multiple layers).
+   */
+  pushText(shape: TextShape, group?: Group | null): TextBlockMetrics;
+  addTexts(shapes: readonly TextShape[], group?: Group | null): this;
+  /**
+   * Lookup or shape (and cache) the origin-relative glyph stream for a single
+   * line of text. Cache is per (fontSize, align, kerning, text); entries are
+   * stable across atlas growth (glyph metrics are immutable once allocated).
+   */
+  private getShapedEntry;
+  /** Drop all glyphs and styles. Retains allocated capacity. */
+  clear(): this;
+  /** Upload the dirty style table to GPU. Called by the renderer pre-draw. */
+  flush(): void;
+  /**
+   * Upload the per-glyph instance buffer to the GPU when its version changed
+   * since the last upload. Allocates / grows the GPU buffer as needed.
+   * No-op when no glyphs are packed.
+   */
+  flushInstances(): void;
+  /**
+   * Combined glyphs+styles bind group (matches `TextDataLayout`). Null until
+   * first flush. Rebuilt lazily when either underlying buffer is reallocated.
+   */
+  get bindGroup(): TgpuBindGroup | null;
+  destroy(): void;
+  private ensureGpuCapacity;
+}
+//#endregion
+//#region src/math/bezier.d.ts
+/**
+ * Evaluate a cubic Bezier at parameter `t`. `t` is not clamped; pass a value
+ * outside `[0, 1]` to extrapolate the curve (rarely useful — the tight AABB
+ * assumes `t ∈ [0, 1]`).
+ */
+declare function cubicEval(p0: Vec2, p1: Vec2, p2: Vec2, p3: Vec2, t: number): Vec2;
+/**
+ * Exact axis-aligned bounding box of a cubic Bezier on `t ∈ [0, 1]`.
+ *
+ * Starts from the endpoint hull and expands for each real root of `B'(t) = 0`
+ * in the open interval. `B'(t) = 3(α t² + 2β t + γ)` per axis, with
+ *   α = -p0 + 3p1 - 3p2 + p3
+ *   β =  p0 - 2p1 + p2
+ *   γ = -p0 + p1
+ * — solve `α t² + 2β t + γ = 0` per axis.
+ *
+ * For axis-aligned-tangent cubics (phylo's case: p1.y = p0.y, p2.y = p3.y),
+ * the derivative roots land at the endpoints and the returned box equals
+ * the endpoint rect exactly.
+ */
+declare function cubicAABB(p0: Vec2, p1: Vec2, p2: Vec2, p3: Vec2): AABB;
+//#endregion
+//#region src/math/contrast.d.ts
+/** WCAG relative luminance of an sRGB color (channels in `[0, 1]`). */
+declare function relativeLuminance(c: Color): number;
+/** WCAG contrast ratio between two colors. Symmetric; result is `[1, 21]`. */
+declare function contrastRatio(a: Color, b: Color): number;
+type WcagLevel = "AA" | "AAA";
+interface WcagTextOptions {
+  /** Font size in CSS pixels. Defaults to 14 (treated as "normal" body text). */
+  fontSizePx?: number;
+  /** Whether the text is rendered with bold weight. */
+  bold?: boolean;
+  /**
+   * Conformance level. `"AA"` / `"AAA"` apply the WCAG thresholds with the
+   * large-text exception. A raw number is treated as an absolute minimum
+   * ratio with no large-text relaxation — useful when callers want a single
+   * fine-grained target across all label sizes. Default `"AA"`.
+   */
+  level?: WcagLevel | number;
+}
+/**
+ * Minimum contrast ratio required by WCAG for the given text. Large text gets
+ * the relaxed threshold (3:1 AA / 4.5:1 AAA); otherwise normal text needs
+ * 4.5:1 AA / 7:1 AAA.
+ */
+declare function wcagMinContrast(opts?: WcagTextOptions): number;
+/** Whether `fg` against `bg` meets the WCAG threshold for the given text. */
+declare function meetsContrast(fg: Color, bg: Color, opts?: WcagTextOptions): boolean;
+/**
+ * Find a color close to `target` that meets `minRatio` contrast against
+ * `fixed`. Preserves hue + saturation; nudges lightness in steps of `0.01`,
+ * picking the smallest L-shift that works. Falls back to black or white —
+ * whichever has more contrast — if no nearby shade qualifies.
+ */
+declare function findAccessibleColor(target: Color, fixed: Color, minRatio: number): Color;
+/**
+ * Find the color closest to `target` whose contrast against `fixed` lands
+ * *at* `ratio` (not just `>=`). Used to equalize a group of labels so they
+ * all carry the same visual weight regardless of their starting color.
+ *
+ * Hue and saturation are preserved; lightness is swept and the L-value
+ * minimizing `|contrast - ratio|` is selected. When two L-values tie on
+ * contrast error, the one closer to the original lightness wins.
+ */
+declare function colorAtContrast(target: Color, fixed: Color, ratio: number): Color;
+//#endregion
+//#region src/math/oklab.d.ts
+type BlendSpace = "srgb" | "linear-rgb" | "oklab" | "oklch" | "hsl";
+interface Lab {
+  L: number;
+  a: number;
+  b: number;
+}
+declare function srgbToOklab(c: Color): Lab;
+declare function oklabToSrgb(lab: Lab, alpha?: number): Color;
+interface Lch {
+  L: number;
+  C: number;
+  /** Hue in turns (`[0, 1)`), to match the rest of the math/color API. */
+  h: number;
+}
+declare function oklabToOklch(lab: Lab): Lch;
+declare function oklchToOklab(lch: Lch): Lab;
+/** Shorthand: interpolate two sRGB colors through OKLab. The default for
+ *  `transition<Color>` and `tweenTo<Color>`. Alpha lerps linearly. */
+declare function lerpColorOklab(a: Color, b: Color, t: number): Color;
+/** Shorthand: naive sRGB channel lerp. Faster but visually muddier. */
+declare function lerpColorRgb(a: Color, b: Color, t: number): Color;
+/**
+ * Interpolate two colors `t` ∈ `[0, 1]` of the way through the chosen color
+ * space. Use `oklab` (default candidate) or `oklch` for visually clean
+ * gradients; `oklch` preserves hue along the path which is great for
+ * staying "in family" but can pass through invalid colors at high chroma —
+ * the result is gamut-clipped on conversion back to sRGB.
+ *
+ * Spaces:
+ * - `srgb` — naive channel-wise lerp; cheapest, often muddy.
+ * - `linear-rgb` — physically correct mixing; brighter midpoints than sRGB.
+ * - `oklab` — perceptually uniform, recommended default.
+ * - `oklch` — OKLab in polar form; preserves hue along the path.
+ * - `hsl` — HSL polar lerp; legacy, can desaturate.
+ */
+declare function lerpInSpace(a: Color, b: Color, t: number, space: BlendSpace): Color;
+//#endregion
+//#region src/math/apca.d.ts
+type ApcaPolarity = "normal" | "reverse";
+/**
+ * Compute APCA Lc for `fg` text against `bg` background.
+ *
+ * Returns a signed value: positive for normal polarity (dark text on light
+ * bg), negative for reverse polarity (light text on dark bg). Magnitude is
+ * the perceptual contrast — Lc 75 is the conventional body-text minimum.
+ *
+ * Returns 0 for foreground/background pairs too close to be readable
+ * (|Y_bg − Y_fg| below the soft-clip floor).
+ */
+declare function apcaContrast(fg: Color, bg: Color): number;
+/** Polarity of `fg` against `bg` — which side of zero APCA Lc would land on. */
+declare function apcaPolarity(fg: Color, bg: Color): ApcaPolarity;
+/**
+ * Minimum |Lc| recommended for `fontSizePx` at `weight` per APCA's font
+ * lookup table. Body text at 14–16px regular (weight 400) → ~75–90.
+ *
+ * Falls back to the closest tabulated row. For size/weight combinations
+ * APCA marks "do not use" (very thin text at small sizes), returns the
+ * strictest recommended value (Lc 100) — the resolver should warn anyway.
+ */
+declare function apcaFontLookup(fontSizePx: number, weight?: number): number;
+/**
+ * Find a color near `target` whose APCA |Lc| against `bg` meets `minLc`.
+ * Preserves hue + saturation; nudges HSL lightness in steps of 0.01,
+ * returning the smallest L-shift that qualifies. Falls back to BLACK or
+ * WHITE — whichever yields larger |Lc| — if no nearby shade works.
+ */
+declare function findApcaColor(target: Color, bg: Color, minLc: number): Color;
+/**
+ * Find the color closest to `target` whose APCA |Lc| against `bg` lands
+ * *at* `lc` (not just `>=`). Used to equalize a group of labels so they
+ * carry the same perceptual weight regardless of starting color.
+ *
+ * Polarity is auto-selected: whichever side of `bg` (lighter or darker)
+ * minimizes the L-shift from `target`. Hue and saturation preserved.
+ */
+declare function colorAtApca(target: Color, bg: Color, lc: number): Color;
+//#endregion
+//#region src/math/scalar.d.ts
+declare const TAU: number;
+declare const PI: number;
+declare const HALF_PI: number;
+declare const DEG_TO_RAD: number;
+declare const RAD_TO_DEG: number;
+declare function clamp(value: number, min: number, max: number): number;
+declare function clamp01(value: number): number;
+declare function lerp(a: number, b: number, t: number): number;
+/** Inverse of `lerp`: where does `value` sit between `a` and `b`? */
+declare function inverseLerp(a: number, b: number, value: number): number;
+/** Map `value` from `[a0, a1]` to `[b0, b1]` (unclamped). */
+declare function remap(value: number, a0: number, a1: number, b0: number, b1: number): number;
+/** Hermite smoothstep. `t` is clamped to `[edge0, edge1]`. */
+declare function smoothstep(edge0: number, edge1: number, value: number): number;
+/** Ken Perlin's 5th-order smoothstep — zero 1st & 2nd derivatives at edges. */
+declare function smootherstep(edge0: number, edge1: number, value: number): number;
+declare function degToRad(deg: number): number;
+declare function radToDeg(rad: number): number;
+/** Wraps `value` into `[0, modulus)` (handles negatives, unlike `%`). */
+declare function wrap(value: number, modulus: number): number;
+declare function sign(value: number): number;
+declare function approxEqual(a: number, b: number, epsilon?: number): boolean;
+//#endregion
+//#region src/math/random.d.ts
+type Rng = () => number;
+/** Mulberry32 — 32-bit, period 2^32. Tiny, fast, good distribution. */
+declare function mulberry32(seed: number): Rng;
+/** SplitMix32 — used to seed other generators. Avalanches small seeds well. */
+declare function splitmix32(seed: number): Rng;
+/** xorshift32 — minimal, period 2^32 - 1. Fastest of the bunch. */
+declare function xorshift32(seed: number): Rng;
+/** SFC32 — 128-bit state, period ~2^128. The default for high-quality streams. */
+declare function sfc32(seedA: number, seedB?: number, seedC?: number, seedD?: number): Rng;
+/** Uniform float in `[min, max)`. */
+declare function uniform(rng: Rng, min: number, max: number): number;
+/** Uniform integer in `[min, max]` (inclusive). */
+declare function uniformInt(rng: Rng, min: number, max: number): number;
+/** Standard normal (Box–Muller). Pass `mean`/`std` to shift/scale. */
+declare function gaussian(rng: Rng, mean?: number, std?: number): number;
+/** Exponential with rate `lambda` (mean = 1/lambda). */
+declare function exponential(rng: Rng, lambda?: number): number;
+/** Log-normal — exponentiated gaussian. `mu`/`sigma` are on the log scale. */
+declare function logNormal(rng: Rng, mu?: number, sigma?: number): number;
+/** Bates distribution — mean of `n` uniforms. `n=1` is uniform; large `n` ≈ normal. */
+declare function bates(rng: Rng, n?: number): number;
+/** Triangular distribution on `[min, max]` peaked at `mode`. */
+declare function triangular(rng: Rng, min: number, max: number, mode: number): number;
+/** Pick one element uniformly from `arr`. Throws on empty input. */
+declare function pick<T>(rng: Rng, arr: readonly T[]): T;
+/** Fisher–Yates shuffle. Returns a new array — does not mutate input. */
+declare function shuffle<T>(rng: Rng, arr: readonly T[]): T[];
+/** Sample `count` distinct elements without replacement. */
+declare function sample<T>(rng: Rng, arr: readonly T[], count: number): T[];
+/**
+ * Pick by weight. `weights[i]` corresponds to `arr[i]`. Weights need not sum to 1.
+ * O(n) per call — fine for small arrays. For high-volume sampling, build an
+ * alias table externally.
+ */
+declare function weighted<T>(rng: Rng, arr: readonly T[], weights: readonly number[]): T;
+/** Uniform point on a unit circle. */
+declare function onUnitCircle(rng: Rng): [number, number];
+/** Uniform point inside a unit disk (square-root trick — preserves density). */
+declare function inUnitDisk(rng: Rng): [number, number];
+//#endregion
+//#region src/interactions.d.ts
+interface FlingOptions {
+  /**
+   * Exponential velocity decay rate in 1/s. Higher settles faster. Default 4.
+   * Travel distance after release is roughly `velocity / friction`.
+   */
+  friction?: number;
+  /**
+   * Minimum release velocity (px/s) needed to start a fling. Below this the
+   * release is treated as "stop here". Default 50.
+   */
+  minVelocity?: number;
+  /**
+   * Sample window (seconds) the velocity tracker uses to estimate release
+   * velocity. Shorter = more reactive / noisier. Default 0.08.
+   */
+  windowSeconds?: number;
+}
+interface BindViewportOptions {
+  /** Enable pointer drag pan. Default: true. */
+  drag?: boolean;
+  /** Enable mouse-wheel zoom. Default: true. */
+  wheel?: boolean;
+  /** Enable two-finger pinch (touch). Default: true. */
+  pinch?: boolean;
+  /** SmoothDamp time constant (seconds). `0` = instant (no smoothing). Default: `0.1`. */
+  smoothTime?: number;
+  /**
+   * Drag-release fling. `true` enables with defaults, `false` disables, or
+   * pass an object to tune. Default: on.
+   */
+  fling?: boolean | FlingOptions;
+  /** Minimum camera zoom. Default: 0.1. */
+  minZoom?: number;
+  /** Maximum camera zoom. Default: 10. */
+  maxZoom?: number;
+  /** Initial camera state to write to the viewport. */
+  initial?: CameraState;
+  /**
+   * Custom zoom gesture handler, fired before the binding's default camera
+   * zoom for both wheel and pinch. Call `preventDefault()` on the supplied
+   * gesture to skip the default uniform-camera-zoom behavior — useful when
+   * the embedding scene wants to translate the gesture into something else
+   * (e.g. adjusting row spacing in a rectilinear phylogram).
+   *
+   * Pinch translation (`deltaX`/`deltaY` pan component) is still applied
+   * even if zoom is prevented.
+   */
+  onZoom?: (gesture: ZoomGesture) => void;
+}
+/**
+ * Unified wheel/pinch zoom gesture. `scale` is a multiplicative factor
+ * (>1 zoom in, <1 zoom out). For wheel events `scale` is derived from
+ * `WHEEL_ZOOM_PER_PX × dy`; for pinch it's `deltaScale` from the gesture
+ * tick.
+ */
+interface ZoomGesture {
+  readonly source: "wheel" | "pinch";
+  /** Multiplicative zoom factor for this gesture tick. */
+  readonly scale: number;
+  /** Anchor (element-local CSS px) — the point the user expects to stay put. */
+  readonly anchorX: number;
+  readonly anchorY: number;
+  /** Suppress the binding's default uniform-camera-zoom. */
+  preventDefault(): void;
+}
+interface CameraViewportBinding {
+  readonly mode: "camera";
+  readonly interacting: boolean;
+  readonly flinging: boolean;
+  /**
+   * True while any damper is still converging on its target (e.g. after a
+   * programmatic `setTarget` for a pan/zoom-to). Lets on-demand rAF loops
+   * keep ticking until the camera settles — without it, a `setTarget` call
+   * outside an active gesture would render one frame then stop mid-animation.
+   */
+  readonly animating: boolean;
+  enabled: boolean;
+  /** Interpolated camera state currently applied to the viewport. */
+  readonly camera: ResolvedCameraState;
+  /** Target the damping is moving toward. */
+  readonly target: ResolvedCameraState;
+  /** Set the target state. Omitted fields keep their current target value. */
+  setTarget(state: CameraState): void;
+  /** Jump to state immediately, skipping interpolation. Cancels any fling. */
+  jumpTo(state: CameraState): void;
+  /** Step damping toward the target and push to the viewport. Call per frame. */
+  update(dt: number): void;
+  /** Immediately cancel any pending smoothing and fling. */
+  stopAnimation(): void;
+  /**
+   * Jump back to the initial target captured on the first `setTarget` /
+   * `jumpTo` call after binding. No-op until an initial state has been set.
+   */
+  resetToInitial(): void;
+  /**
+   * Convert a CSS-pixel coordinate (element-local) to world coords using the
+   * binding's currently interpolated camera.
+   */
+  screenToWorld(cssX: number, cssY: number): Vec2;
+  /** Inverse of {@link screenToWorld}. Returns CSS pixels (element-local). */
+  worldToScreen(wx: number, wy: number): Vec2;
+  destroy(): void;
+}
+type ViewportBinding = CameraViewportBinding;
+declare function bindViewport(viewport: CameraViewport, element: HTMLElement, options?: BindViewportOptions): CameraViewportBinding;
+//#endregion
+//#region src/watch-dpr.d.ts
+interface WatchDprOptions {
+  /**
+   * Maximum device-pixel ratio to allow. Defaults to `2`.
+   *
+   * At DPR=3 (common on modern phones) the per-frame fill cost is 9× that of
+   * DPR=1 and the OIT A-buffer may exceed the 128 MiB device storage limit.
+   * Capping at 2 keeps costs predictable while still looking crisp.
+   */
+  maxDpr?: number;
+}
+/**
+ * Auto-track device-pixel ratio and canvas size for a renderer.
+ *
+ * Wires:
+ * - `ResizeObserver` on `canvas` (debounced via `requestAnimationFrame`)
+ * - `visualViewport` resize (iOS keyboard viewport shrink)
+ * - `screen.orientation` change or `window.orientationchange` fallback
+ *   (Android WebView landscape↔portrait)
+ *
+ * On each event the helper computes the effective DPR, calls `renderer.setDpr`
+ * then `renderer.resize(canvas.clientWidth, canvas.clientHeight)`.
+ *
+ * @returns A `dispose()` function that removes all listeners. Call it when
+ * tearing down the renderer or unmounting the canvas.
+ */
+declare function watchDpr(renderer: Renderer2D, canvas: HTMLCanvasElement, opts?: WatchDprOptions): {
+  dispose(): void;
+};
+//#endregion
+//#region src/animation/easings.d.ts
+type Easing = (t: number) => number;
+declare const linear: Easing;
+declare const easeInQuad: Easing;
+declare const easeOutQuad: Easing;
+declare const easeInOutQuad: Easing;
+declare const easeInCubic: Easing;
+declare const easeOutCubic: Easing;
+declare const easeInOutCubic: Easing;
+declare const easeInQuart: Easing;
+declare const easeOutQuart: Easing;
+declare const easeInOutQuart: Easing;
+declare const easeInQuint: Easing;
+declare const easeOutQuint: Easing;
+declare const easeInOutQuint: Easing;
+declare const easeInExpo: Easing;
+declare const easeOutExpo: Easing;
+declare const easeInOutExpo: Easing;
+declare const easeInSine: Easing;
+declare const easeOutSine: Easing;
+declare const easeInOutSine: Easing;
+declare const easeInCirc: Easing;
+declare const easeOutCirc: Easing;
+declare const easeInOutCirc: Easing;
+declare const easeInBack: Easing;
+declare const easeOutBack: Easing;
+declare const easeInOutBack: Easing;
+declare const easeInElastic: Easing;
+declare const easeOutElastic: Easing;
+declare const easeInOutElastic: Easing;
+declare const easeOutBounce: Easing;
+declare const easeInBounce: Easing;
+declare const easeInOutBounce: Easing;
+/**
+ * Build an easing from four CSS-style control points. Endpoints are fixed at
+ * `(0,0)` and `(1,1)`; `(x1,y1)` / `(x2,y2)` control the curve. `x1` and `x2`
+ * are clamped to `[0, 1]` to keep the curve single-valued in the time axis.
+ *
+ * Implemented as Newton iteration on the x-parametric cubic, with a bisection
+ * fallback when Newton fails. Fast enough to call per frame.
+ */
+declare function cubicBezier(x1: number, y1: number, x2: number, y2: number): Easing;
+//#endregion
+//#region src/animation/tween.d.ts
+interface TweenOptions {
+  /** Starting value. */
+  from: number;
+  /** Target value. */
+  to: number;
+  /** Duration in seconds. Must be > 0. */
+  duration: number;
+  /** Easing. Default: {@link linear}. */
+  easing?: Easing;
+  /** Pre-roll delay in seconds before the tween begins advancing. Default 0. */
+  delay?: number;
+}
+interface Tween {
+  readonly value: number;
+  readonly from: number;
+  readonly to: number;
+  readonly duration: number;
+  readonly elapsed: number;
+  /** True once elapsed ≥ duration (after delay). */
+  readonly done: boolean;
+  /** Advance by `dt` seconds and return the new value. */
+  step(dt: number): number;
+  /** Rewind to `from`, cleared elapsed, cleared delay. */
+  reset(): void;
+  /** Sample the raw easing curve at absolute progress `u ∈ [0, 1]`. */
+  sampleAt(u: number): number;
+  /**
+   * Redirect mid-flight: the current value becomes the new `from`, and a new
+   * tween begins toward `to`. Elapsed resets to 0. If `duration` is omitted
+   * the previous value is kept.
+   */
+  retarget(to: number, duration?: number): void;
+}
+declare function tween(opts: TweenOptions): Tween;
+//#endregion
+//#region src/animation/spring.d.ts
+interface SpringOptions {
+  /** Hooke constant. Default 170. */
+  stiffness?: number;
+  /** Viscous damping coefficient. Default 26 (≈ critical at k=170, m=1). */
+  damping?: number;
+  /** Point mass. Default 1. */
+  mass?: number;
+  /** Starting value. Defaults to `target` (or 0 if both omitted). */
+  initialValue?: number;
+  /** Starting velocity. Default 0. */
+  initialVelocity?: number;
+  /** Initial target. Defaults to `initialValue` (or 0). */
+  target?: number;
+  /** |velocity| below which the spring can settle. Default 0.01. */
+  restVelocity?: number;
+  /** |value - target| below which the spring can settle. Default 0.01. */
+  restDisplacement?: number;
+}
+interface Spring {
+  readonly value: number;
+  readonly velocity: number;
+  readonly target: number;
+  readonly settled: boolean;
+  readonly stiffness: number;
+  readonly damping: number;
+  readonly mass: number;
+  /** Advance by `dt` seconds. Returns the new value. */
+  step(dt: number): number;
+  /** Move the target. Motion stays continuous. */
+  setTarget(target: number): void;
+  /** Jump position without changing velocity. */
+  setValue(value: number): void;
+  /** Inject velocity (e.g. fling handoff). */
+  setVelocity(velocity: number): void;
+  /** Snap to current target with zero velocity. */
+  reset(): void;
+}
+declare function spring(opts?: SpringOptions): Spring;
+interface DurationSpringSpec {
+  /** Undamped natural period (seconds). Must be > 0. */
+  duration: number;
+  /** Overshoot control in `(-∞, 1]`. Default 0 (critical). */
+  bounce?: number;
+  /** Point mass. Default 1. */
+  mass?: number;
+}
+interface PhysicalSpringParams {
+  stiffness: number;
+  damping: number;
+  mass: number;
+}
+declare function springFromDuration(spec: DurationSpringSpec): PhysicalSpringParams;
+//#endregion
+//#region src/animation/smoothDamp.d.ts
+interface SmoothDampOptions {
+  /** Approximate time to converge. Seconds. Must be > 0. Default 0.1. */
+  smoothTime?: number;
+  /** Clamp on integrated speed (|change| / s). Default `Infinity`. */
+  maxSpeed?: number;
+  /** Starting value. Defaults to `target` (or 0). */
+  initialValue?: number;
+  /** Starting velocity. Default 0. */
+  initialVelocity?: number;
+  /** Initial target. Defaults to `initialValue`. */
+  target?: number;
+  /** |velocity| below which the filter can settle. Default 1e-4. */
+  restVelocity?: number;
+  /** |value - target| below which the filter can settle. Default 1e-4. */
+  restDisplacement?: number;
+}
+interface SmoothDamp {
+  readonly value: number;
+  readonly velocity: number;
+  readonly target: number;
+  readonly settled: boolean;
+  smoothTime: number;
+  maxSpeed: number;
+  /** Advance by `dt` seconds. Returns the new value. */
+  step(dt: number): number;
+  /** Move the target; velocity is preserved. */
+  setTarget(target: number): void;
+  /** Jump value without touching velocity. */
+  setValue(value: number): void;
+  /** Inject velocity (fling handoff). */
+  setVelocity(velocity: number): void;
+  /** Snap to target with zero velocity. */
+  reset(): void;
+}
+declare function smoothDamp(opts?: SmoothDampOptions): SmoothDamp;
+//#endregion
+//#region src/animation/decay.d.ts
+interface DecayOptions {
+  /** Starting value. Default 0. */
+  initialValue?: number;
+  /** Starting velocity. Default 0. */
+  initialVelocity?: number;
+  /** Decay rate (1/s). Higher = stops sooner. Default 4. */
+  friction?: number;
+  /** |velocity| at or below which the decay settles. Default 1e-3. */
+  restVelocity?: number;
+}
+interface Decay {
+  readonly value: number;
+  readonly velocity: number;
+  readonly settled: boolean;
+  friction: number;
+  /** Advance by `dt` seconds. Returns the new value. */
+  step(dt: number): number;
+  /** Replace value. */
+  setValue(value: number): void;
+  /** Replace velocity (reactivates the decay if it was settled). */
+  setVelocity(velocity: number): void;
+  /** Clear velocity without touching value. */
+  reset(): void;
+  /**
+   * Predict the total travel remaining if velocity decays undisturbed.
+   * `∫₀^∞ v₀·e^(-μt) dt = v₀/μ`. Useful for targeting a clamp boundary.
+   */
+  projectedDistance(): number;
+}
+declare function decay(opts?: DecayOptions): Decay;
+//#endregion
+//#region src/animation/velocity-tracker.d.ts
+interface VelocityTrackerOptions {
+  /**
+   * Drop samples older than this (seconds) when estimating. Default 0.1.
+   * Shorter = more reactive, noisier; longer = smoother, laggier.
+   */
+  windowSeconds?: number;
+  /** Maximum ring-buffer size. Default 16. */
+  capacity?: number;
+}
+interface VelocityTracker {
+  /** Record a pointer sample. `t` is in seconds (monotonic). */
+  sample(t: number, x: number, y: number): void;
+  /** Estimated velocity in units/s. Zero if not enough recent samples. */
+  velocity(): Vec2;
+  /** Clear all samples. */
+  reset(): void;
+}
+declare function createVelocityTracker(opts?: VelocityTrackerOptions): VelocityTracker;
+//#endregion
+//#region src/animation/transition.d.ts
+interface TransitionOptions<T> {
+  /** Starting value. Also the initial target. */
+  initial: T;
+  /** Duration in seconds. Must be > 0. */
+  duration: number;
+  /** Easing curve applied to progress. Default {@link linear}. */
+  easing?: Easing;
+  /**
+   * Linear interpolation between two values at parameter `t ∈ [0, 1]`.
+   * Required when `T` is not `number`. Default lerps numbers.
+   */
+  interpolate?: (a: T, b: T, t: number) => T;
+  /**
+   * Equality predicate used to short-circuit `setTarget` and to decide whether
+   * a snap is needed. Default {@link Object.is}.
+   */
+  equals?: (a: T, b: T) => boolean;
+  /**
+   * Optional invalidator. Marked dirty when motion starts and on each step
+   * while active, so on-demand RAF loops keep ticking until settled.
+   */
+  invalidator?: Invalidator;
+}
+interface Transition<T> extends ReadableSignal<T> {
+  /** Current displayed value (animates toward `target`). */
+  readonly value: T;
+  /** The value `step` is moving toward. */
+  readonly target: T;
+  /** True while the transition has not yet reached `target`. */
+  readonly active: boolean;
+  /**
+   * Set a new target. If `immediate` is true (or the new target equals the
+   * current value), the value snaps and motion stops. Otherwise a fresh tween
+   * begins from the current value over `duration`.
+   */
+  setTarget(target: T, immediate?: boolean): void;
+  /** Snap value (and target) without animation. */
+  setValue(value: T): void;
+  /** Advance by `dt` seconds. Returns the new value. */
+  step(dt: number): T;
+}
+declare function transition<T>(opts: TransitionOptions<T>): Transition<T>;
+//#endregion
+//#region src/animation/tween-once.d.ts
+/**
+ * Scheduler contract: invoked once with a `tick(dt)` callback. The scheduler
+ * calls `tick` each frame with elapsed seconds; `tick` returns `true` while
+ * the tween wants more frames, `false` once done. The scheduler returns a
+ * stop function that the tween calls on cancel/complete to detach.
+ */
+type TweenScheduler = (tick: (dt: number) => boolean) => () => void;
+interface TweenToOptions<T> {
+  from: T;
+  to: T;
+  /** Duration in seconds. Must be > 0. */
+  duration: number;
+  /** Easing curve. Default {@link linear}. */
+  easing?: Easing;
+  /** Pre-roll delay in seconds before motion begins. Default 0. */
+  delay?: number;
+  /** Custom interpolator. Defaults to numeric lerp / OKLab color lerp. */
+  interpolate?: (a: T, b: T, t: number) => T;
+  /** Called every frame the value changes (including the final value). */
+  onChange: (value: T) => void;
+  /** Called once at completion with the final value. Skipped on cancel. */
+  onComplete?: (value: T) => void;
+  /** Custom scheduler. Default: rAF in browser, microtask fallback. */
+  scheduler?: TweenScheduler;
+}
+interface TweenHandle {
+  /** True until the tween completes or is cancelled. */
+  readonly active: boolean;
+  /** Stop the tween. Suppresses any further `onChange` and `onComplete`. */
+  cancel(): void;
+}
+/**
+ * Default scheduler used by `tweenTo` when no `scheduler` option is provided.
+ * Exposed for callers that want to plug it into a different host loop.
+ */
+declare function defaultTweenScheduler(): TweenScheduler;
+declare function tweenTo<T>(opts: TweenToOptions<T>): TweenHandle;
+//#endregion
+export { easeOutElastic as $, MenuItemLayout as $n, RegionCloudNode as $r, colorAtApca as $t, easeInBounce as A, getLastGPUHandle as Ai, DEFAULT_REGION_PAD as An, CrosshairOptions as Ar, weighted as At, easeInOutExpo as B, NavigatorCacheOptions as Bn, Selection as Br, degToRad as Bt, springFromDuration as C, MirrorSimplify as Ci, ShapedBlock as Cn, BrushOptions as Cr, sample as Ct, Easing as D, createSVGRenderer as Di, RasterFont as Dn, Crosshair as Dr, triangular as Dt, tween as E, SVGRendererOptions as Ei, SdfGlyphAtlas as En, createBrush as Er, splitmix32 as Et, easeInOutBack as F, LabelCullerOptions as Fn, Invalidator as Fr, RAD_TO_DEG as Ft, easeInQuad as G, createNavigator as Gn, HitFanOutEventContext as Gr, sign as Gt, easeInOutQuart as H, NavigatorInteractionOptions as Hn, createSelection as Hr, lerp as Ht, easeInOutBounce as I, LodLayer as In, animateToward as Ir, TAU as It, easeInSine as J, Menu as Jn, HitFanOutSubscriber as Jr, wrap as Jt, easeInQuart as K, isCoarsePointer as Kn, HitFanOutSpec as Kr, smootherstep as Kt, easeInOutCirc as L, LodLevel as Ln, createInvalidator as Lr, approxEqual as Lt, easeInCubic as M, unionRegionFromAabbs as Mn, createCrosshair as Mr, DEG_TO_RAD as Mt, easeInElastic as N, viewportAabb as Nn, AnimateTowardOptions as Nr, HALF_PI as Nt, cubicBezier as O, GPUHandle as Oi, RasterFontOptions as On, CrosshairAxis as Or, uniform as Ot, easeInExpo as P, LabelCuller as Pn, AnimatedValue as Pr, PI as Pt, easeOutCubic as Q, MenuItem as Qn, createHitFanOut as Qr, apcaPolarity as Qt, easeInOutCubic as R, createLodLayer as Rn, HoverTracker as Rr, clamp as Rt, spring as S, MirrorLayerOptions as Si, ShapeOptions as Sn, BrushEdge as Sr, pick as St, TweenOptions as T, SVGRenderer as Ti, shapeText as Tn, BrushStyle as Tr, shuffle as Tt, easeInOutQuint as U, NavigatorOptions as Un, HitFanOut as Ur, radToDeg as Ut, easeInOutQuad as V, NavigatorIndicatorOptions as Vn, SelectionMods as Vr, inverseLerp as Vt, easeInOutSine as W, NavigatorRetainHost as Wn, HitFanOutActive as Wr, remap as Wt, easeOutBounce as X, MenuBounds as Xn, PickAtOptions as Xr, apcaContrast as Xt, easeOutBack as Y, MenuAnchor as Yn, HitSlot as Yr, ApcaPolarity as Yt, easeOutCirc as Z, MenuContent as Zn, PickAtResult as Zr, apcaFontLookup as Zt, smoothDamp as _, CAMERA_Z as _i, cubicAABB as _n, TooltipStyle as _r, gaussian as _t, tweenTo as a, InteractionManager as ai, oklabToOklch as an, createMenu as ar, linear as at, Spring as b, VIEWPORT_Z as bi, TextPack as bn, Brush as br, mulberry32 as bt, transition as c, PointCloudSpec as ci, srgbToOklab as cn, TooltipAnchor as cr, BindViewportOptions as ct, createVelocityTracker as d, InteractionNode as di, colorAtContrast as dn, TooltipLayout as dr, ViewportBinding as dt, RegionCloudSpec as ei, findApcaColor as en, MenuLayout as er, easeOutExpo as et, Decay as f, InteractionNodeSpec as fi, contrastRatio as fn, TooltipMeasure as fr, ZoomGesture as ft, SmoothDampOptions as g, ScrollInfo as gi, wcagMinContrast as gn, TooltipRowLayout as gr, exponential as gt, SmoothDamp as h, PointerInfo as hi, relativeLuminance as hn, TooltipRow as hr, bates as ht, defaultTweenScheduler as i, GestureEventInfo as ii, lerpInSpace as in, MenuStyle as ir, easeOutSine as it, easeInCirc as j, initGPU as ji, projectAabbToBounds as jn, CrosshairStyle as jr, xorshift32 as jt, easeInBack as k, InitGPUOptions as ki, loadSystemFont as kn, CrosshairBounds as kr, uniformInt as kt, VelocityTracker as l, registerPointCloud as li, WcagLevel as ln, TooltipBounds as lr, CameraViewportBinding as lt, decay as m, PinchInfo as mi, meetsContrast as mn, TooltipPlacement as mr, Rng as mt, TweenScheduler as n, BackgroundTapInfo as ni, lerpColorOklab as nn, MenuOptions as nr, easeOutQuart as nt, Transition as o, createInteractionManager as oi, oklabToSrgb as on, layoutMenu as or, WatchDprOptions as ot, DecayOptions as p, Mods as pi, findAccessibleColor as pn, TooltipOptions as pr, bindViewport as pt, easeInQuint as q, watchCoarsePointer as qn, HitFanOutState as qr, smoothstep as qt, TweenToOptions as r, ContextMenuOpts as ri, lerpColorRgb as rn, MenuPlacement as rr, easeOutQuint as rt, TransitionOptions as s, PointCloudNode as si, oklchToOklab as sn, Tooltip as sr, watchDpr as st, TweenHandle as t, registerRegionCloud as ti, BlendSpace as tn, MenuMeasure as tr, easeOutQuad as tt, VelocityTrackerOptions as u, DragPointerInfo as ui, WcagTextOptions as un, TooltipContent as ur, FlingOptions as ut, DurationSpringSpec as v, PRESS_MOVEMENT_THRESHOLD_PX as vi, cubicEval as vn, createTooltip as vr, inUnitDisk as vt, Tween as w, mirrorLayer as wi, ShapedGlyph as wn, BrushRect as wr, sfc32 as wt, SpringOptions as x, MirrorLayer as xi, TextShape as xn, BrushAxis as xr, onUnitCircle as xt, PhysicalSpringParams as y, USER_DEFAULT_Z as yi, TextBlockMetrics as yn, layoutTooltip as yr, logNormal as yt, easeInOutElastic as z, Navigator as zn, trackHover as zr, clamp01 as zt };