insomni 0.2.0-alpha.0

package/dist/renderer-DzZqd1bY.d.mts

@@ -0,0 +1,4566 @@
+import { N as FrameRect, R as Vec2, S as Mat3, i as ResolvedCameraState, n as CameraState, r as FitCameraToBoundsOptions, t as Bounds2D } from "./camera-view-DHmMiKvP.mjs";
+import { g as GPUOwner, m as TextureRegion, p as Texture, t as GlyphAtlas } from "./text-font-D7GGDtTK.mjs";
+import { StorageFlag, TgpuBuffer, TgpuRoot, d } from "typegpu";
+
+//#region src/math/color.d.ts
+interface Color {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}
+declare function rgba(r: number, g: number, b: number, a?: number): Color;
+/** Parse a 24-bit hex color, e.g. hex(0xff6600). Alpha is always 1. */
+declare function hex(value: number): Color;
+/** Parse a CSS hex string, e.g. cssHex("#ff6600") or cssHex("#ff660080"). */
+declare function cssHex(value: string): Color;
+/**
+ * HSL → RGB. All inputs in `[0, 1]`. Hue wraps automatically.
+ * `hsv` is the cousin of this for value-based color picking.
+ */
+declare function hsl(h: number, s: number, l: number, a?: number): Color;
+/** HSV → RGB. All inputs in `[0, 1]`. Hue wraps automatically. */
+declare function hsv(h: number, s: number, v: number, a?: number): Color;
+/** Alias of `hsl` for parity with code that explicitly calls out the conversion. */
+declare const hslToRgb: typeof hsl;
+/** Alias of `hsl` — accepts the same `(h, s, l, a)` signature. */
+declare const hslToRgba: typeof hsl;
+/** Linearly interpolate two colors channel-wise. */
+declare function lerpColor(a: Color, b: Color, t: number): Color;
+/** Alias of `lerpColor` matching the `mix()` naming used in shaders. */
+declare const mixColor: typeof lerpColor;
+/** Return a copy of `color` with the given alpha. */
+declare function withAlpha(color: Color, alpha: number): Color;
+/** Multiply alpha — useful for fading layered colors without losing the base value. */
+declare function fade(color: Color, factor: number): Color;
+/** Mix `color` with white by `t` ∈ [0, 1]. */
+declare function lighten(color: Color, t: number): Color;
+/** Mix `color` with black by `t` ∈ [0, 1]. */
+declare function darken(color: Color, t: number): Color;
+declare const TRANSPARENT: Color;
+declare const BLACK: Color;
+declare const WHITE: Color;
+//#endregion
+//#region src/kinds/polyline.d.ts
+type LineCap = "butt" | "round" | "square";
+type LineJoin = "miter" | "bevel" | "round";
+interface PolylineShape {
+  points: readonly Vec2[];
+  color: Color;
+  width?: number;
+  cap?: LineCap;
+  join?: LineJoin;
+  closed?: boolean;
+  miterLimit?: number;
+  /** Dash pattern as alternating [dash, gap, dash, gap, ...] lengths. Empty = solid. */
+  dashPattern?: readonly number[];
+  /** Offset into the dash pattern. Default: 0 */
+  dashOffset?: number;
+}
+interface TessellatedTriangle {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+  x3: number;
+  y3: number;
+}
+/**
+ * Note on SDF-shape dash parity: the rendering engine's SDF rect/circle/ellipse
+ * pipeline does not natively support dashed strokes (polylines do). When
+ * higher-level code needs a dashed/dotted border on an SDF shape, generate the
+ * border via {@link polylineEllipseRing} / {@link polylineRectRing} and stroke
+ * it through {@link tessellatePolyline} with a `dashPattern`. The visual
+ * difference at marker-typical sizes is negligible and the trade is a small
+ * tessellation cost in exchange for staying off the SDF shader's hot path.
+ */
+interface EllipseRingOptions {
+  cx: number;
+  cy: number;
+  rx: number;
+  ry: number;
+  /** Rotation around (cx, cy) in radians. Default 0. */
+  rotation?: number;
+  /** Number of vertices around the ring. Default scales with radius (16..128). */
+  segments?: number;
+}
+interface RectRingOptions {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  /** Corner radius. Default 0 (sharp corners → 4 vertices total). */
+  cornerRadius?: number;
+  /** Vertices per corner arc when `cornerRadius > 0`. Default 4. */
+  cornerSegments?: number;
+}
+/**
+ * Generate a closed-loop polyline approximating an ellipse. Vertices are
+ * spaced evenly in angle (not arc length) — for small markers this matches
+ * SDF rendering to within a sub-pixel. Returns points in CCW math order (which
+ * is CW in screen coords where y grows downward). The returned array does NOT
+ * include a duplicate closing point — pass `closed: true` to `tessellatePolyline`.
+ */
+declare function polylineEllipseRing(opts: EllipseRingOptions): Vec2[];
+/**
+ * Generate a closed-loop polyline for a rectangle outline. Sharp by default;
+ * supply `cornerRadius` to get rounded corners via small arcs at each corner.
+ * Like {@link polylineEllipseRing}, the returned array is unclosed — feed it
+ * to `tessellatePolyline` with `closed: true`.
+ */
+declare function polylineRectRing(opts: RectRingOptions): Vec2[];
+/**
+ * Tessellate a polyline into triangles for GPU rendering.
+ * Returns an array of triangles representing the stroke geometry.
+ */
+declare function tessellatePolyline(shape: PolylineShape): TessellatedTriangle[];
+//#endregion
+//#region src/shared/pack.d.ts
+/**
+ * Bytes per shape instance in the packed vertex buffer. Layout, little-endian:
+ *   0:  float32 pos.x
+ *   4:  float32 pos.y
+ *   8:  float16 size.x
+ *  10:  float16 size.y
+ *  12:  u32     fill    (unorm8x4; R in low byte)
+ *  16:  u32     stroke  (unorm8x4)
+ *  20:  float16 rotation
+ *  22:  float16 strokeWidth
+ *  24:  float16 cornerRadius
+ *  26:  u16     _pad (zero)
+ *  28:  u32     shapeType
+ */
+declare const SHAPE_BYTES = 32;
+declare const TRIANGLE_FLOATS = 12;
+declare const SPRITE_FLOATS$1 = 16;
+/**
+ * Floats per segment instance in the packed segment buffer (24 B total).
+ * Layout:
+ *   float 0: start.x     (f32)
+ *   float 1: start.y     (f32)
+ *   float 2: end.x       (f32)
+ *   float 3: end.y       (f32)
+ *   float 4: colorBits   (u32 reinterpret; straight RGBA unorm8x4)
+ *   float 5: width       (f32; layer-local units)
+ *
+ * Color is stored unpremultiplied (matching the shape pipeline); the shader
+ * multiplies by alpha at output to produce premultiplied blended results.
+ */
+declare const SEGMENT_FLOATS = 6;
+/**
+ * Floats per curve instance in the packed curve buffer (48 B total — a
+ * multiple of 16 B for storage-buffer struct-array alignment). Layout:
+ *   float  0..1: p0.xy         (f32)
+ *   float  2..3: p1.xy         (f32)
+ *   float  4..5: p2.xy         (f32)
+ *   float  6..7: p3.xy         (f32)
+ *   float  8:    colorBits     (u32 reinterpret; unorm8x4 RGBA, unpremultiplied)
+ *   float  9:    widthPacked   (u32 reinterpret; pack2x16float(widthStart, widthEnd))
+ *   float 10:    flagsBits     (u32 reinterpret; cap style in low 2 bits, rest reserved)
+ *   float 11:    _pad          (zero)
+ *
+ * widthPacked carries two f16 widths from day one so curve taper can land
+ * later without a schema migration. v1 callers pass the same width for both.
+ * flagsBits reserves the remaining 30 bits for dash / phase / outline.
+ */
+declare const CURVE_FLOATS = 12;
+declare const CURVE_CAP_ROUND = 0;
+declare const CURVE_CAP_BUTT = 1;
+declare const CURVE_CAP_SQUARE = 2;
+/**
+ * Floats per arc instance in the packed arc buffer (32 B total — multiple
+ * of 16 B for storage-buffer struct-array alignment). Layout:
+ *   float 0..1: center.xy   (f32)
+ *   float 2:    radius      (f32)
+ *   float 3:    theta0      (f32; radians)
+ *   float 4:    theta1      (f32; radians)
+ *   float 5:    width       (f32; layer-local units)
+ *   float 6:    colorBits   (u32 reinterpret; unorm8x4 RGBA, unpremultiplied)
+ *   float 7:    _pad        (zero)
+ *
+ * Arc is the short path from `theta0` to `theta1`; rendering depends on the
+ * absolute span only. Use the {@link ArcShape} interface — the layer/pack
+ * normalises into this form. Butt caps; no joins.
+ */
+declare const ARC_FLOATS = 8;
+declare const SHAPE_RECT = 0;
+declare const SHAPE_CIRCLE = 1;
+declare const SHAPE_ELLIPSE = 2;
+interface RectShape {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  fill?: Color;
+  stroke?: Color;
+  strokeWidth?: number;
+  cornerRadius?: number;
+  rotation?: number;
+}
+interface CircleShape {
+  cx: number;
+  cy: number;
+  radius: number;
+  fill?: Color;
+  stroke?: Color;
+  strokeWidth?: number;
+}
+interface EllipseShape {
+  cx: number;
+  cy: number;
+  rx: number;
+  ry: number;
+  fill?: Color;
+  stroke?: Color;
+  strokeWidth?: number;
+  rotation?: number;
+}
+interface LineShape {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+  color: Color;
+  width?: number;
+}
+/**
+ * A 2D line segment drawn by the dedicated segment pipeline. Uses a compact
+ * 24 B record (f32 endpoints + unorm8x4 color + f32 width) and a 1D SDF
+ * fragment — roughly 25% of the storage of a `LineShape` and a simpler
+ * fragment. Prefer over `LineShape` for high-count use cases (phylo trees,
+ * edge bundles). Butt caps only — joins are the caller's responsibility.
+ */
+interface SegmentShape {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+  color: Color;
+  /** Line thickness in layer-local units. Default 1. */
+  width?: number;
+}
+/**
+ * A 2D cubic Bezier curve drawn by the dedicated curve pipeline. Uses a
+ * 48 B record (4 f32 control points + unorm8x4 color + f16×2 widths +
+ * u32 flags) and an SDF fragment that iteratively solves distance-to-curve.
+ *
+ * Round caps are free (fall out of the clamped-t SDF); `butt` and `square`
+ * discard fragments past the tangent at the endpoint.
+ *
+ * For taper — pass different start/end widths via `widthStart` + `widthEnd`.
+ * Omit either to fall back to the uniform `width`.
+ */
+interface CurveShape {
+  p0: Vec2;
+  p1: Vec2;
+  p2: Vec2;
+  p3: Vec2;
+  color: Color;
+  /** Uniform line thickness in layer-local units. Default 1. Overridden by widthStart/widthEnd if provided. */
+  width?: number;
+  /** Thickness at `p0`. Falls back to `width`. */
+  widthStart?: number;
+  /** Thickness at `p3`. Falls back to `width`. */
+  widthEnd?: number;
+  /** End cap style. Default `round`. */
+  cap?: LineCap;
+}
+/**
+ * A 2D circular arc drawn by the dedicated arc pipeline. SDF-based — stays
+ * pixel-crisp at any zoom, unlike a tessellated polyline. The rendered shape
+ * is the band of width `width` straddling the arc curve, with butt caps at
+ * each endpoint.
+ *
+ * `theta0` / `theta1` are absolute angles in radians; the renderer uses the
+ * absolute span (clamped to 2π — pass `theta1 = theta0 + 2π` for a full ring).
+ * Direction is irrelevant to the rendered geometry.
+ */
+interface ArcShape {
+  cx: number;
+  cy: number;
+  radius: number;
+  theta0: number;
+  theta1: number;
+  color: Color;
+  /** Stroke thickness in layer-local units. Default 1. */
+  width?: number;
+}
+interface PolygonShape$1 {
+  points: readonly Vec2[];
+  holes?: readonly (readonly Vec2[])[];
+  fill?: Color;
+  stroke?: Color;
+  strokeWidth?: number;
+  fillEnabled?: boolean;
+}
+type PolygonOpts = Omit<PolygonShape$1, "points">;
+//#endregion
+//#region src/schema/instance.d.ts
+/** The TypeGPU primitive a field maps to. */
+type FieldKind = "f32" | "vec4f" | "u32";
+/** One field in the universal per-instance record. */
+interface InstanceField {
+  /** Field name — shared verbatim by the CPU offset table, the TypeGPU struct
+   * key, and the WGSL accessor local. */
+  name: string;
+  /** The TypeGPU primitive this field maps to. */
+  kind: FieldKind;
+  /** Float count this field occupies: `f32` = 1, `u32` = 1, `vec4f` = 4. */
+  floats: number;
+}
+/**
+ * Universal per-instance record: 16 floats / 64 bytes. Field order here IS the
+ * GPU memory order; do not reorder without re-deriving every consumer.
+ *
+ * Depth is carried by the explicit `order` field (float-offset 10), never
+ * derived from the instance index. Index-derived Z couples depth precision to
+ * draw count and requires a per-draw uniform; the explicit field removes both.
+ *
+ * Layout (float offset / byte offset):
+ *   geom0     @  0 /  0  vec4f  — geometry slot 0 (kind-specific)
+ *   geom1     @  4 / 16  vec4f  — geometry slot 1 (kind-specific)
+ *   colorBits @  8 / 32  u32    — packed unorm8x4 color
+ *   typeFlag  @  9 / 36  u32    — shape-kind discriminant
+ *   order     @ 10 / 40  f32    — EXPLICIT depth; never index-derived
+ *   lane0     @ 11 / 44  u32    — kind-specific payload
+ *   lane1     @ 12 / 48  u32
+ *   lane2     @ 13 / 52  u32
+ *   lane3     @ 14 / 56  u32
+ *   lane4     @ 15 / 60  u32  — see emphasis note below
+ *
+ * `lane4` is dual-purpose, kind-by-kind. No *shape* kind (rect/circle/ellipse/
+ * segment/curve/arc/triangle/polyline) reads it, so for shapes it carries the
+ * **emphasis key** (Phase 4): the uber `transparent` / OIT-build fragments
+ * compare it against the `Emphasis.focusedKey` uniform to dim non-focused
+ * PARTICIPATING instances (`shader/assemble.ts`). EXEMPT-ZERO: `lane4 == 0u` —
+ * the deterministic default `UberPack.append` writes — is the opt-out sentinel;
+ * a key-0 shape is NEVER dimmed (instances opt INTO emphasis with a key ≥ 1), so
+ * untagged shapes stay full-alpha during a mark emphasis. A shape's `lane4` is
+ * never stale. The glyph pack (`glyph/glyph-pack.ts`) independently uses `lane4`
+ * for the anchored-text world anchor Y — that is fine because glyphs render
+ * through the dedicated glyph pipeline, which never reads the emphasis uniform.
+ */
+declare const INSTANCE_FIELDS: readonly InstanceField[];
+/** Total floats per instance — derived from {@link INSTANCE_FIELDS}. */
+declare const INSTANCE_FLOATS: number;
+/** Total bytes per instance — derived from {@link INSTANCE_FLOATS}. */
+declare const INSTANCE_BYTES: number;
+//#endregion
+//#region src/schema/codegen.d.ts
+/** A single field's position within the packed instance record. */
+interface FieldOffset {
+  /** Offset from the start of the instance, in floats. */
+  floatOffset: number;
+  /** Offset from the start of the instance, in bytes (`floatOffset * 4`). */
+  byteOffset: number;
+}
+/**
+ * The derived instance layout: CPU offsets, the TypeGPU struct, and the WGSL
+ * accessor — all produced from {@link INSTANCE_FIELDS} in one pass.
+ */
+interface InstanceLayout {
+  /** Bytes per instance (`INSTANCE_BYTES`). */
+  byteStride: number;
+  /** Floats per instance (`INSTANCE_FLOATS`). */
+  floatStride: number;
+  /** Per-field float/byte offsets, keyed by field name. */
+  offsets: Record<string, FieldOffset>;
+  /** TypeGPU struct mirroring `INSTANCE_FIELDS` field-for-field, in order. */
+  tgpuStruct: ReturnType<typeof d.struct>;
+  /** WGSL snippet reading every field of an `InstanceStruct` value by name. */
+  wgslAccessor: string;
+}
+/**
+ * Derive the full instance layout from {@link INSTANCE_FIELDS}. Pure and
+ * deterministic — calling it twice yields structurally identical layouts.
+ */
+declare function deriveLayout(): InstanceLayout;
+/** Eagerly-derived canonical instance layout — the shared v3 contract. */
+declare const INSTANCE_LAYOUT: InstanceLayout;
+//#endregion
+//#region src/kinds/kind.d.ts
+/** Shape-kind discriminant written into `InstanceRecord.typeFlag`. */
+declare const TYPE_RECT = 0;
+declare const TYPE_CIRCLE = 1;
+declare const TYPE_ELLIPSE = 2;
+declare const TYPE_SEGMENT = 3;
+declare const TYPE_CURVE = 4;
+/**
+ * Reserved for a future Phase-4 in-uber sprite kind (texture binding in the
+ * uber-shader + `Layer.pushSprite`). In Phase 3, sprites render via the
+ * {@link BufferLayer} + sibling pipeline path — see
+ * `pipelines/sprite-pipelines.ts` (`createSpritePipelines`) and
+ * `layers/buffer-layer.ts` (`BufferLayerSpritesOptions`). `TYPE_SPRITE` is
+ * intentionally absent from `ORDERED_KINDS` in `kinds/index.ts`: the shader
+ * assembler (`assembleShader`) does NOT emit a dispatch branch for it, and
+ * there is no concrete sprite kind module under `kinds/`.
+ */
+declare const TYPE_SPRITE = 5;
+declare const TYPE_TRIANGLE = 6;
+declare const TYPE_ARC = 7;
+/**
+ * Glyph quad packed by `GlyphPack`. One instance per visible glyph;
+ * atlas UV, atlas glyph id, and per-string flags live in the lane slots.
+ * The MSDF glyph pipeline (RTT bake) selects this kind at fragment time.
+ */
+declare const TYPE_GLYPH = 8;
+/**
+ * Analytic SDF stroke-path (`kinds/stroke.ts`). Up to 4 points per instance; an
+ * N-point stroke chains `ceil((M-1)/3)` instances. The min-of-segment SDF in
+ * the fragment computes coverage analytically (no CPU triangulation) — the
+ * opt-in alternative to the tessellated `pushPolyline` path for dense strokes.
+ */
+declare const TYPE_STROKE_PATH = 9;
+/** World-space axis-aligned bounding box. Used by tile-cull / damage tracking. */
+interface WorldAABB {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}
+/**
+ * A primitive-kind strategy. `R` is the kind's plain record type (the shape the
+ * caller supplies). Each kind owns the four facts the renderer needs about a
+ * primitive and nothing else.
+ */
+interface PrimitiveKind<R> {
+  /** Matches the `TYPE_*` constant written into `typeFlag`. */
+  readonly typeFlag: number;
+  /**
+   * Pack one record into the flat instance buffer at `offset` (in floats).
+   * Writes exactly `INSTANCE_FLOATS` floats using the `InstanceRecord` field
+   * layout: `geom0` @ +0, `geom1` @ +4, `colorBits` @ +8, `typeFlag` @ +9,
+   * `order` @ +10, `lane0..lane4` @ +11..+15. `f32` and `u32` alias the same
+   * buffer; float fields are written through `f32`, bit-packed fields through
+   * `u32`.
+   *
+   * `order` (float-offset 10) carries explicit depth and is the caller's
+   * concern — the packer leaves it at whatever the caller pre-seeded, so the
+   * scene layer owns Z assignment. (Distinct from v2, which derived Z from the
+   * instance index via a per-draw uniform.)
+   */
+  pack(record: R, f32: Float32Array, u32: Uint32Array, offset: number): void;
+  /**
+   * World-space AABB of the primitive, padded by at least 1px of anti-alias
+   * fringe beyond the stroke boundary (so tile-cull never clips the AA edge).
+   */
+  aabb(record: R): WorldAABB;
+  /**
+   * WGSL geometry-expansion snippet for the vertex stage. Run when
+   * `shapeType == this.typeFlag`; reads the unpacked instance fields and the
+   * per-vertex quad, and assigns `world` (vec2f) plus the varyings the SDF
+   * fragment consumes. Authored once per kind — never copy-pasted between
+   * kinds.
+   */
+  wgslGeom(): string;
+  /**
+   * WGSL SDF + anti-alias snippet for the fragment stage. Run when
+   * `shapeType == this.typeFlag`; reads the varyings and instance fields and
+   * assigns the premultiplied `outColor` (vec4f). Authored once per kind.
+   *
+   * NOTE: AA floor varies by kind. Closed shapes (rect/circle/ellipse) clamp
+   * `pixelLocal` to max(..., 0.5); 1D/curved shapes (segment/curve/arc) use
+   * max(..., 1e-9) to avoid over-softening thin strokes.
+   */
+  wgslSdf(): string;
+}
+//#endregion
+//#region src/shader/assemble.d.ts
+/** The WGSL stage sources produced from one assembly pass. */
+interface AssembledShader {
+  /** Full vertex-stage WGSL source (geometry expansion + camera transform). */
+  vertex: string;
+  /** Full fragment-stage WGSL source — with the opaque `discard`. */
+  opaque: string;
+  /** Full fragment-stage WGSL source — alpha-blended, no `discard`. */
+  transparent: string;
+  /**
+   * Full fragment-stage WGSL source for the OIT (A-buffer) **build** pass.
+   *
+   * It runs the SAME geometry expansion (the shared `vertex`) and the SAME
+   * per-kind SDF switch that produces `outColor` as {@link transparent} — the
+   * geometry/SDF logic is generated from the kinds exactly once, never
+   * hand-copied. Where the transparent variant returns `outColor` for hardware
+   * blending, this variant instead inserts `outColor` (premultiplied) plus the
+   * fragment depth into the per-pixel bounded-K A-buffer (atomic slot reserve,
+   * write-once). Color writes are masked off by the pipeline (`writeMask:0`);
+   * the returned `vec4f(0.0)` is discarded by the hardware.
+   *
+   * Adds, relative to the opaque/transparent fragment input, a
+   * `@builtin(position)` so it can compute the integer pixel index, and three
+   * extra `@group(2)` bindings (heads / slots / oitViewport). The vertex stage
+   * and binding groups 0/1 are unchanged, so {@link vertex} feeds this variant
+   * verbatim. `pipelines/oit-pipelines.ts` builds the build pipeline from this
+   * source; it must not re-author the geometry/SDF body.
+   */
+  oitBuild: string;
+}
+/**
+ * Assemble the full uber-shader from the kind contributions. Produces the
+ * vertex source plus the opaque and transparent fragment sources from a SINGLE
+ * fragment body — the two variants differ only by the trailing `discard`, so
+ * they cannot drift.
+ *
+ * @param kinds The primitive kinds to dispatch over. Every kind's `typeFlag`
+ *   gets a geom branch in the vertex and an sdf branch in the fragment.
+ * @param _accessorWgsl Deprecated no-op parameter kept for call-site
+ *   compatibility. Kinds read `inst.*` directly from the `InstanceStruct`
+ *   binding; the generated `readInstance` accessor was dead code and has been
+ *   removed. Pass any string (e.g. `INSTANCE_LAYOUT.wgslAccessor`) — it is
+ *   ignored.
+ */
+declare function assembleShader(kinds: PrimitiveKind<unknown>[], _accessorWgsl?: string): AssembledShader;
+//#endregion
+//#region src/pipelines/pipelines.d.ts
+interface Pipelines {
+  /** Opaque pass: depth write on, no blend (src-replace). */
+  opaque: GPURenderPipeline;
+  /** Transparent pass: depth write off, ALPHA_BLEND premultiplied src-over. */
+  transparent: GPURenderPipeline;
+  /**
+   * Clear-quad pass: one oversized triangle-list triangle that resets color
+   * and depth (`z = 1.0`, `depthCompare:"always"`, write enabled) within the
+   * scissor rect. Used by partial-redraw to clear each damage rect before
+   * its overlapping geometry is redrawn.
+   */
+  clearQuad: GPURenderPipeline;
+  /**
+   * Shared bind-group layout for `@group(0)` — the camera uniform
+   * (`Camera { vpCol0, vpCol1, vpCol2 }`), visible to the vertex stage.
+   * Both {@link opaque} and {@link transparent} are built against this exact
+   * layout object so ONE camera bind group serves both passes. (With
+   * `layout:"auto"` the two pipelines would receive distinct, mutually
+   * incompatible auto-layouts and the renderer would need a separate bind
+   * group per pass.)
+   */
+  cameraLayout: GPUBindGroupLayout;
+  /**
+   * Shared bind-group layout for `@group(1)` — the read-only instance storage
+   * buffer (`array<InstanceStruct>`), visible to vertex + fragment. Like
+   * {@link cameraLayout}, shared by both passes so one instances bind group
+   * serves opaque + transparent.
+   */
+  instanceLayout: GPUBindGroupLayout;
+}
+/**
+ * Construct the three v3 render pipeline variants.
+ *
+ * @param root   TypeGPU root (provides `root.device`).
+ * @param format Swapchain texture format.
+ * @param shader Assembled uber-shader from {@link assembleShader}.
+ */
+declare function createPipelines(root: TgpuRoot, format: GPUTextureFormat, shader: AssembledShader): Pipelines;
+//#endregion
+//#region src/core/logger.d.ts
+/**
+ * Injectable diagnostic logger.
+ *
+ * insomni emits a handful of development-time diagnostics (font-mismatch
+ * warnings, atlas-overflow warnings, device-loss / GPU validation errors, effect
+ * cleanup failures). Host apps need to be able to redirect or suppress that
+ * output, so library code routes every diagnostic through {@link getLogger}
+ * instead of calling `console.*` directly.
+ *
+ * The active logger is a single module-level value (defaulting to {@link console})
+ * rather than a value threaded through every call site: the diagnostic sites live
+ * in unrelated modules (text packing, glyph atlas, reactivity, SVG export) that
+ * have no handle on renderer/init options. Callers install their logger once via
+ * {@link setLogger} (or by passing `logger` to `initGPU` / `createRenderer`),
+ * which is a process-wide setting for the library.
+ */
+interface Logger {
+  /** Non-fatal diagnostic — recoverable, but the caller should know. */
+  warn(...args: unknown[]): void;
+  /** Error diagnostic — something failed (device loss, GPU validation, …). */
+  error(...args: unknown[]): void;
+  /** Verbose/optional diagnostic. Defaults to a no-op when unset. */
+  debug?(...args: unknown[]): void;
+}
+/**
+ * Install the process-wide diagnostic logger. Pass `null`/`undefined` to reset
+ * back to the {@link console} default.
+ */
+declare function setLogger(logger: Logger | null | undefined): void;
+/** The active diagnostic logger. Defaults to {@link console}. */
+declare function getLogger(): Logger;
+//#endregion
+//#region src/scene/group.d.ts
+interface GroupOptions {
+  /** Transform applied by this group. Default: `IDENTITY`. */
+  transform?: Mat3;
+  /** Parent group — transforms compound up the chain. */
+  parent?: Group;
+}
+interface Group {
+  /** Mutable — update between frames; takes effect without re-packing. */
+  transform: Mat3;
+  /** Parent group. Immutable after creation. */
+  readonly parent: Group | null;
+}
+/** Mint a fresh group. Defaults to an identity transform with no parent. */
+declare function createGroup(options?: GroupOptions): Group;
+/**
+ * Walk the parent chain and return the compounded transform (root applied
+ * first, leaf last). Returns `IDENTITY` when `group` is `null`.
+ *
+ * Start with the leaf's transform, then pre-multiply each ancestor so the root
+ * sits leftmost
+ * in `multiply(parent, child)` (which applies `child` first, then `parent`).
+ */
+declare function resolveGroupTransform(group: Group | null): Mat3;
+//#endregion
+//#region src/scene/space.d.ts
+/** Coordinate space a layer's shapes are authored in. */
+type LayerSpace = "world" | "ui";
+/** Per-frame inputs the `project` hook needs to map a world AABB to pixels. */
+interface ProjectOptions {
+  /** Resolved camera ({x, y, zoom, rotation}). Read only by `space:"world"`. */
+  camera: ResolvedCameraState;
+  /** Group whose compounded transform applies before the camera. `world` only. */
+  group: Group | null;
+  /**
+   * Device-pixel ratio. NOT applied to `ui` rects (they return CSS px — the
+   * renderer's `applyScissor` is the single dpr owner). Read only by `world`:
+   * the world projection maps through the renderer's CSS-px camera baseline via
+   * `worldToCssMatrix` (which divides the device dims it is fed by `dpr`), so
+   * device dims are passed as `viewportWidth/Height × dpr`.
+   */
+  dpr: number;
+  /** Viewport width in CSS pixels (the camera's projection target). */
+  viewportWidth: number;
+  /** Viewport height in CSS pixels. */
+  viewportHeight: number;
+}
+/**
+ * Project a layer-space AABB `(minX, minY)`–`(maxX, maxY)` to a **CSS-pixel**
+ * `FrameRect` suitable as a damage / scissor region. The renderer applies the
+ * device-pixel ratio exactly once (`applyScissor`); `project` does NOT
+ * pre-multiply dpr (the debt #11 single-owner fix).
+ *
+ * - `ui`: `{x,y,w,h}` in CSS px. Camera + dpr are never applied to the value.
+ * - `world`: resolve the group transform, transform all four corners through it
+ *   and the world → CSS-px camera view (`worldToCssMatrix`, the CSS-px camera
+ *   baseline), take the screen min/max (CSS px).
+ */
+declare function project(minX: number, minY: number, maxX: number, maxY: number, space: LayerSpace, opts: ProjectOptions): FrameRect;
+//#endregion
+//#region src/kinds/rect.d.ts
+/** A rounded rectangle. `(x, y)` is the top-left corner; `width`/`height` are
+ * the full extents (matching v1's `RectShape`). */
+interface RectRecord {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  fill?: Color;
+  stroke?: Color;
+  strokeWidth?: number;
+  cornerRadius?: number;
+  rotation?: number;
+}
+declare const rect: PrimitiveKind<RectRecord>;
+//#endregion
+//#region src/kinds/circle.d.ts
+/** A circle centered at `(cx, cy)` with `radius`. */
+interface CircleRecord {
+  cx: number;
+  cy: number;
+  radius: number;
+  fill?: Color;
+  stroke?: Color;
+  strokeWidth?: number;
+}
+declare const circle: PrimitiveKind<CircleRecord>;
+//#endregion
+//#region src/kinds/ellipse.d.ts
+/** An ellipse centered at `(cx, cy)` with radii `rx`/`ry`. */
+interface EllipseRecord {
+  cx: number;
+  cy: number;
+  rx: number;
+  ry: number;
+  fill?: Color;
+  stroke?: Color;
+  strokeWidth?: number;
+  rotation?: number;
+}
+declare const ellipse: PrimitiveKind<EllipseRecord>;
+//#endregion
+//#region src/kinds/segment.d.ts
+/** A straight line segment from `(x1, y1)` to `(x2, y2)`. */
+interface SegmentRecord {
+  x1: number;
+  y1: number;
+  x2: number;
+  y2: number;
+  color: Color;
+  /** Line thickness in layer-local units. Default 1. */
+  width?: number;
+}
+declare const segment: PrimitiveKind<SegmentRecord>;
+//#endregion
+//#region src/kinds/curve.d.ts
+/** End cap style for a curve / open stroke. */
+type CurveCap = "round" | "butt" | "square";
+/** A cubic Bezier stroke through `p0..p3`. */
+interface CurveRecord {
+  p0: Vec2;
+  p1: Vec2;
+  p2: Vec2;
+  p3: Vec2;
+  color: Color;
+  /** Uniform thickness. Default 1. Overridden by `widthStart`/`widthEnd`. */
+  width?: number;
+  /** Thickness at `p0`. Falls back to `width`. */
+  widthStart?: number;
+  /** Thickness at `p3`. Falls back to `width`. */
+  widthEnd?: number;
+  /** End cap style. Default `round`. */
+  cap?: CurveCap;
+}
+declare const curve: PrimitiveKind<CurveRecord>;
+//#endregion
+//#region src/kinds/arc.d.ts
+/** A circular arc centred at `(cx, cy)`, radius `radius`, spanning
+ * `theta0`→`theta1` (absolute radians; direction irrelevant). */
+interface ArcRecord {
+  cx: number;
+  cy: number;
+  radius: number;
+  theta0: number;
+  theta1: number;
+  color: Color;
+  /** Stroke thickness in layer-local units. Default 1. */
+  width?: number;
+}
+declare const arc: PrimitiveKind<ArcRecord>;
+//#endregion
+//#region src/kinds/triangle.d.ts
+/** A flat-filled triangle through `p1`, `p2`, `p3`. */
+interface TriangleRecord {
+  p1: Vec2;
+  p2: Vec2;
+  p3: Vec2;
+  fill: Color;
+}
+declare const triangle: PrimitiveKind<TriangleRecord>;
+//#endregion
+//#region src/kinds/stroke.d.ts
+/** Maximum points packed into one stroke instance (geom0+geom1 = 4 vec2f). */
+declare const STROKE_MAX_POINTS = 4;
+/** Live sub-segments per full instance (= STROKE_MAX_POINTS - 1). */
+declare const STROKE_SEGMENTS_PER_INSTANCE: number;
+/**
+ * One packed stroke-path instance: up to {@link STROKE_MAX_POINTS} points plus
+ * the stroke style. Produced by {@link chunkStroke}; the public authoring entry
+ * point is `Layer.pushStroke`, which builds the chunk list from a polyline.
+ */
+interface StrokeInstanceRecord {
+  /** Live points for this instance (2..4). Slots beyond `points.length` are padded. */
+  points: readonly Vec2[];
+  color: Color;
+  /** Stroke thickness. Default 1. */
+  width?: number;
+  /** Cap at the path START — only applied when {@link isChainStart}. Default round. */
+  capStart?: LineCap;
+  /** Cap at the path END — only applied when {@link isChainEnd}. Default round. */
+  capEnd?: LineCap;
+  /** Join style at interior vertices. Default round. */
+  join?: LineJoin;
+  /** Miter limit (ratio). Default 4. */
+  miterLimit?: number;
+  /** True when this instance carries the path's first point (apply `capStart`). */
+  isChainStart?: boolean;
+  /** True when this instance carries the path's last point (apply `capEnd`). */
+  isChainEnd?: boolean;
+}
+/** Solid-stroke input for {@link chunkStroke} (the polyline before SDF chunking). */
+interface StrokePathShape {
+  points: readonly Vec2[];
+  color: Color;
+  width?: number;
+  cap?: LineCap;
+  join?: LineJoin;
+  miterLimit?: number;
+  /** When true, the first and last points are joined into a loop. */
+  closed?: boolean;
+}
+/**
+ * Number of SDF instances a stroke of `pointCount` points produces:
+ * `ceil((pointCount - 1) / 3)` (3 live sub-segments per K=4 instance). A
+ * `closed` stroke adds one synthetic segment back to the start, so it uses
+ * `pointCount` segments → `ceil(pointCount / 3)`.
+ */
+declare function strokeInstanceCount(pointCount: number, closed?: boolean): number;
+/**
+ * Chunk a solid stroke into {@link StrokeInstanceRecord}s of up to
+ * {@link STROKE_MAX_POINTS} points each. Consecutive instances overlap on their
+ * shared boundary point (instance `k` spans points `[3k .. 3k+3]`), so the
+ * round-join blob at the boundary covers the seam. Returns `[]` for a degenerate
+ * stroke (fewer than 2 points after closing).
+ *
+ * Cap application: `capStart` is set ONLY on the instance carrying the path's
+ * first point and `capEnd` ONLY on the one carrying the last point. A `closed`
+ * stroke has no caps (the wrap segment makes both ends interior joins).
+ */
+declare function chunkStroke(shape: StrokePathShape): StrokeInstanceRecord[];
+/**
+ * Pack the {@link StrokeInstanceRecord} flag word for `lane1` (see the lane
+ * layout comment at the top of this file). Exported for the unit tests to
+ * round-trip without re-deriving the bit packing.
+ */
+declare function packStrokeFlags(rec: StrokeInstanceRecord): number;
+declare const stroke: PrimitiveKind<StrokeInstanceRecord>;
+//#endregion
+//#region src/kinds/index.d.ts
+/**
+ * Every concrete primitive kind, sorted ascending by `typeFlag`. This is the
+ * canonical kind list `assembleShader()` dispatches over (one `if (typeFlag ==
+ * N)` branch per kind, in this order) and the order the renderer factory feeds
+ * the shader assembler.
+ *
+ * Note the gaps vs the `TYPE_*` discriminants: `TYPE_SPRITE` (5) has no kind
+ * module yet (sprites go through the textured-quad composite path), and
+ * `TYPE_GLYPH` (8) is NOT a uber-shader kind — glyphs render only inside the RTT
+ * bake via the dedicated MSDF glyph pipeline (`pipelines/glyph-pipelines.ts`).
+ * Both are intentionally absent from the dispatch chain.
+ */
+declare const ORDERED_KINDS: readonly PrimitiveKind<unknown>[];
+//#endregion
+//#region src/pack/uber-pack.d.ts
+/**
+ * A contiguous span of instances in `UberPack.buffer` that share a kind and
+ * opacity, suitable for a single GPU draw call. Byte offsets align to
+ * `INSTANCE_BYTES` (64 bytes).
+ */
+interface DrawCommand {
+  /** `PrimitiveKind.typeFlag` identifying the shape kind for this span. */
+  kind: number;
+  /** True when all instances in this span are fully opaque. */
+  opaque: boolean;
+  /** Byte start of this span within the `UberPack` buffer. */
+  byteOffset: number;
+  /** Byte length of this span (always a multiple of `INSTANCE_BYTES`). */
+  byteCount: number;
+  /**
+   * Optional per-command clip rect (CSS px). `null` / absent means "no clip"
+   * (the command draws across the full damage rect). Present on clipped commands
+   * from scene layers; the partial-redraw path intersects it with each damage
+   * rect to cull zero-area draws.
+   */
+  clipRect?: FrameRect | null;
+  /**
+   * Optional per-command `Group` (P3-T8). `null` / absent means "no group" (the
+   * command draws through the layer's base space view-projection). When present
+   * the renderer composes the group's resolved transform INTO the space VP and
+   * routes this command to a distinct per-(space × group) camera slot — geometry
+   * transforms live, with NO repack (the group is CPU-side draw metadata only;
+   * the packed instance bytes never carry it). A group-identity change is a
+   * `_mergeCommand` boundary, so two shapes in different groups never coalesce
+   * into one draw (they need different slots).
+   */
+  group?: Group | null;
+}
+/**
+ * CPU-side flat instance buffer + draw-command list for the v3 renderer.
+ *
+ * Usage per frame:
+ * ```ts
+ * pack.clear();
+ * for (const item of scene) {
+ *   pack.append(item.kind, item.record, item.opaque);
+ * }
+ * // Upload pack.buffer[0..pack.byteLength) to GPU, then iterate pack.commands.
+ * pack.tickShrink();
+ * ```
+ */
+declare class UberPack {
+  private _buf;
+  private _f32;
+  private _u32;
+  /** Occupied byte count within `_buf`. */
+  private _byteLen;
+  private _commands;
+  /** Monotonic mutation counter — incremented by `append` and `clear`. */
+  private _version;
+  private _aabbs;
+  /** Count of AABBs written (== instance count). */
+  private _aabbCount;
+  private _lowWaterFrames;
+  private _peakBytes;
+  constructor();
+  /** The underlying `ArrayBuffer`. Only the first `byteLength` bytes are valid. */
+  get buffer(): ArrayBuffer;
+  /** Number of valid (occupied) bytes at the start of `buffer`. */
+  get byteLength(): number;
+  /** Read-only view of the current draw commands. Invalidated by `clear()`. */
+  get commands(): readonly DrawCommand[];
+  /**
+   * Parallel per-instance world-space AABBs — 4 floats per instance
+   * (`minX, minY, maxX, maxY`), in `append` order. Only the first
+   * `instanceCount * 4` floats are valid. Instance `i` reads `aabbs[i*4 .. i*4+3]`.
+   * Consumed by the v3 frustum-cull stage; populated lazily by `append`.
+   */
+  get aabbs(): Float32Array;
+  /**
+   * Monotonic mutation counter. Incremented by every `append` and `clear`
+   * call. Consumers (e.g. `MirrorLayer` simplify path) compare this across
+   * frames to detect whether a rebuild is necessary.
+   */
+  get version(): number;
+  /**
+   * Append one instance to the buffer. Calls `kind.pack` to write the record
+   * into the tail of the buffer, then merges or pushes a `DrawCommand`.
+   *
+   * `group` (P3-T8, optional) is CPU-side draw metadata — it is NOT packed into
+   * the instance bytes (geometry packing + the instance schema are UNTOUCHED).
+   * It rides along on the resulting `DrawCommand` so the renderer can compose
+   * the group transform into the camera slot live; a group-identity change is a
+   * merge boundary (see {@link _mergeCommand}). Omitting it (the common case)
+   * is byte-identical to the pre-T8 path: `group` defaults to `null`.
+   *
+   * `emphasisKey` (Phase 4, optional) is the per-instance emphasis key written
+   * into `lane4`. It is NOT geometry — no shape kind reads `lane4` — so it is
+   * stamped after `kind.pack`. The default `0` is written unconditionally so the
+   * key is deterministic (the buffer is reused across frames without zeroing).
+   * With the default emphasis uniform (`t == 0`) this has no visual effect.
+   */
+  append<R>(kind: PrimitiveKind<R>, rec: R, opaque: boolean, group?: Group | null, emphasisKey?: number): void;
+  /**
+   * Append `count` pre-packed instances verbatim from `src` into the tail of
+   * the buffer, then merge/push a single `DrawCommand` for the whole span.
+   *
+   * This is the byte-level analogue of {@link append}: rather than calling a
+   * `PrimitiveKind.pack` callback per instance, it `set()`s an already-packed
+   * `INSTANCE_BYTES * count` byte block (e.g. a slice copied out of another
+   * pack's buffer) directly. The caller owns the `typeFlag` — it is written onto
+   * the resulting command for the renderer's draw-call dispatch exactly as if
+   * each instance had been packed by a kind with that `typeFlag`.
+   *
+   * Used by {@link MirrorLayer}'s simplify rebuild, which copies/strips spans
+   * out of the primary pack's buffer and re-appends them. Replaces the prior
+   * synthetic-`PrimitiveKind` closure (which faked a kind with mutable per-call
+   * state, violating the kind contract).
+   *
+   * AABBs: per-instance world AABBs are NOT recoverable from packed bytes alone,
+   * so each appended instance gets a zero AABB (`0,0,0,0`) — identical to what
+   * the prior synthetic kind produced. The frustum-cull stage treats a degenerate
+   * AABB as "always submit", so a raw-appended span is never wrongly culled.
+   *
+   * `group` / `clipRect` flow onto the command exactly like {@link append}'s
+   * group: they participate in the {@link _mergeCommand} boundary (a span with a
+   * different group OR clip never coalesces with the previous command) and ride
+   * along on the pushed `DrawCommand`. A `null`/absent group + clip merges like
+   * `append` did before — byte- and command-identical.
+   *
+   * No-op when `count === 0`.
+   */
+  appendRaw(src: Uint8Array, typeFlag: number, opaque: boolean, count: number, group?: Group | null, clipRect?: FrameRect | null): void;
+  /**
+   * Reset the buffer for the next frame. Does not release memory — the
+   * allocated capacity is reused. Clears both the command list and the
+   * occupied byte count.
+   */
+  clear(): void;
+  /**
+   * Call once per frame end (after rendering). Tracks the low-water mark and
+   * reallocates to a smaller buffer after `SHRINK_FRAMES` consecutive frames
+   * where the occupied bytes are below 50 % of the buffer capacity.
+   *
+   * Safe: never reallocates when `_byteLen > newSize`.
+   */
+  tickShrink(): void;
+  /**
+   * Merge into the last `DrawCommand` if kind + opaque + group + contiguous,
+   * otherwise push a new command. Two instances tagged with DIFFERENT
+   * `Group` objects (by reference; `null` === "no group") never coalesce, since
+   * each group routes to its own per-(space × group) camera slot in the
+   * renderer. This RESTORES the architecture doc's "same-group merge" — the
+   * pre-T8 path dropped the group entirely and wrongly merged across groups.
+   * A `null`/absent group keeps the old behaviour exactly.
+   */
+  private _mergeCommand;
+  /**
+   * Ensure at least `additional` more bytes can be written at `_byteLen`.
+   * Growth policy: pow-of-2 doubling below `POW2_THRESHOLD_BYTES`; 1.25×
+   * linear at or above. Throws on overflow (exceeds `Number.MAX_SAFE_INTEGER`).
+   */
+  private _ensureCapacity;
+  /**
+   * Ensure the parallel AABB array holds at least `instances` instances (4 floats
+   * each). Doubles on demand and copies the existing AABBs across — the count is
+   * driven by `append` and never exceeds the instance count.
+   */
+  private _ensureAabbCapacity;
+  /** Reallocate to exactly `newByteLen` bytes, copying existing data. */
+  private _reallocate;
+}
+/**
+ * Compute the next buffer byte capacity given the current byte capacity and
+ * the minimum required bytes.
+ *
+ * - Below `POW2_THRESHOLD_BYTES`: power-of-2 doubling from `current` until ≥ `required`.
+ * - At or above threshold: `ceil(current * LINEAR_FACTOR)`, clamped to `required`.
+ *
+ * Throws a `RangeError` if `required` exceeds `Number.MAX_SAFE_INTEGER`.
+ */
+declare function nextByteCapacity(currentBytes: number, requiredBytes: number): number;
+//#endregion
+//#region src/scene/sprite-pack.d.ts
+/** Floats per sprite record — matches the 64 B `SpriteSchema`. */
+declare const SPRITE_FLOATS = 16;
+/** Bytes per sprite record (64 B). */
+declare const SPRITE_BYTES: number;
+/**
+ * One sprite to push onto a `Layer`.
+ */
+interface SpriteShape {
+  /** World/ui/device-space position of the sprite anchor. */
+  pos: Vec2;
+  /** Sprite size in the layer's coordinate space. */
+  size: Vec2;
+  /** Source texture or a borrowed sub-region of one. */
+  texture: Texture | TextureRegion;
+  /** Multiplicative tint (premultiplied in-shader). Default opaque white. */
+  tint?: Color;
+  /** Rotation in radians about the anchor. Default 0. */
+  rotation?: number;
+  /** Normalized anchor within the sprite. Default `[0.5, 0.5]` (center). */
+  anchor?: Vec2;
+  /**
+   * When `true`, routes into the opaque (depth-write) pass so the sprite
+   * contributes to early-Z occlusion. Default `false` (texture alpha unknown at
+   * pack time). Set only when the texture is fully opaque.
+   */
+  opaque?: boolean;
+}
+/**
+ * A merge-coalesced sprite draw command: a run of `count` contiguous sprite
+ * records (from float offset `offset * SPRITE_FLOATS`) sharing one `texture` and
+ * `opaque` flag. Mirrors v1's `DrawCommand` (kind `"sprites"`).
+ */
+interface SpriteCommand {
+  texture: Texture;
+  /** Item index of the first sprite in this run. */
+  offset: number;
+  /** Number of contiguous sprites in this run. */
+  count: number;
+  opaque: boolean;
+}
+/**
+ * CPU-side sprite accumulator backing `Layer.pushSprite`. Holds a flat
+ * `SpriteSchema`-layout float buffer (grown power-of-2) and a per-texture,
+ * adjacency-merged command list. The renderer reads {@link data} / {@link commands}
+ * after the main pass and draws each command through the interop sprites pipeline.
+ */
+declare class SpritePack {
+  private _data;
+  private _count;
+  private readonly _commands;
+  constructor(initialCapacity?: number);
+  /** Number of sprites packed. */
+  get count(): number;
+  /** Tight view of the packed sprite floats (`count * SPRITE_FLOATS`). */
+  get data(): Float32Array;
+  /** Merge-coalesced per-texture draw commands, in submission order. */
+  get commands(): readonly SpriteCommand[];
+  /** True when no sprites have been pushed (renderer can skip the layer). */
+  get isEmpty(): boolean;
+  /**
+   * Append one sprite and emit (or extend) its draw command. Adjacent sprites
+   * sharing a texture + opaque flag coalesce into one command (verbatim with
+   * v1's `appendSpriteCommand`).
+   */
+  push(sprite: SpriteShape): void;
+  /**
+   * Stamp the `order` (depth, float-offset 15) of the sprites in
+   * `[start, start + count)` to `value`. The owning {@link Layer} calls this at
+   * finalize with depths derived from the layer's UNIFIED push sequence (one
+   * continuous domain across shapes/glyphs/sprites), so a sprite z-interleaves
+   * with the shapes/glyphs pushed around it. No-op when `count <= 0`.
+   */
+  stampOrder(start: number, count: number, value: number): void;
+  /** Reset for the next frame. Capacity is reused (no reallocation). */
+  clear(): void;
+  /** Pack one sprite's 16 floats in the exact `SpriteSchema` byte layout. */
+  private _appendRecord;
+  /** Emit or extend the trailing draw command (adjacency merge by texture). */
+  private _appendCommand;
+  /** Grow the float buffer power-of-2 to hold `additional` more sprites. */
+  private _ensureCapacity;
+}
+//#endregion
+//#region src/schema/glyph.d.ts
+/** Per-block style. Layout matches `TextStyleTable` in text/effects.ts (144 B). */
+declare const TextStyleSchema: d.WgslStruct<{
+  fillColor: d.Vec4f;
+  outlineColor: d.Vec4f;
+  shadowColor: d.Vec4f;
+  gradientFrom: d.Vec4f;
+  gradientTo: d.Vec4f;
+  blockOrigin: d.Vec2f;
+  blockExtent: d.Vec2f;
+  shadowOffset: d.Vec2f;
+  gradientDir: d.Vec2f;
+  outlineWidth: d.F32;
+  outlineSoftness: d.F32;
+  shadowSoftness: d.F32;
+  pxRange: d.F32;
+  flags: d.U32;
+  _pad0: d.U32;
+  _pad1: d.Vec2u;
+}>;
+//#endregion
+//#region src/text/effects.d.ts
+type StyleStorageBuffer = TgpuBuffer<d.WgslArray<typeof TextStyleSchema>> & StorageFlag;
+interface TextOutline {
+  color: Color;
+  /** Outline half-width in screen pixels. */
+  width: number;
+  /** AA softness in screen pixels. Default 1. */
+  softness?: number;
+}
+interface TextShadow {
+  color: Color;
+  /** Offset in screen pixels (positive Y = down on screen). */
+  dx: number;
+  dy: number;
+  /** Edge softness in screen pixels. Default 2. */
+  softness?: number;
+}
+interface TextGradient {
+  from: Color;
+  to: Color;
+  /** Angle in radians, 0 = left→right, π/2 = top→bottom. Default 0. */
+  angle?: number;
+}
+interface TextStyle {
+  fill: Color;
+  outline?: TextOutline;
+  shadow?: TextShadow;
+  gradient?: TextGradient;
+}
+interface BlockGeometry {
+  /** World-space top-left of the block's content bbox. */
+  originX: number;
+  originY: number;
+  /** World-space size of the block's content bbox. */
+  width: number;
+  height: number;
+}
+/**
+ * Manages the GPU style-table storage buffer. One entry per visible text
+ * block per frame. `reset()` is called at the start of each frame; `add()`
+ * returns a `blockId` that the per-glyph instance data references.
+ *
+ * Layout matches `TextStyleSchema` in `schema/glyph.ts`.
+ */
+declare class TextStyleTable {
+  private readonly root;
+  /** CPU staging buffer; resized as power-of-2 when capacity grows. */
+  private cpuBuffer;
+  /** Same backing memory as `cpuBuffer`, viewed as u32 for flag/u32 writes. */
+  private cpuBufferU32;
+  /** GPU buffer. Reallocated when capacity grows. */
+  private gpu;
+  private _capacity;
+  private _count;
+  private _dirty;
+  /** Set when any added style enables the shadow flag this frame. */
+  private _hasShadow;
+  /**
+   * Per-frame intern table. Key is a string-serialized style payload; value
+   * is the blockId previously allocated for that payload. Cleared on reset()
+   * — block geometry varies by call site, so dedupe is single-frame scoped.
+   */
+  private internMap;
+  constructor(owner: GPUOwner, options?: {
+    label?: string;
+    initialCapacity?: number;
+  });
+  get count(): number;
+  /** Raw GPU buffer (advanced use). */
+  get gpuBuffer(): GPUBuffer;
+  /** TgpuBuffer for the style storage. Identity changes on `grow()`. */
+  get tgpuBuffer(): StyleStorageBuffer;
+  get hasShadow(): boolean;
+  /** Drop all entries. Call at the start of each frame. */
+  reset(): void;
+  /**
+   * Append a style entry, return its blockId.
+   * `geometry` provides the block's world-space AABB so the gradient can
+   * sample in block-local space.
+   */
+  add(style: TextStyle, geometry: BlockGeometry, pxRange: number): number;
+  /**
+   * Like `add`, but returns an existing blockId when called with a
+   * byte-equivalent style. Geometry is excluded from the dedupe key when no
+   * gradient is configured (the fragment shader only reads
+   * `blockOrigin`/`blockExtent` on the gradient path), so labels at
+   * different positions can share a single style entry. With a gradient,
+   * geometry is part of the key — falls back to per-block allocation.
+   */
+  intern(style: TextStyle, geometry: BlockGeometry, pxRange: number): number;
+  /** Upload dirty CPU data to the GPU buffer. Idempotent within a frame. */
+  flush(): void;
+  destroy(): void;
+  private createGpuBuffer;
+  private grow;
+  private write;
+}
+//#endregion
+//#region src/glyph/glyph-pack.d.ts
+/**
+ * Per-string rendering flags. Replace the three-pack split in v1.
+ *
+ * - `needsShaping` — full shaper (kerning, multi-line, wrap). Default false.
+ *   The fast LUT/simple path is used when false.
+ * - `anchored` — world anchor stored in lane3/lane4 (f32 bits) without CPU
+ *   camera projection; geom0.xy holds the origin-relative CSS-px pen position.
+ *   Bit 0 of lane2 is set so the vertex shader projects the anchor per-frame and
+ *   adds the glyph quad as a screen-px NDC delta. Pan never triggers a repack.
+ * - `screenSized` — em size is CSS px, not world units; bit 1 of lane2 is set
+ *   so the vertex shader scales by DPR instead of camera scale.
+ */
+interface GlyphPackFlags {
+  needsShaping?: boolean;
+  anchored?: boolean;
+  screenSized?: boolean;
+}
+/**
+ * Shape descriptor for `GlyphPack.pushText`. Mirrors v1's `TextShape` fields
+ * for call-site compatibility; fields not used by the v3 CPU packer (style
+ * effects — `outline`, `shadow`, `gradient`) are accepted but silently ignored.
+ * Effect support is a future v3 milestone.
+ */
+interface GlyphTextShape {
+  text: string;
+  /**
+   * World-space x (or CSS-px x when `screenSized`). When `anchored`, this is
+   * the WORLD anchor x — projected through the camera per-frame by the shader,
+   * not summed into the glyph geometry.
+   */
+  x: number;
+  /** World-space y (or CSS-px y when `screenSized`). Top of the first line.
+   * When `anchored`, the WORLD anchor y. */
+  y: number;
+  /**
+   * CSS-px offset from the projected anchor, applied in screen space. Only
+   * meaningful when `anchored` (mirrors v1's `AnchoredStringShape.offsetX/Y`).
+   * Default 0.
+   */
+  offsetX?: number;
+  offsetY?: number;
+  /** Fill color. Default BLACK. */
+  color?: Color;
+  /** Font size in world units per em (or CSS px when `screenSized`). Default 16. */
+  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, and wrap (matches v1's `TextShape.simple`).
+   * Equivalent to passing `{ needsShaping: false }` in flags.
+   */
+  simple?: boolean;
+  /**
+   * Glyph outline (stroke around each glyph). Accepted for call-site
+   * compatibility with v1's `TextShape`; silently ignored by the v3 packer
+   * until outline support is added to the glyph pipeline.
+   */
+  outline?: TextOutline;
+  /**
+   * Drop/inner shadow. Accepted for call-site compatibility with v1's
+   * `TextShape`; silently ignored by the v3 packer until shadow support is
+   * added to the glyph pipeline.
+   */
+  shadow?: TextShadow;
+  /**
+   * Linear gradient applied across the glyph fill. Accepted for call-site
+   * compatibility with v1's `TextShape`; silently ignored by the v3 packer
+   * until gradient support is added to the glyph pipeline.
+   */
+  gradient?: TextGradient;
+}
+/** Layout metrics returned by `pushText`. */
+interface GlyphMetricsOut {
+  glyphCount: number;
+  bbox: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  };
+}
+/**
+ * One plain-text push, recorded for auto-damage push-level diffing (D10
+ * revised). The fields are EVERY layout-affecting input — two records that
+ * compare equal are guaranteed to have produced identical pixels (the glyph
+ * stream is a pure function of these plus the atlas), so an unchanged push
+ * re-issued next frame (the clear-and-redraw HUD pattern) contributes no
+ * damage; only genuinely changed pushes damage their old/new bboxes.
+ */
+interface GlyphPushRecord {
+  /** The pushed string (reference — never copied). */
+  readonly text: string;
+  readonly x: number;
+  readonly y: number;
+  readonly fontSize: number;
+  readonly align: "left" | "center" | "right";
+  readonly lineHeight: number;
+  readonly maxWidth: number | undefined;
+  /** Layout switches that change glyph placement for the same text. */
+  readonly kerning: boolean;
+  readonly simple: boolean;
+  readonly colorBits: number;
+  /** The push's resulting layer-space layout bbox. */
+  readonly minX: number;
+  readonly minY: number;
+  readonly maxX: number;
+  readonly maxY: number;
+}
+/**
+ * CPU-side glyph instance buffer for v3.
+ *
+ * Each glyph is one 16-float `InstanceRecord` with `typeFlag=TYPE_GLYPH`.
+ * The pack is independent of any GPU device — construct and fill it in any
+ * environment and hand the `buffer` to the renderer for upload.
+ *
+ * Capacity grows power-of-2; `dataU32` is always re-aliased after growth.
+ */
+declare class GlyphPack {
+  private data;
+  private dataU32;
+  private _glyphCount;
+  private _version;
+  private _bboxMinX;
+  private _bboxMinY;
+  private _bboxMaxX;
+  private _bboxMaxY;
+  private _hasUnboundedGlyphs;
+  private _pushRecords;
+  private _retainAllRecords;
+  constructor(initialCap?: number, retainAllRecords?: boolean);
+  /** Number of glyph instances currently packed. */
+  get count(): number;
+  /**
+   * Monotonic content version. Increments on every mutating call (`pushText` /
+   * `pushString` / `pushAnchoredString` / `clear`) and never otherwise — so two
+   * reads with the same value guarantee the packed bytes are unchanged. The
+   * renderer uses it (alongside `count`) to skip the per-frame glyph upload on a
+   * frame that only moved the camera.
+   */
+  get version(): number;
+  /**
+   * The underlying flat `Float32Array`. Valid range: `[0, count * 16)`.
+   *
+   * May be reallocated on any push. Always re-read the reference after
+   * calling push methods if you hold a pre-push reference.
+   */
+  get buffer(): Float32Array;
+  /**
+   * Cumulative layer-space bbox of every PLAIN glyph pushed since `clear()`,
+   * or `null` when none. Anchored / screen-sized glyphs do NOT contribute (see
+   * {@link hasUnboundedGlyphs}). Returns a fresh object — safe to retain.
+   */
+  get contentBbox(): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  } | null;
+  /**
+   * Whether any anchored or screen-sized glyphs were pushed since `clear()`.
+   * Their pixels are placed by the camera projection at draw time, so
+   * {@link contentBbox} cannot bound them — auto-damage must not trust the
+   * bbox for this pack and falls back to a full-frame promote (D10).
+   */
+  get hasUnboundedGlyphs(): boolean;
+  /**
+   * The plain pushes since `clear()` as {@link GlyphPushRecord}s, or `null`
+   * once the pack overflowed {@link GLYPH_PUSH_RECORD_CAP}. Auto-damage diffs
+   * these against the previous frame's records so an unchanged push (same
+   * text, position, layout) contributes NO damage — without this, one changed
+   * HUD string damages the union of EVERY text block in the layer.
+   */
+  get pushRecords(): readonly GlyphPushRecord[] | null;
+  /**
+   * Push all visible glyphs from `shape` into the pack.
+   *
+   * Routing:
+   * - Single-line AND (`simple=true` OR no `\n` + no `maxWidth`):
+   *   fast path — cache lookup + memcpy + per-glyph patch (translate + colorBits + lane2).
+   * - Otherwise:
+   *   slow path — full `shapeText` call + per-glyph pack.
+   *
+   * `flags.needsShaping` overrides the routing decision: when true the slow
+   * path is always used; when false the fast path is always used.
+   */
+  pushText(shape: GlyphTextShape, atlas: GlyphAtlas, flags?: GlyphPackFlags): GlyphMetricsOut;
+  /**
+   * LUT (no-kerning) alias for `pushText`. Equivalent to calling `pushText`
+   * with `{ needsShaping: false }`. Preserved for v1 call-site parity
+   * (`TextStringPack.pushString`).
+   */
+  pushString(shape: GlyphTextShape, atlas: GlyphAtlas): number;
+  /**
+   * Stamp the `order` (depth, float-offset 10) of the glyph instances in
+   * `[start, start + count)` to `value`. The owning {@link Layer} calls this at
+   * finalize with depths derived from the layer's UNIFIED push sequence (one
+   * continuous domain across shapes/glyphs/sprites), so a glyph z-interleaves
+   * with the shapes pushed around it. No-op when `count <= 0`. Does NOT bump
+   * {@link version} — `order` is renderer-facing depth metadata, not glyph
+   * geometry, and the layer stamps it every frame regardless.
+   */
+  stampOrder(start: number, count: number, value: number): void;
+  /** Reset for the next frame. Retains allocated capacity. */
+  clear(): this;
+  private _pushFastPath;
+  /**
+   * Look up or compute the origin-relative glyph stream for a single-line
+   * shape. Cache key: `${fontSize}|${align}|${kerning ? 1 : 0}|${text}`.
+   */
+  private _getOrShapeFast;
+  private _pushSlowPath;
+  /**
+   * Ensure capacity for `add` more glyph instances. Returns the float offset
+   * where the new instances start. Re-aliases `dataU32` after any growth so
+   * both views are always consistent (never stale after reallocation).
+   */
+  private _ensureCapacity;
+}
+//#endregion
+//#region src/scene/layer.d.ts
+/**
+ * Optional `group` tag accepted by every `Layer.pushXxx` method. The group is
+ * forwarded into `UberPack.append` and the renderer transforms the shape's
+ * geometry live by composing the group's resolved transform into a dedicated
+ * per-(space × group) camera slot (P3-T8) — no repack on a group move. Mirrors
+ * v1's `GroupedShape`.
+ */
+interface GroupedShape {
+  group?: Group;
+  /**
+   * Per-instance emphasis key (Phase 4). Written into the instance's `lane4`;
+   * the uber `transparent` / OIT-build fragments dim every PARTICIPATING instance
+   * whose key does NOT equal the renderer's `Emphasis.focusedKey` uniform (set via
+   * {@link Renderer2D.setEmphasis}). Instances sharing a key emphasize together
+   * (e.g. a whole series).
+   *
+   * Defaults to `0`, which is the EXEMPT / opt-out sentinel: a key-0 instance is
+   * NON-participating and never dimmed, regardless of `t`. An instance OPTS IN by
+   * tagging a key ≥ 1 — so axis / grid / overlay shapes (which leave the default)
+   * stay full-alpha while chart marks dim. With emphasis inactive (`t == 0`) the
+   * key has no visual effect either way. Plot assigns keys in Phase 5.
+   *
+   * A tagged instance (`emphasisKey >= 1`) ALWAYS renders on the transparent
+   * path — dimming is a blend toward the backdrop, which the opaque
+   * (non-blending, discard-based) pipeline cannot express; visually identical
+   * for alpha-1 colors (src-over with a=1 replaces). So an alpha-1 mark that
+   * opts into emphasis is force-classified transparent at push time (see the
+   * `pushXxx` opacity computation) even though its color alpha is 1.
+   */
+  emphasisKey?: number;
+}
+interface GroupedRectRecord extends RectRecord, GroupedShape {}
+interface GroupedCircleRecord extends CircleRecord, GroupedShape {}
+interface GroupedEllipseRecord extends EllipseRecord, GroupedShape {}
+interface GroupedSegmentRecord extends SegmentRecord, GroupedShape {}
+interface GroupedCurveRecord extends CurveRecord, GroupedShape {}
+interface GroupedArcRecord extends ArcRecord, GroupedShape {}
+interface GroupedTriangleRecord extends TriangleRecord, GroupedShape {}
+interface GroupedPolylineShape extends PolylineShape, GroupedShape {}
+/**
+ * A solid stroke rendered through the analytic SDF `stroke-path` kind
+ * ({@link Layer.pushStroke}) instead of the CPU-tessellated `pushPolyline`
+ * path. Shares `PolylineShape`'s authoring surface (points / color / width /
+ * cap / join / closed / miterLimit) so call sites can opt in by swapping the
+ * method name. `dashPattern` is NOT supported on the SDF path — see
+ * {@link Layer.pushStroke}.
+ */
+interface GroupedStrokeShape extends PolylineShape, GroupedShape {}
+/**
+ * Hole-aware filled polygon. `points` is the outer ring (CCW or CW — earcut is
+ * orientation-agnostic), `holes` are inner rings (opposite winding). Mirrors
+ * v1's `ShapePack.appendPolygon` fill path: rings are flattened into one
+ * coordinate array with `holeIndices`, and `earcut(coords, holeIndices)`
+ * triangulates the result. The `{ triangles }` form (pre-triangulated) is the
+ * other accepted overload of `Layer.pushPolygon`.
+ */
+interface PolygonShape {
+  points: readonly Vec2[];
+  holes?: readonly (readonly Vec2[])[];
+  fill: Color;
+  group?: Group;
+  /**
+   * Per-instance emphasis key (Phase 4) written onto EVERY synthesized triangle
+   * of this polygon — exactly like {@link GroupedPolylineShape} threads one key
+   * across every tessellated segment — so a polygon-filled mark dims as one unit
+   * under the GPU emphasis uniform. Defaults to `0` (EXEMPT). A tagged polygon
+   * (`emphasisKey >= 1`) is force-classified transparent (see {@link GroupedShape}).
+   */
+  emphasisKey?: number;
+}
+/** Pre-triangulated polygon: the caller supplies the triangle list directly. */
+interface TriangulatedPolygon {
+  triangles: readonly TriangleRecord[];
+  group?: Group;
+  /**
+   * Per-instance emphasis key (Phase 4) written onto every supplied triangle.
+   * See {@link PolygonShape.emphasisKey}.
+   */
+  emphasisKey?: number;
+}
+/** Text shape plus the optional `group` tag (mirrors v1's `GroupedTextShape`). */
+interface GroupedTextShape extends GlyphTextShape, GroupedShape {}
+/**
+ * World-anchored, screen-sized string shape — the input to
+ * {@link Layer.pushAnchoredString}. Mirrors v1's `AnchoredStringShape`: the
+ * anchor is a world coordinate (projected per-frame by the glyph shader) and
+ * `fontSize` / `offsetX` / `offsetY` are CSS px. `x`/`y` are accepted as
+ * fallbacks for the anchor so older `{ x, y }` call sites keep working.
+ */
+interface GroupedAnchoredStringShape extends GroupedShape {
+  text: string;
+  /** Anchor in world coordinates. Projected through the camera at draw time. */
+  worldX?: number;
+  worldY?: number;
+  /** Fallback anchor (used when `worldX`/`worldY` are absent). */
+  x?: number;
+  y?: number;
+  /** Offset from the projected anchor, in CSS px. Default (0, 0). */
+  offsetX?: number;
+  offsetY?: number;
+  /** Em size in CSS px (not world units). Default 16. */
+  fontSize?: number;
+  /** Fill color. Default BLACK. */
+  color?: Color;
+  /** Horizontal anchor. Default `"left"`. */
+  align?: "left" | "center" | "right";
+  /** CSS-family hint for non-GPU consumers (SVG export); GPU uses the atlas font. */
+  fontFamily?: string;
+}
+/**
+ * Bulk single-line string batch for {@link Layer.pushStringsBulkInto} — the v3
+ * port of v1's `BulkStringBatch`. Structure-of-arrays input for the hot
+ * anchored-labels fast path: one append call shapes & packs `count` short
+ * labels into the layer's glyph pack with no per-string object allocation.
+ *
+ * NOTE (Phase-4): v1's `pushStringsBulkInto(pack, batch, options?)` took an
+ * explicit `TextStringPack` as its first arg. v3 has no separate string-pack —
+ * the layer owns one `GlyphPack` — so the first arg is dropped: v3 callers pass
+ * just `(batch, options?)`. The `anchored-labels.ts` call site (which currently
+ * passes `pack`) must drop that argument when it migrates.
+ */
+interface BulkStringBatch {
+  /** Number of strings in this batch. */
+  count: number;
+  /** World-x per string. Length ≥ count. */
+  x: ArrayLike<number>;
+  /** World-y per string. Length ≥ count. */
+  y: ArrayLike<number>;
+  /** Per-string font size in world units. Length ≥ count. */
+  fontSize: ArrayLike<number>;
+  /** Per-string text. Length ≥ count. */
+  texts: readonly string[];
+  /** Applies to every string in the batch. Mutually exclusive with `colors`. */
+  color?: Color;
+  /** Per-string color override. Length ≥ count when set; mutually exclusive with `color`. */
+  colors?: readonly Color[];
+  /** Horizontal align, shared by all strings. Default `"left"`. */
+  align?: "left" | "center" | "right";
+}
+interface LayerOptions {
+  /**
+   * Coordinate space for this layer:
+   * - `"world"` (default): camera-transformed world coordinates.
+   * - `"ui"`: CSS-pixel coordinates; camera ignored (UI overlays, text).
+   *
+   * Raw device px is no longer an authoring space (it is renderer-internal);
+   * for density-aware drawing author in `"ui"` and scale by `devicePixelRatio`.
+   */
+  space?: LayerSpace;
+  /**
+   * Crop this layer to the given device-pixel rectangle (applied as a scissor).
+   * Replaces v1's `clipRect` with a clearer name; `clipRect` is kept as an alias.
+   */
+  clip?: FrameRect;
+  /** Alias for `clip`, kept for v1 back-compat. `clip` wins when both are set. */
+  clipRect?: FrameRect;
+  /**
+   * MSDF glyph atlas backing this layer's text. Required to call `pushText` /
+   * `pushString` / `pushAnchoredString` (mirrors v1's
+   * `renderer.createLayer({ font })`, which mints the layer's `TextPack`). When
+   * omitted the text methods throw — a layer with no atlas cannot shape glyphs.
+   */
+  atlas?: GlyphAtlas;
+  /**
+   * Layer-wide default group (see {@link Layer.group}). Applied to commands
+   * without a per-push group so all of the layer's geometry projects through
+   * the group's transform — the navigator uses this to render its world content
+   * through the overview camera.
+   */
+  group?: Group;
+  /**
+   * Composite z-band for this layer (see {@link Layer.zIndex} for the full
+   * flat-z-band contract). `undefined` (default) → the layer keeps array
+   * insertion order, sorting ABOVE every layer that sets an explicit `zIndex`.
+   */
+  zIndex?: number;
+  /**
+   * Cache policy (see {@link Layer.cache}). Default `"auto"`.
+   */
+  cache?: CacheHint;
+  /**
+   * Optional human-readable label for this layer (see {@link Layer.label}). Pure
+   * metadata — never affects rendering. Surfaced in `FrameDebug.layers` /
+   * `bakeEvents`; absent → a stable `layer#<index-in-render-array>` fallback.
+   */
+  label?: string;
+  /**
+   * Retain a {@link GlyphPushRecord} for every text push without the
+   * {@link GLYPH_PUSH_RECORD_CAP} limit. Used by the static SVG exporter so
+   * every label can emit a semantic <text>. Off by default (the live/GPU path
+   * keeps bounded damage records).
+   */
+  retainAllPushRecords?: boolean;
+  /**
+   * Whether this layer is drawn (see {@link Layer.visible}). Default `true`. A
+   * `false` layer is EXCLUDED from drawing; flipping it demotes the next frame to
+   * a full repaint (folded into the view fingerprint).
+   */
+  visible?: boolean;
+  /**
+   * Optional static debug metadata (see {@link Layer.debugData}). Pure
+   * metadata — NEVER affects rendering. Read only while the debug probe is
+   * capturing and surfaced in `FrameDebug.layers[].debugData` (decision D7).
+   */
+  debugData?: Record<string, unknown>;
+  /**
+   * When `true`, forces all shapes pushed to this layer to be classified as
+   * transparent, routing them into the transparent pass (with depth write disabled).
+   *
+   * **Use Case**:
+   * Useful for layers containing interleaved opaque and transparent primitives (e.g.
+   * glowing cells or charts with status fills) where alternating opacities would
+   * otherwise fragment draw commands and break batching.
+   *
+   * **Caveats**:
+   * - **Fill-rate Cost**: Disables GPU Early-Z occlusion for all shapes on this layer,
+   *   running the full fragment shader for hidden/occluded pixels.
+   * - **OIT Buffer Cap**: Under OIT (`config.oit === true`), routing large volumes of
+   *   opaque geometry into the transparent pass increases the risk of overflowing the
+   *   GPU linked-list A-buffer (default max 8 fragments per pixel), which can cause
+   *   dropped pixels or rendering glitches.
+   */
+  forceTransparent?: boolean;
+  /**
+   * When `true` and the renderer runs with OIT enabled (`config.oit`), this
+   * layer is EXEMPT from the per-pixel A-buffer: its shapes/glyphs/sprites skip
+   * the OIT emit sweeps and instead alpha-blend directly into the backbuffer
+   * AFTER the OIT resolve, in painter's order, always ON TOP of the resolved
+   * scene (depth is reset for the exempt draw, so scene geometry never occludes
+   * it).
+   *
+   * **Use Case**: cursor-attached UI overlays (tooltips / crosshairs). The
+   * A-buffer holds at most `oitFragmentsPerPixel` fragments per pixel and
+   * overflow drops fragments in APPEND order — an overlay layer appends LAST,
+   * so over dense transparent marks its fragments are the first dropped and the
+   * overlay renders ghost-faint. Exemption takes the overlay out of the budget
+   * entirely.
+   *
+   * **Caveats**: an exempt layer does not z-interleave with OIT content — it is
+   * unconditionally topmost. With OIT off the flag is inert (the layer draws on
+   * the ordinary depth-stamped fallback path).
+   */
+  oitExempt?: boolean;
+}
+/**
+ * How the renderer decides whether to back a layer with a cached RTT snapshot
+ * (Phase 3, decisions.md D5):
+ *
+ *   - `"auto"` (default) — a cheap static heuristic (`instanceCount` + text)
+ *     decides: expensive layers bake, cheap ones stay live. NOT runtime-measured
+ *     (that is Phase 6).
+ *   - `"always"` — always bake to an RTT texture and composite the snapshot;
+ *     re-bake only when the layer's content or the view changes. Pinned: an
+ *     `"always"` layer is exempt from memory-budget eviction.
+ *   - `"never"` — always rasterize live; never bake, however expensive.
+ *
+ * The hint is SUBORDINATE to z-soundness (T-ZBAKE). A bake is a translucent image
+ * that can only composite UNDER all live geometry (a leading z-run) or OVER it (a
+ * trailing z-run); it cannot depth-interleave with the live opaque sweep. A layer
+ * whose bake would sit BETWEEN two live layers therefore stays LIVE even under
+ * `"always"` (composite correctness wins) — the cache policy never creates such a
+ * bake, and a manual one is demoted to live for any sandwiched frame. Bakes
+ * accelerate layers at the bottom and top of the z-stack.
+ */
+type CacheHint = "auto" | "always" | "never";
+/**
+ * Result of {@link Layer.finalizeOrder} — the per-layer unified z-order domain.
+ *
+ * `total` is N, the layer's instance count across shapes + glyphs + sprites.
+ * `shapeOrderSeq[j]` is the unified push index `i ∈ [0, N)` of the j-th UberPack
+ * shape instance (pack order). PHASE-4: the renderer consumes this to stamp
+ * shape `order = 1 - (i + 0.5)/total` in the SAME domain it now stamps glyph +
+ * sprite order — replacing today's cross-layer shape-only concat domain.
+ */
+interface OrderFinalization {
+  total: number;
+  shapeOrderSeq: number[];
+}
+/**
+ * A bag of shapes backed by a single `UberPack`. Push-methods delegate to the
+ * per-kind packers; `clear()` resets the pack for the next frame.
+ */
+declare class Layer {
+  readonly space: LayerSpace;
+  /** Device-pixel crop rect, or `undefined` for no clip. */
+  clipRect: FrameRect | undefined;
+  /** The underlying instance buffer + draw-command list. */
+  readonly pack: UberPack;
+  /** MSDF atlas the text methods shape against (`undefined` for shape-only layers). */
+  readonly atlas: GlyphAtlas | undefined;
+  /**
+   * Layer-wide default group: applied to every shape command (live OR retained)
+   * that carries no explicit per-push `group`, so ALL of the layer's geometry
+   * projects through the group's resolved transform. The escape hatch for
+   * content whose pushes don't set a group — e.g. the navigator routes its
+   * world content through an overview-camera group. Mutable so the group's
+   * transform can be re-derived per frame. A per-push `group` still wins.
+   */
+  group: Group | undefined;
+  /**
+   * Composite z-band (decisions.md D3 — the FLAT-Z-BAND contract):
+   *
+   *   - A layer is a flat z-band: layer N is entirely ABOVE layer N−1. Inter-
+   *     layer compositing is painter's order (a stack of `over`); there is NO
+   *     per-shape z-interleave ACROSS layers. A thing that must interleave with
+   *     another layer's shapes belongs in the same layer (where intra-layer OIT
+   *     resolves overlap) or must be split so the band order is unambiguous.
+   *   - Ordering: explicit `zIndex` sorts in ascending numeric order (lower =
+   *     drawn first = below). `undefined` keeps array insertion order and sorts
+   *     ABOVE all explicit-`zIndex` layers (the default "top" band). Equal keys
+   *     (including all-`undefined`) preserve insertion order — the sort is STABLE.
+   *   - Mutable: a pure `zIndex` change between frames is a COMPOSITE-only
+   *     invalidation (restack/recomposite, NO content re-render). The renderer
+   *     folds the z-order into its view fingerprint so a reorder demotes a
+   *     partial frame to a clean full repaint rather than ghosting (P2-T3).
+   */
+  zIndex: number | undefined;
+  /**
+   * Cache policy hint (Phase 3, decisions.md D5). The renderer reads this each
+   * frame to decide whether to back the layer with a cached RTT snapshot
+   * (composite the texture) or rasterize it live. See {@link CacheHint}. Mutable:
+   * flipping it between frames re-applies the policy on the next `render()`.
+   * Default `"auto"`.
+   *
+   * The hint never overrides z-order (T-ZBAKE): a bake composites UNDER all live
+   * geometry or OVER it, so a layer whose bake would sit between two live layers
+   * stays live even under `"always"` (composite correctness wins). Caching
+   * accelerates only the bottom and top of the z-stack.
+   */
+  cache: CacheHint;
+  /**
+   * Optional human-readable label. Pure metadata — it NEVER affects rendering.
+   * The renderer surfaces it in `FrameDebug.layers[].label` and the bake-event
+   * lists so tooling can name layers; when absent the renderer falls back to a
+   * stable `layer#<index-in-render-array>` id. Mutable.
+   */
+  label: string | undefined;
+  /**
+   * Whether this layer is drawn (default `true`). A `false` layer is EXCLUDED
+   * from the frame entirely — it is filtered out before the z-sort, so the
+   * concat / cache policy / cull / glyph / sprite paths all skip it consistently.
+   *
+   * Hiding SKIPS COMPOSITING an existing bake (it does NOT drop the bake), so a
+   * quick toggle does not thrash the RTT cache — re-showing composites the same
+   * texture again with no re-bake.
+   *
+   * INVALIDATION: a visibility flip MUST demote the NEXT frame to a full repaint
+   * (a hidden layer's pixels would otherwise linger under partial redraw). The
+   * renderer folds a visibility fingerprint into its view fingerprint (same
+   * pattern as the z-order fold), so any flip forces a clean full frame. Mutable.
+   */
+  visible: boolean;
+  /**
+   * Optional static debug metadata (decision D7). Pure metadata — it NEVER
+   * affects rendering and is READ ONLY while the debug probe is capturing. The
+   * renderer surfaces it (reference copy, not a clone) in
+   * `FrameDebug.layers[].debugData` so a presenter can show static extras
+   * (e.g. plot geom kinds) without re-binding to the layer. Mutable.
+   */
+  debugData: Record<string, unknown> | undefined;
+  /**
+   * When `true`, all shapes pushed to this layer are forced to be classified
+   * as transparent, routing them into the transparent pass.
+   */
+  readonly forceTransparent: boolean;
+  /**
+   * When `true`, this layer skips the OIT A-buffer under an OIT renderer and is
+   * drawn post-resolve, alpha-blended, always on top (see {@link LayerOptions.oitExempt}).
+   */
+  readonly oitExempt: boolean;
+  /**
+   * @internal Lazily-minted glyph instance buffer. `null` until the first
+   * `pushText`/`pushString`/`pushAnchoredString`; the bake path reads it through
+   * the `glyphPack` getter and renders glyphs via the dedicated MSDF glyph
+   * pipeline (`pipelines/glyph-pipelines.ts`), never the uber-shader.
+   */
+  private _glyphPack;
+  private _retainAllPushRecords;
+  /**
+   * @internal Lazily-minted CPU sprite accumulator. `null` until the first
+   * `pushSprite`/`addSprites`. The renderer reads it through the {@link spritePack}
+   * getter and draws each per-texture command through the standalone interop
+   * sprites pipeline POST-MAIN (a textured sibling pass — sprites cannot join the
+   * uber-pack; see `sprite-pack.ts`). Reset by `clear()` / `destroy()`.
+   */
+  private _spritePack;
+  /**
+   * @internal Running union of the world-space content bbox of every glyph
+   * pushed into this layer. `null` until the first text push. Shape AABBs are
+   * NOT tracked here — they live in `pack.aabbs` and are folded in by the
+   * {@link effectiveLocalBounds} getter. Reset by `clear()` / `destroy()`.
+   */
+  private _textBounds;
+  private readonly _orderEvents;
+  /** Pack instance count already folded into a shape event (flush watermark). */
+  private _shapesFlushed;
+  /** Pack instance count (shape instances appended to the UberPack). */
+  private _packInstanceCount;
+  /**
+   * Fold any UberPack instances appended since the last flush into one trailing
+   * shape event, preserving their position relative to interleaved glyph/sprite
+   * pushes. Called before each glyph/sprite event and once at finalize.
+   */
+  private _flushPendingShapes;
+  /** Log a glyph event (call AFTER {@link _flushPendingShapes}). No-op for 0 glyphs. */
+  private _logGlyphs;
+  constructor(pack: UberPack, options?: LayerOptions);
+  /**
+   * @deprecated Use the `pack` field directly. This getter exists only for
+   * call sites that reached `_pack` before it was renamed; it will be removed
+   * once all callers migrate.
+   * @internal
+   */
+  get _pack(): UberPack;
+  /**
+   * This layer's glyph instances, or `null` when the layer has pushed no text.
+   *
+   * The uber-shader has no glyph branch — a layer's glyphs are drawn through the
+   * dedicated MSDF glyph pipeline (`pipelines/glyph-pipelines.ts`), never the
+   * uber-shader. Two render paths consume this pack:
+   *
+   *   - LIVE (P3-T2): `Renderer2D.render([layer])` draws the glyphs in the main
+   *     pass as a sibling instanced draw — non-OIT in-pass (depth-tested against
+   *     shapes) or, under OIT, in a depth-attached pass after the resolve so text
+   *     lands above the transparent layer. Anchored glyphs re-project through the
+   *     camera every frame, so a pan never repacks them.
+   *   - BAKED: `Renderer2D.cacheLayer` → `runBakePass` freezes the glyphs into
+   *     the layer's RTT snapshot (`tiers/bake.ts`). A cached layer is composited,
+   *     NOT drawn live — the renderer's `_bakes` filter gates EITHER-live-OR-baked.
+   */
+  get glyphPack(): GlyphPack | null;
+  /** Lazily mint the glyph pack on first text push. */
+  private _glyphs;
+  /**
+   * This layer's CPU sprite accumulator, or `null` when no sprite was pushed.
+   *
+   * Sprites do NOT enter the {@link pack} uber-buffer — a textured quad carries
+   * an external texture binding the uber/OIT fragment cannot own (decisions.md
+   * §unifying-rule). The renderer reads this pack after the main pass and draws
+   * each per-texture command through the standalone interop sprites pipeline
+   * (camera-projected, depth/tint/rotation), stacking by submission order — the
+   * same post-main slot as BufferLayer / CustomDrawable. `@internal` for the
+   * renderer; consumers use {@link pushSprite}.
+   * @internal
+   */
+  get spritePack(): SpritePack | null;
+  /** Lazily mint the sprite pack on first sprite push. */
+  private _sprites;
+  /** Require the atlas configured at construction, or throw with v1's guidance. */
+  private _requireAtlas;
+  pushRect(shape: GroupedRectRecord): this;
+  pushCircle(shape: GroupedCircleRecord): this;
+  pushEllipse(shape: GroupedEllipseRecord): this;
+  pushSegment(shape: GroupedSegmentRecord): this;
+  /**
+   * Back-compat alias for v1's `pushLine`. v1's `LineShape` is just a straight
+   * stroked segment, so it collapses onto `pushSegment` in v3.
+   */
+  pushLine(shape: GroupedSegmentRecord): this;
+  pushCurve(shape: GroupedCurveRecord): this;
+  pushArc(shape: GroupedArcRecord): this;
+  pushTriangle(shape: GroupedTriangleRecord): this;
+  /**
+   * Stroke a polyline. The shape is tessellated on the CPU (port of v1's
+   * `tessellatePolyline` — caps butt/round/square, joins miter/bevel/round,
+   * miter-limit fallback, dashes, closed loops) into a triangle list, and each
+   * triangle is appended through the `triangle` kind so adjacent same-fill
+   * triangles merge into one draw command. The polyline's `color` becomes each
+   * triangle's `fill`. Mirrors v1's `Layer.pushPolyline`; the optional `group`
+   * tag is forwarded to every synthesized triangle so the whole polyline shares
+   * one per-(space × group) camera slot and transforms live (see the class doc).
+   */
+  pushPolyline(shape: GroupedPolylineShape): this;
+  /**
+   * Stroke a polyline through the analytic SDF `stroke-path` kind — the opt-in
+   * alternative to {@link pushPolyline}'s CPU triangulation. The polyline is
+   * chunked into `ceil((M-1)/3)` instances of up to 4 points each (3 live
+   * sub-segments per instance) via {@link chunkStroke}; the fragment shader
+   * computes coverage with a min-of-segment SDF and analytic AA. For dense
+   * branch lines this collapses ~26 triangle instances per 8-point curve down to
+   * 3 stroke instances (≈8.7×), eliminating the per-triangle `pack.append` cost.
+   *
+   * All instances of one stroke share kind + group, so they self-merge into ONE
+   * draw command. The `group` and `emphasisKey` tags are forwarded to every
+   * synthesized instance (like {@link pushPolyline}), and opacity is classified
+   * identically (`colorOpaque(color)` unless tagged).
+   *
+   * SCOPE: solid strokes only. `dashPattern` is NOT supported on the SDF path —
+   * a dashed shape THROWS here; route dashes through {@link pushPolyline}
+   * (CPU-tessellated) instead.
+   *
+   * GUARANTEES (GPU pixel-parity verified): round joins render exactly, and
+   * round/butt caps render exactly. Square caps are APPROXIMATE at the corners
+   * (the analytic clip rounds-then-flattens the corner rather than producing the
+   * tessellator's true square extension). Miter/bevel joins are NOT rendered by
+   * the SDF kind: a single instance cannot see the join angle at a point that
+   * lives on its own chunk/closure boundary, so those seam vertices would render
+   * round. Such shapes are DELEGATED to the tessellated {@link pushPolyline}
+   * path, which is exact. (Full analytic miter/bevel seam joins are a tracked
+   * follow-up requiring a neighbor-point encoding in the instance.)
+   *
+   * JOIN ROUTING: the polyline default join is `"miter"` (see
+   * `tessellatePolyline`: `shape.join ?? "miter"`). An UNDEFINED `join` therefore
+   * means miter and is routed to {@link pushPolyline} as well — the SDF kind is
+   * used ONLY when `join` is explicitly `"round"`. After this guard the stroke
+   * kind only ever receives round joins.
+   *
+   * KEEPS {@link pushPolyline} as the default, unchanged — this is purely additive.
+   */
+  pushStroke(shape: GroupedStrokeShape): this;
+  /** Bulk SDF-stroke append. Mirrors {@link addLines} for {@link pushStroke}. */
+  addStrokes(shapes: readonly GroupedStrokeShape[], options?: {
+    group?: Group;
+  }): this;
+  /**
+   * A polygon is rendered as a triangle list. Two forms are accepted:
+   *
+   *   - `{ triangles }` — pre-triangulated. Each triangle is appended directly
+   *     (unchanged from the original v3 API).
+   *   - `{ points, holes? }` — earcut-triangulated hole-aware on the CPU,
+   *     mirroring v1's `ShapePack` fill path (flatten outer ring + hole rings
+   *     into one coords array with `holeIndices`, call `earcut`). The polygon's
+   *     `fill` becomes each triangle's fill.
+   *
+   * Adjacent same-fill triangles merge into one draw command.
+   */
+  pushPolygon(shape: TriangulatedPolygon | PolygonShape): this;
+  addRects(shapes: readonly GroupedRectRecord[], options?: {
+    group?: Group;
+  }): this;
+  addCircles(shapes: readonly GroupedCircleRecord[], options?: {
+    group?: Group;
+  }): this;
+  addEllipses(shapes: readonly GroupedEllipseRecord[], options?: {
+    group?: Group;
+  }): this;
+  /** Bulk straight-segment append. Mirrors v1's `addLines` (LineShape collapses onto `pushSegment`). */
+  addLines(shapes: readonly GroupedSegmentRecord[], options?: {
+    group?: Group;
+  }): this;
+  addTriangles(shapes: readonly GroupedTriangleRecord[], options?: {
+    group?: Group;
+  }): this;
+  addPolygons(shapes: readonly PolygonShape[], options?: {
+    group?: Group;
+  }): this;
+  /**
+   * Bulk-append `opts.count` segments from a pre-packed v1-stride buffer
+   * (`SEGMENT_FLOATS` floats per record: `[x1, y1, x2, y2, colorBits, width]`).
+   * Repacked into v3's 16-float instance layout and submitted as one draw
+   * command. Byte-identical to looping {@link pushSegment} over the records.
+   */
+  addSegmentsPacked(data: ArrayLike<number>, opts: {
+    count: number;
+    opaque: boolean;
+    group?: Group;
+  }): this;
+  /**
+   * Bulk-append `opts.count` cubic curves from a pre-packed v1-stride buffer
+   * (`CURVE_FLOATS` floats per record: four control points, then `colorBits`,
+   * `widthPacked` (pack2x16float), `flagsBits` (cap in low 2 bits), and a pad).
+   * Byte-identical to looping {@link pushCurve} over the records.
+   */
+  addCurvesPacked(data: ArrayLike<number>, opts: {
+    count: number;
+    opaque: boolean;
+    group?: Group;
+  }): this;
+  /**
+   * Bulk-append `opts.count` circular arcs from a pre-packed v1-stride buffer
+   * (`ARC_FLOATS` floats per record: `[cx, cy, radius, theta0, theta1, width,
+   * colorBits, _pad]`). Byte-identical to looping {@link pushArc} over the
+   * records.
+   */
+  addArcsPacked(data: ArrayLike<number>, opts: {
+    count: number;
+    opaque: boolean;
+    group?: Group;
+  }): this;
+  /**
+   * Append one textured sprite (port of v1's `Layer.pushSprite`). Adjacent
+   * sprites sharing a texture coalesce into one draw command. Returns `this` for
+   * chaining. The sprite draws above this layer's shape geometry by submission.
+   */
+  pushSprite(sprite: SpriteShape): this;
+  /** Append many sprites (port of v1's `Layer.addSprites`). */
+  addSprites(sprites: readonly SpriteShape[]): this;
+  /**
+   * Shape `shape.text` and append its glyphs to this layer's glyph pack. Mirrors
+   * v1's `Layer.pushText` — full shaper (kerning, multi-line, wrap) unless
+   * `flags.needsShaping` / `shape.simple` opt into the fast path. Returns the
+   * layout metrics (glyph count + world bbox).
+   */
+  pushText(shape: GroupedTextShape, flags?: GlyphPackFlags): GlyphMetricsOut;
+  /**
+   * Fast single-line, no-kerning text append. Mirrors v1's `Layer.pushString`
+   * (`TextStringPack.pushString`): equivalent to `pushText` with
+   * `{ needsShaping: false }`. Returns `this` for chaining.
+   */
+  pushString(shape: GroupedTextShape): this;
+  /**
+   * World-anchored text append. Mirrors v1's `Layer.pushAnchoredString`: the
+   * anchor stays in world coordinates (no CPU camera projection) and the
+   * vertex shader projects it per-frame, so a pan never repacks the glyphs.
+   * Sets the `anchored` flag (lane2 bit 0).
+   */
+  pushAnchoredString(shape: GroupedAnchoredStringShape, flags?: GlyphPackFlags): this;
+  /**
+   * Bulk single-line label fast path (port of v1's `Layer.pushStringsBulkInto`).
+   * Shapes & packs every string in `batch` into this layer's glyph pack with no
+   * per-string object allocation — the structure-of-arrays input is walked once.
+   *
+   * v1 took an explicit `TextStringPack` as the first argument; v3 has a single
+   * layer-owned `GlyphPack`, so that argument is dropped (see {@link BulkStringBatch}).
+   * Returns `this` for chaining. The optional `group` is accepted for call-site
+   * parity but, like all v3 text, glyphs carry no per-instance group.
+   */
+  pushStringsBulkInto(batch: BulkStringBatch, _options?: {
+    group?: Group;
+  }): this;
+  /**
+   * Finalize this layer's UNIFIED z-order for a frame. Walks the per-push event
+   * log in true interleaved order, assigns every instance — shape, glyph,
+   * sprite — a monotonic index `i ∈ [0, N)` (N = total instances across the
+   * three packs), and stamps `order = 1 - (i + 0.5)/N ∈ (0, 1)` into the GLYPH
+   * and SPRITE packs so they z-interleave with the shapes pushed around them.
+   *
+   * The returned `shapeOrderSeq` is the unified index `i` of each UberPack shape
+   * instance, in pack order, and `total` is N.
+   *
+   * PHASE-4: shape `order` is still stamped by the renderer's gather
+   * (`renderer.ts`, `ORDER_FLOAT_OFFSET`) over the CROSS-LAYER concat with
+   * N = total shapes across ALL layers — a DIFFERENT domain from this per-layer
+   * unified one. Until the renderer adopts this layer-local domain (consuming
+   * {@link OrderFinalization.shapeOrderSeq} + {@link OrderFinalization.total}),
+   * shapes and glyphs/sprites do NOT yet share one continuous domain at draw
+   * time. This method is the single source of truth for that reconciliation.
+   *
+   * Idempotent within a frame: re-deriving `order` from the same event log
+   * yields the same values. The glyph/sprite CPU stamp is done here regardless
+   * so a glyph/sprite pack always carries live depth; wiring the renderer to
+   * call this + consume `shapeOrderSeq` is the PHASE-4 follow-up.
+   */
+  finalizeOrder(): OrderFinalization;
+  /** Reset the pack (and glyph pack) for the next frame. Capacity is reused. */
+  clear(): this;
+  /**
+   * Set this layer's device-pixel crop rect (port of v1's `Layer.setClipRect`).
+   * Pass `undefined` to disable clipping. Sets the {@link clipRect} field and
+   * returns `this` for chaining. `mount`'s `applyPipelineFrames` calls this each
+   * frame to confine marks to the plot frame.
+   */
+  setClipRect(rect: FrameRect | undefined): this;
+  /**
+   * Number of SDF-shape instances (rect / circle / ellipse) packed into this
+   * layer. Port of v1's `Layer.shapeCount`. Counts only the closed SDF shapes —
+   * triangles are reported by {@link triangleCount}; segments / curves / arcs /
+   * glyphs are not included (matching v1's `ShapePack.shapeCount`).
+   */
+  get shapeCount(): number;
+  /**
+   * Number of triangle instances packed into this layer (port of v1's
+   * `Layer.triangleCount`). Polygons and tessellated polylines each append one
+   * triangle instance per tri, so this is their combined tri count.
+   */
+  get triangleCount(): number;
+  /**
+   * Effective local-space AABB of this layer's content, or `null` when empty
+   * (port of v1's `Layer.effectiveLocalBounds`). The union of every packed
+   * shape's world AABB (read from `pack.aabbs`, which {@link UberPack} captures
+   * at pack time) plus every pushed glyph block's content bbox. Used by `mount`
+   * and `PhyloScene` to derive overlay damage rects.
+   *
+   * Bounds are in the layer's local shape space, ignoring any per-shape group
+   * transform — matching v1.
+   */
+  get effectiveLocalBounds(): WorldAABB | null;
+  /**
+   * Drop CPU-side buffers held by this layer (port of v1's `Layer.destroy`).
+   * After `destroy()` the layer should not be pushed to or rendered again.
+   * Anchored-labels and plot's mount teardown call this. Renderer-side state
+   * keyed off the layer lives in a `WeakMap` and is reclaimed once the caller
+   * drops their reference.
+   */
+  destroy(): void;
+  /** Fold a glyph block's content bbox into the running text-bounds union. */
+  private _expandTextBounds;
+}
+/** Mint a fresh `Layer` over a new `UberPack`. */
+declare function createLayer(options?: LayerOptions): Layer;
+//#endregion
+//#region src/debug/space-map.d.ts
+/** A coordinate space a debug rect may be expressed in (decision D2). */
+type DebugSpace = "world" | "ui" | "device" | "css-layout";
+/** A 2D size in pixels (units depend on the space it describes). */
+interface DebugSize {
+  readonly w: number;
+  readonly h: number;
+}
+/**
+ * Per-frame snapshot of the coordinate spaces the debug tooling converts between.
+ *
+ * - `dpr` — device-pixel ratio (`device = ui × dpr`).
+ * - `deviceSize` — backing-store size in device px (`canvas.width/height`).
+ * - `uiSize` — `deviceSize ÷ dpr`; the camera's projection target and the space
+ *   core regions are reported in.
+ * - `cssBox` — the canvas CSS layout box (`clientWidth/clientHeight`), or `null`
+ *   when unknown (headless tests / no DOM). Used only to map ui ↔ css-layout.
+ * - `worldToUi` — base world-camera view matrix into ui px (= `viewFromCamera`
+ *   over the CSS-px viewport, matching the draw/scissor path).
+ */
+interface SpaceMap {
+  readonly dpr: number;
+  readonly deviceSize: DebugSize;
+  readonly uiSize: DebugSize;
+  readonly cssBox: DebugSize | null;
+  readonly worldToUi: Mat3;
+}
+/** An axis-aligned rect (no space tag — the caller passes `from`/`to`). */
+interface RectXYWH {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+/**
+ * Build a {@link SpaceMap} from plain inputs — pure, no DOM access. The renderer
+ * (P1-T2) gathers `camera` / sizes / `dpr` / `cssBox` and calls this only while
+ * the probe is enabled (decision D8). `worldToUi` is the canonical
+ * `worldToCssMatrix(camera, deviceSize.w, deviceSize.h, dpr)` — `viewFromCamera`
+ * over the CSS-px viewport (`device ÷ dpr`). The renderer's world camera
+ * baseline is CSS px and dpr is applied once matrix-side when drawing to the
+ * device backbuffer, so this is the exact world → ui map of what landed on
+ * screen, including under HiDPI.
+ */
+declare function captureSpaceMap(inputs: {
+  camera: ResolvedCameraState;
+  deviceSize: DebugSize;
+  dpr: number;
+  cssBox?: DebugSize | null;
+}): SpaceMap;
+/**
+ * Convert `rect` from space `from` to space `to`, routing through ui as the hub.
+ *
+ * - world ↔ ui via `worldToUi` (four corners min/max — correct under rotation).
+ * - ui ↔ device via `dpr`.
+ * - ui ↔ css-layout via `cssBox / uiSize` per-axis (identity when `cssBox` null).
+ *
+ * Same-space conversion returns the rect unchanged.
+ */
+declare function convertRect(rect: RectXYWH, from: DebugSpace, to: DebugSpace, map: SpaceMap): RectXYWH;
+//#endregion
+//#region src/config.d.ts
+/**
+ * Per-frame timing/diagnostics record emitted via {@link RendererConfig.onFrameTiming}.
+ *
+ * The `totalMs`/`uploadMs`/`encodeMs`/`drawCalls`/`damageRects` fields are the
+ * v3 canonical surface. The trailing `cpuMs`/`renderNs`/`computeNs` getters are
+ * v1-back-compat ALIASES (P3-T7) so Phase-4 consumers reading the v1
+ * `FrameTiming` shape keep working without a code change; build the record with
+ * {@link frameTiming} so the aliases stay derived (single source of truth — the
+ * canonical fields) rather than separately settable.
+ */
+interface FrameTiming {
+  /** Wall-clock ms for the full render call. */
+  totalMs: number;
+  /** ms spent in GPU upload (writeBuffer calls). */
+  uploadMs: number;
+  /** ms spent encoding + submitting (createCommandEncoder → queue.submit). */
+  encodeMs: number;
+  /** Number of draw calls issued this frame. */
+  drawCalls: number;
+  /** Number of damage rects processed (0 = full frame). */
+  damageRects: number;
+  /** v1 alias of {@link totalMs} — wall-clock CPU ms of the render call. */
+  readonly cpuMs: number;
+  /**
+   * v1 alias: CPU-side encode time in NANOSECONDS (`encodeMs * 1e6`), as a
+   * `bigint` to match v1's `renderNs` type. v3 does not run a GPU
+   * timestamp-query, so this is the closest CPU analog of v1's GPU render-pass
+   * duration, NOT a true GPU measurement.
+   */
+  readonly renderNs: bigint;
+  /**
+   * v1 alias: always `0n`. The v3 `render()` spine issues no compute passes
+   * (v1's `computeNs` summed `renderer.compute()` passes, which v3's render path
+   * has no equivalent of), so there is nothing to report.
+   */
+  readonly computeNs: bigint;
+}
+/**
+ * Build a {@link FrameTiming} from the v3 canonical fields, deriving the v1
+ * back-compat aliases (`cpuMs`/`renderNs`/`computeNs`) as getters over them so
+ * the canonical fields stay the single source of truth. See {@link FrameTiming}
+ * for the alias mapping rationale.
+ */
+declare function frameTiming(canonical: {
+  totalMs: number;
+  uploadMs: number;
+  encodeMs: number;
+  drawCalls: number;
+  damageRects: number;
+}): FrameTiming;
+/**
+ * A named PART of the composite view fingerprint (decision D1/render-debug v2).
+ * When a `"view-changed"` full frame fires while the probe is enabled, the
+ * renderer diffs the previous frame's parts against this frame's and reports the
+ * subset that actually changed in {@link FrameDebug.fullCause}`.changed`. The
+ * `"emphasis"` part is folded in by P4-T1 (emphasis-in-fingerprint, D6).
+ */
+type FingerprintPart = "camera" | "size" | "dpr" | "background" | "view-key" | "z-order" | "visibility" | "buffer-layer" | "emphasis";
+/**
+ * A space-tagged axis-aligned rect crossing the debug boundary (decision D2).
+ * Core's damage regions are reported in `"ui"` (device ÷ dpr); a presenter
+ * converts to its own space only via {@link convertRect} + the frame's
+ * {@link SpaceMap}.
+ */
+interface DebugRect {
+  /** The coordinate space `x/y/width/height` are expressed in. */
+  space: DebugSpace;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+/**
+ * Per-layer diagnostic snapshot inside a {@link FrameDebug.layers} array, in
+ * the frame's z-sorted DRAW order (`orderLayersByZ`, NOT insertion order). One
+ * entry per `Layer` passed to `render()` (BufferLayers / CustomDrawables are not
+ * Layers and are excluded). Allocated only when the debug probe is capturing —
+ * never on the zero-cost path.
+ *
+ * Carries a DIRECT {@link Layer} reference (`layer`) so a presenter binds to the
+ * live object by identity — there is no label-then-index re-binding heuristic
+ * (the v1 `matchRows` footgun, decision D1).
+ */
+interface LayerDebugInfo {
+  /** Direct reference to the live `Layer` (identity — not a clone). */
+  layer: Layer;
+  /** The layer's {@link Layer.label}, or a stable fallback `layer#<insertion-index>`. */
+  label: string;
+  /** The layer's composite z-band, or `undefined` (top band — array order). */
+  zIndex: number | undefined;
+  /** Coordinate space (`"world" | "ui"`). */
+  space: LayerSpace;
+  /** {@link Layer.visible} — `false` layers are excluded from drawing. */
+  visible: boolean;
+  /** Packed shape-instance count (`pack.byteLength / INSTANCE_BYTES`). */
+  instances: number;
+  /** Packed glyph count (`glyphPack?.count ?? 0`). */
+  glyphs: number;
+  /**
+   * Static cost estimate (the `"auto"` cache heuristic's `_costEstimate`:
+   * `instances + glyphs * GLYPH_COST_WEIGHT`).
+   */
+  cost: number;
+  /**
+   * Where the layer landed in the frame's draw plan (derived from the T-ZBAKE
+   * bake partition + visibility filter):
+   *
+   *   - `"hidden"`      — `visible === false`; excluded from drawing.
+   *   - `"live"`        — rasterized live this frame (no bake, or a demoted bake).
+   *   - `"baked-below"` — composited UNDER all live geometry (leading z-run bake).
+   *   - `"baked-above"` — composited OVER all live geometry (trailing z-run bake).
+   *   - `"bake-demoted"`— has a bake but sat sandwiched between live layers, so it
+   *     was demoted to live for this frame (T-ZBAKE).
+   */
+  cacheState: "live" | "baked-below" | "baked-above" | "bake-demoted" | "hidden";
+  /**
+   * The layer's {@link Layer.debugData} metadata (reference copy, not a clone),
+   * or `undefined`. Wired in P1-T5; surfaced here so a presenter can read static
+   * geom-kind extras without re-binding to the layer.
+   */
+  debugData?: Record<string, unknown>;
+}
+/**
+ * Per-frame DEBUG record (render-debug v2) — the single rich event the core
+ * `renderer.debug` probe dispatches each frame. The history ring stores leaner
+ * SUMMARIES of these (decision D3); the live event carries direct {@link Layer}
+ * references + the {@link SpaceMap}.
+ *
+ * Replaces the v1 `FrameDebug` (deleted, not deprecated — decision D1). The key
+ * upgrades: `fullCause.changed[]` (fingerprint-PART diff, not just an umbrella
+ * reason), space-tagged `regionsCaller`/`regionsFinal`, direct layer refs, a
+ * per-frame {@link SpaceMap}, and cache/emphasis detail.
+ *
+ * ZERO-COST-WHEN-OFF (HARD requirement, mirrors `insomni-profiler`): when the
+ * probe is not capturing, the renderer constructs NO record, retains NO previous
+ * fingerprint parts, reads NO `cssBox` from the DOM, and builds NO `layers` /
+ * region arrays — the entire assembly is guarded behind the capture check.
+ */
+interface FrameDebug {
+  /** Monotonic frame index (`Renderer2D` `_frameIndex`). */
+  frame: number;
+  /** `"full"` (loadOp:"clear" whole-canvas repaint) or `"partial"` (scissored). */
+  kind: "full" | "partial";
+  /**
+   * Why this frame was FULL (only set when `kind === "full"`). `reason` is the
+   * kebab-case umbrella vocabulary (`"no-regions"`, `"bake-created"`,
+   * `"force-full"`, `"view-changed"`, …); on a `"view-changed"` full while the
+   * probe is capturing, `changed` lists the fingerprint PARTS that actually moved
+   * (`undefined` for every other reason).
+   */
+  fullCause?: {
+    reason: string;
+    changed?: readonly FingerprintPart[];
+  };
+  /**
+   * Damage rects exactly as the caller passed them, space-tagged `"ui"`. Empty
+   * on a `damage: "auto"` frame — the caller passed no rects there; the
+   * core-derived ones appear in `regionsFinal` (+ `autoDamage` provenance).
+   */
+  regionsCaller: readonly DebugRect[];
+  /** Damage rects post-pad/clamp (what the GPU scissored), space-tagged `"ui"`. */
+  regionsFinal: readonly DebugRect[];
+  /**
+   * Provenance for CORE-derived damage (`damage: "auto"`) — which layer produced
+   * which rects, BEFORE coalesce (so a tick can be attributed to the mark that
+   * moved). Space-tagged `"ui"`. Present only on an auto PARTIAL frame; absent on
+   * caller-`regions`, full, and non-auto frames.
+   */
+  autoDamage?: {
+    perLayer: readonly {
+      label: string;
+      rects: readonly DebugRect[];
+    }[];
+  };
+  /**
+   * Per-frame coordinate-space snapshot (decision D2). `cssBox` is read from the
+   * canvas `clientWidth/clientHeight` ONLY here and only while capturing.
+   */
+  spaces: SpaceMap;
+  /** One entry per `Layer` passed to `render()`, in z-sorted draw order. */
+  layers: readonly LayerDebugInfo[];
+  /** Cached-layer (bake) detail this frame. */
+  cache: {
+    /** `config.layerCacheBudgetBytes` (0 = unlimited). */budgetBytes: number; /** Sum of resident bake texture bytes. */
+    usedBytes: number; /** One entry per live bake. */
+    bakes: readonly {
+      label: string;
+      bytes: number;
+      state: string;
+      lastChangeFrame: number;
+    }[]; /** Synthetic ids of bakes evicted this frame (records already gone). */
+    evicted: readonly string[]; /** Spaces of bakes DEMOTED to live this frame (T-ZBAKE). */
+    demoted: readonly string[];
+  };
+  /** Decoded emphasis uniform mirror (`setEmphasis` state). */
+  emphasis: {
+    focusedKey: number;
+    dimAlpha: number;
+    t: number;
+  };
+  /**
+   * Caller-supplied annotation (decision D7). Wired in P1-T5 — declared now so
+   * the shape is stable. `reason` is the caller's intent next to core's decision;
+   * `data` is freeform.
+   */
+  annotation?: {
+    reason?: string;
+    data?: Record<string, unknown>;
+  };
+  /** Wall-clock ms for the full render call. */
+  totalMs: number;
+  /** ms spent in GPU upload (writeBuffer calls). */
+  uploadMs: number;
+  /** ms spent encoding + submitting. */
+  encodeMs: number;
+  /** Number of draw calls issued this frame. */
+  drawCalls: number;
+  /** Number of damage rects processed (0 = full frame). */
+  damageRects: number;
+}
+/** Construction-time configuration for the v3 renderer. */
+interface RendererConfig {
+  oit: boolean;
+  oitFragmentsPerPixel: number;
+  /**
+   * When `navigator.deviceMemory` (GiB) is below this threshold, OIT is
+   * automatically disabled even if `oit: true`. Default `2` GiB.
+   * Set to `0` to disable the auto-check. Non-standard API: absent on Firefox;
+   * treated as "unknown / assume sufficient" when missing.
+   */
+  autoDisableOitBelowMemoryGiB?: number;
+  partialRedraw: boolean;
+  /**
+   * Frustum cull: when `true` (the default), the render spine narrows each
+   * `world`-space draw command to the contiguous sub-ranges whose per-instance
+   * AABB intersects the viewport frustum, emitting split draws against the same
+   * concat buffer (no compaction) and stamping depth over survivors only.
+   * `ui` / `device` chrome is never frustum-culled. When `false` the cull stage
+   * is skipped entirely and every command issues one full-span draw (the path is
+   * byte-identical to the pre-cull behavior). Read LIVE per frame in the spine
+   * (like `partialRedraw`), so a runtime toggle takes effect on the next render
+   * — it is NOT seeded into a cached `_useCull` field.
+   */
+  cull: boolean;
+  msaaBakes: 1 | 4;
+  persistent: boolean;
+  /**
+   * Total resident memory budget (bytes) for renderer-managed cached-layer RTT
+   * textures (P3-T3). When a new `"auto"`/`"always"` bake would push the total
+   * cached-texture bytes over this cap, the policy evicts the least-valuable
+   * auto-managed bake(s) first (lowest `cost × staleness`); `"always"` layers and
+   * explicit `cacheLayer()` bakes are pinned (never auto-evicted). Read LIVE per
+   * frame. `0` (or negative) disables the budget (unlimited). Default 128 MiB
+   * (≈ eight 4096×2048 RGBA8 snapshots). Manual `cacheLayer()` is not counted
+   * against the budget for eviction decisions beyond its resident bytes.
+   */
+  layerCacheBudgetBytes: number;
+  /**
+   * Initial clear color, applied once at construction to seed the live
+   * `_background` (mutate at runtime via `setBackground`). Default
+   * fully-transparent.
+   */
+  initialBackground: Color;
+  /**
+   * Initial CSS→device pixel ratio, applied once at construction to seed the
+   * live `_dpr` (mutate at runtime via `setDpr`). The renderer NEVER reads
+   * `window.devicePixelRatio` itself — the app opts in via `detectDpr()` +
+   * `setDpr()` (HARD boundary 4). Default `1`.
+   */
+  initialDpr: number;
+  /**
+   * Cap applied to `detectDpr()` results. Set to `2` for mobile to limit
+   * fill cost (fragment cost scales as DPR²). Callers pass this to
+   * `watchDpr(renderer, canvas, { maxDpr })`. Default `undefined` (no cap).
+   */
+  maxDpr?: number;
+  /**
+   * Color-target format the bake + composite pipelines are built at. CONSTRAINED
+   * (HARD boundary 3): it MUST match the injected pipelines AND the swap-chain
+   * format. It does NOT configure the swap chain — that always uses
+   * `navigator.gpu.getPreferredCanvasFormat()`. `undefined` means "default to
+   * the swap-chain's preferred format" (resolved at construction).
+   */
+  colorFormat?: GPUTextureFormat;
+  onFrameTiming?: (t: FrameTiming) => void;
+  onGpuFrameTiming?: (ms: number) => void;
+}
+/** Default v3 renderer configuration (OIT + partial redraw + frustum cull enabled + 4× MSAA bakes on). */
+declare const DEFAULT_CONFIG: Readonly<RendererConfig>;
+//#endregion
+//#region src/debug/frame-ring.d.ts
+/** Capacity of the core history ring (decision D3). */
+declare const FRAME_RING_CAPACITY = 240;
+/** A scalar per-layer row in a {@link FrameSummary} (no `Layer` ref). */
+interface LayerSummary {
+  label: string;
+  cacheState: LayerDebugInfo["cacheState"];
+  instances: number;
+  glyphs: number;
+}
+/**
+ * A compact, JSON-serializable per-frame summary kept in the {@link FrameRing}.
+ * Carries no `Layer` references and no `SpaceMap` matrices (decision D3) — only
+ * scalars — so the ring never retains a scene graph.
+ */
+interface FrameSummary {
+  frame: number;
+  kind: "full" | "partial";
+  /** `fullCause.reason` on a full frame; `undefined` on a partial. */
+  reason: string | undefined;
+  /** `fullCause.changed` fingerprint parts (only on a view-changed full). */
+  changed: readonly FingerprintPart[] | undefined;
+  /** Number of final damage rects (0 on a full frame). */
+  rectCount: number;
+  /** Summed area of the final damage rects in ui px² (0 on a full frame). */
+  rectArea: number;
+  totalMs: number;
+  uploadMs: number;
+  encodeMs: number;
+  drawCalls: number;
+  layers: readonly LayerSummary[];
+}
+/** Derive a {@link FrameSummary} (scalars only) from a rich {@link FrameDebug}. */
+declare function summarize(d: FrameDebug): FrameSummary;
+/**
+ * Fixed-capacity ring buffer of {@link FrameSummary}. `push` appends and drops
+ * the oldest once full; `toArray` returns oldest→newest in insertion order.
+ */
+declare class FrameRing {
+  readonly capacity: number;
+  private buf;
+  private head;
+  private full;
+  constructor(capacity?: number);
+  push(s: FrameSummary): void;
+  get size(): number;
+  /** Oldest → newest. */
+  toArray(): FrameSummary[];
+  /** Cumulative full/partial counts over the resident window. */
+  ratio(): {
+    full: number;
+    partial: number;
+  };
+  /** The resident timeline (oldest→newest) as a JSON string (D3 copy-JSON). */
+  exportJson(): string;
+  clear(): void;
+}
+//#endregion
+//#region src/debug/probe.d.ts
+/** A per-frame FrameDebug v2 listener. Returns nothing. */
+type FrameDebugListener = (d: FrameDebug) => void;
+/**
+ * The narrow slice of `Renderer2D` the probe drives. The renderer implements this
+ * inline at construction so the probe never holds the public renderer surface (or
+ * imports the class — no cycle). All methods are called ONLY while capturing.
+ */
+interface DebugHost {
+  /** Release the per-frame retention (caller layer array + prev fingerprint parts). */
+  releaseDebugRetention(): void;
+  /** The exact `Layer[]` reference passed to the most recent `render()`, or null. */
+  getLastLayers(): readonly Layer[] | null;
+  /** Re-render the retained last layers as a full frame (no-op if none retained). */
+  requestRender(): void;
+  /**
+   * Project the union of `layer`'s packed instance AABBs into a single `ui`-space
+   * rect (the layer's live space view-projection), or `null` when the pack is
+   * empty. The probe converts to the requested space via the frame's SpaceMap.
+   */
+  layerAabbUi(layer: Layer): DebugRect | null;
+  /** Convert a `ui`-space rect to `space` using the most recent frame's SpaceMap. */
+  convertFromUi(rect: DebugRect, space: DebugSpace): DebugRect | null;
+}
+/**
+ * Core-owned render-debug probe. Constructed lazily by `Renderer2D.debug`; see
+ * the module header for the zero-cost-off lifecycle.
+ */
+declare class RendererDebug {
+  private readonly host;
+  private readonly listeners;
+  private _enabled;
+  /** Fixed-capacity history ring of frame SUMMARIES (decision D3). */
+  readonly ring: FrameRing;
+  constructor(host: DebugHost);
+  /**
+   * Whether the renderer should assemble a FrameDebug v2 record this frame. True
+   * while explicitly enabled OR while any `onFrame` listener is attached. Read by
+   * the renderer once per frame — the zero-cost-off gate.
+   */
+  get isCapturing(): boolean;
+  /** Enable capture unconditionally (idempotent). The app gates the call (D4). */
+  enable(): void;
+  /**
+   * Disable explicit capture (idempotent). Capture continues if listeners remain;
+   * once neither enabled nor listened-to, the host's per-frame retention is freed.
+   */
+  disable(): void;
+  /**
+   * Subscribe to the per-frame FrameDebug v2 event. Returns an unsubscribe fn.
+   * Attaching a listener makes the probe capture; removing the last one (while not
+   * explicitly enabled) releases retention. Safe to unsubscribe during dispatch.
+   */
+  onFrame(cb: FrameDebugListener): () => void;
+  /**
+   * The exact `Layer[]` reference passed to the most recent `render()` while
+   * capturing, or `null`. A presenter reads this to mutate the caller's live
+   * layers (visibility / cache-hint) by identity.
+   */
+  get lastLayers(): readonly Layer[] | null;
+  /** Re-render the retained last layers as a full frame (no-op if none). */
+  requestRender(): void;
+  /**
+   * Project the union of `layer`'s packed instance AABBs into a damage rect in
+   * `space` (default `"ui"`), or `null` when the pack is empty / no frame has
+   * been captured (the SpaceMap is unknown before the first capturing frame).
+   * Uses the same `viewProjectionForSpace` the draw + `regionsFromLayerAabbs` use.
+   */
+  layerAabb(layer: Layer, space?: DebugSpace): DebugRect | null;
+  /**
+   * Dispatch a freshly-assembled frame to the ring + listeners. Renderer-internal:
+   * called by the host ONLY when `isCapturing`. Snapshots the listener set first so
+   * a callback may unsubscribe (or others subscribe) mid-dispatch without skipping
+   * or double-invoking.
+   */
+  dispatch(d: FrameDebug): void;
+}
+//#endregion
+//#region src/shared/cull.d.ts
+interface AABB {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}
+//#endregion
+//#region src/cull.d.ts
+/**
+ * The cull stage's view of one rebased draw command: a contiguous run of global
+ * instance indices `[firstInstance, firstInstance + instanceCount)` that share a
+ * kind + opacity, plus whether they live in `world` space (frustum-culled) or a
+ * screen-fixed space (`ui` / `device`, passed through unculled). Shaped as a
+ * structural subset of the renderer's `RebasedCommand` so the renderer feeds its
+ * commands straight in.
+ */
+interface CullCommand {
+  firstInstance: number;
+  instanceCount: number;
+  /**
+   * `true` when this command's coordinate space is `world` (camera-transformed),
+   * so the frustum cull applies. `false` for `ui` / `device` — screen-fixed
+   * chrome that is NEVER frustum-culled (invariant 5).
+   */
+  world: boolean;
+}
+/**
+ * One narrowed sub-range of a {@link CullCommand}: a contiguous span of global
+ * instance indices that survived the cull, suitable for a single `pass.draw`.
+ * Multiple ranges are emitted when a command's survivors are non-contiguous
+ * (a culled middle gap splits one command into several draws — invariant 2).
+ */
+interface CulledRange {
+  firstInstance: number;
+  instanceCount: number;
+  /**
+   * Index into the input `commands` array of the command this range came from,
+   * so the renderer recovers the source command's pipeline kind / opacity /
+   * camera slot / clip when issuing the draw.
+   */
+  commandIndex: number;
+}
+/** Result of {@link cullCommands}: narrowed ranges + the ordered survivor list. */
+interface CullResult {
+  /**
+   * The narrowed draw ranges, in the SAME order as the input commands (and, for
+   * a split command, ascending by `firstInstance`). When cull keeps an entire
+   * command, exactly ONE range is emitted with the original first/count
+   * (all-survive coalesces — invariant 4).
+   *
+   * `firstInstance` indexes the GLOBAL concat buffer directly — the buffer is
+   * NOT compacted (invariant 2), so these are issued to `pass.draw` as-is.
+   */
+  ranges: CulledRange[];
+  /**
+   * Global instance indices of every survivor, in ascending (submission) order.
+   * The renderer stamps depth over THESE ONLY, with a running survivor counter
+   * and `N = survivorIndices.length`, so z re-densifies over (0,1) without
+   * moving any instance in the buffer (invariants 1 & 2).
+   */
+  survivorIndices: number[];
+}
+/**
+ * Derive the world-space frustum AABB for the WORLD camera slot — the rectangle
+ * of world coordinates visible in a `width × height` (CSS-px) viewport under the
+ * given camera, inflated by {@link CULL_AA_EPSILON} CSS px converted to world
+ * units (`/zoom`). This is the single place the AA pad lives (it is NOT baked
+ * into every shape's AABB — that would dominate tiny-world content).
+ *
+ * Rotation is handled CONSERVATIVELY: under a rotated camera the visible world
+ * region is the rotated viewport rectangle, whose axis-aligned bounding box has
+ * half-extents `halfW·|cos θ| + halfH·|sin θ|` (and the transpose for Y) — the
+ * standard AABB of a rotated rect. This is an over-approximation (it always
+ * contains the true rotated frustum), so the cull never wrongly drops a visible
+ * shape; at `θ = 0` it collapses to the exact `width/zoom × height/zoom` box.
+ */
+declare function worldFrustumAabb(camera: {
+  x: number;
+  y: number;
+  zoom: number;
+  rotation?: number;
+}, width: number, height: number): AABB;
+/**
+ * Narrow each draw command into the contiguous sub-ranges whose per-instance
+ * world AABB intersects `view`. Pure + device-free.
+ *
+ * @param commands  Rebased draw commands (global instance ranges + `world` flag).
+ * @param aabbs     Flat per-instance world AABBs, 4 floats per GLOBAL instance
+ *                  index (`minX, minY, maxX, maxY`) — i.e. instance `g` reads
+ *                  `aabbs[g*4 .. g*4+3]`. Sourced from `kind.aabb()` at pack time.
+ * @param view      World-space frustum AABB (see {@link worldFrustumAabb}).
+ *
+ * Behavior:
+ *  - A `world` command keeps each maximal run of consecutive visible instances
+ *    as one range; a culled gap splits it (invariant 2 — no compaction, split
+ *    draws). A fully-visible command yields exactly one range with its original
+ *    first/count (invariant 4 — all-survive coalesces). A fully off-screen
+ *    command yields no range (invariant: off-screen dropped).
+ *  - A `ui` / `device` command (`world === false`) is passed through UNCULLED —
+ *    one range with its original first/count (invariant 5 — screen chrome is
+ *    never frustum-culled).
+ *
+ * Survivor RELATIVE order is preserved (commands processed in input order, each
+ * scanned ascending), so the painter stack is intact.
+ */
+declare function cullCommands(commands: readonly CullCommand[], aabbs: Float32Array, view: AABB): CullResult;
+//#endregion
+//#region src/tiers/spatial-grid.d.ts
+/**
+ * A cell-binned spatial grid over a retained pack's per-instance AABBs. Slot
+ * indices (`cellStart`, `smallEnd`, ranges) index the REORDERED buffer the
+ * renderer uploads (per {@link buildSpatialGrid}'s `newOrder`), NOT the original
+ * `append` order.
+ */
+interface SpatialGrid {
+  readonly gridW: number;
+  readonly gridH: number;
+  /**
+   * Per-axis cell size — sized independently so elongated content (a phylo tree
+   * whose Y span dominates X) keeps fine X-granularity. Mirrors v1's split.
+   */
+  readonly cellSizeX: number;
+  readonly cellSizeY: number;
+  readonly originX: number;
+  readonly originY: number;
+  /**
+   * Length `gridW * gridH + 1`. `cellStart[i]..cellStart[i+1]` is the slot range
+   * for cell `i` in the reordered buffer. The last value equals {@link smallEnd}
+   * (oversized items live past it and are not cell-binned).
+   */
+  readonly cellStart: Uint32Array;
+  /** Per-cell max half-extent on X/Y; query inflates each cell bbox by these. */
+  readonly cellMaxHalfW: Float32Array;
+  readonly cellMaxHalfH: Float32Array;
+  /** Boundary between cell-binned small items `[0, smallEnd)` and the oversized tail. */
+  readonly smallEnd: number;
+  /** Flat `[minX,minY,maxX,maxY]×(count-smallEnd)` for the oversized tail; `null` when none. */
+  readonly oversizedAabbs: Float32Array | null;
+  /** Total instances indexed — matches the retained pack's instance count. */
+  readonly count: number;
+}
+/** One contiguous slot range of the reordered buffer suitable for a single `pass.draw`. */
+interface SpatialRange {
+  /** First slot index in the reordered buffer. */
+  offset: number;
+  count: number;
+}
+/** Result of {@link buildSpatialGrid}. */
+interface SpatialGridResult {
+  index: SpatialGrid;
+  /**
+   * Permutation: `newOrder[newSlot] = originalInstanceIndex`. The renderer copies
+   * each instance's bytes from its original slot to `newSlot`, so a cell's items
+   * land contiguously and {@link queryRanges} emits few draws.
+   */
+  newOrder: Uint32Array;
+}
+/** Options for {@link buildSpatialGrid}. Mirrors v1's `BuildSpatialIndexOptions`. */
+interface SpatialGridOptions {
+  /** Target cells along the dominant axis. Default 32. */
+  cellsPerAxis?: number;
+  /** Below this instance count the grid is not worth building → returns `null`. Default 1024. */
+  minItems?: number;
+}
+/**
+ * Build a cell-binned grid + permutation from flat per-instance AABBs
+ * (`[minX,minY,maxX,maxY]×count`, the `UberPack.aabbs` layout).
+ *
+ * Returns `null` when `count < minItems` or the content bounds are degenerate —
+ * the caller then retains the pack WITHOUT an index (drawn as one full-span
+ * draw, the existing non-indexed retained path). Faithful port of
+ * `renderer/spatial-index.ts:buildGridFromAabbs`.
+ */
+declare function buildSpatialGrid(aabbs: Float32Array, count: number, options?: SpatialGridOptions): SpatialGridResult | null;
+/**
+ * Query the grid for the contiguous slot ranges (in the reordered buffer) whose
+ * cell bboxes intersect `view`. Writes into `out` (cleared first) and returns
+ * it. Faithful port of `renderer/spatial-index.ts:queryRanges` — fast-path when
+ * `view` contains the whole grid, a tier-1 small-cell sweep, and a tier-2
+ * oversized-tail per-item test, all coalescing consecutive survivors into runs.
+ */
+declare function queryRanges(index: SpatialGrid, view: AABB, out: SpatialRange[]): SpatialRange[];
+//#endregion
+//#region src/tiers/encode-types.d.ts
+/**
+ * A draw command rebased onto the dynamic concat instance buffer: the source
+ * command plus its `[firstInstance, firstInstance+instanceCount)` slice, the
+ * camera slot it binds, and the per-frame cull/clip/exempt facts the encode
+ * paths need. The clip + cull are wired so a future clipped command (or the
+ * scene layer) drops in with no spine change.
+ */
+interface RebasedCommand {
+  cmd: DrawCommand;
+  firstInstance: number;
+  instanceCount: number;
+  clipRect: FrameRect | null;
+  /**
+   * Camera slot this command's draw binds at `@group(0)`. For an un-grouped
+   * command this is the base space slot; for a group-tagged command (P3-T8) it
+   * is a dynamic per-(space × group) slot whose uploaded matrix is `spaceVP ∘
+   * resolveGroupTransform(group)`, assigned per frame by `Renderer2D.render`.
+   * The encode paths bind `cameraBindGroups[spaceSlot]` — they are agnostic to
+   * whether the slot is a base or group slot.
+   */
+  spaceSlot: number;
+  /**
+   * `true` when this command's layer is `world` space (camera-transformed), so
+   * the frustum-cull stage applies; `false` for `ui` / `device` (screen-fixed
+   * chrome, passed through unculled — invariant 5). Fed to `cullCommands`.
+   */
+  world: boolean;
+  /**
+   * `true` when this command's layer sets `Layer.oitExempt` AND the renderer
+   * runs with OIT: the command skips BOTH main-pass sweeps (opaque Pass 1 and
+   * the OIT build Pass 2) and instead draws post-resolve in the exempt overlay
+   * pass (`encodeExempt`). Always `false` on a non-OIT renderer — the flag is
+   * inert there and the command takes the ordinary path.
+   */
+  exempt: boolean;
+}
+/**
+ * One live-glyph instanced draw: a contiguous slice of the concatenated glyph
+ * instance buffer (`[first, first+count)`) bound against `atlas`'s @group(2) and
+ * the camera `slot` for the source layer's space. Built once per frame in the
+ * gather pass; consumed by `Renderer2D._encodeGlyphs` in BOTH the non-OIT
+ * in-pass draw and the OIT post-resolve pass.
+ */
+interface GlyphDraw {
+  /** The source layer's MSDF atlas — its own @group(2) binding (invariant 9). */
+  atlas: GlyphAtlas;
+  /** Camera slot for the layer's coordinate space. */
+  slot: number;
+  /** First glyph instance index in the concatenated glyph buffer. */
+  first: number;
+  /** Glyph instance count for this layer. */
+  count: number;
+  /**
+   * `true` when the source layer sets `Layer.oitExempt`: under OIT these
+   * glyphs skip the OIT emit sweep and draw post-resolve in the exempt overlay
+   * pass via the direct-color pipeline. Inert on the non-OIT path.
+   */
+  exempt: boolean;
+}
+/**
+ * A registered RTT bake for a cached layer. The `texture` is a single-sample
+ * snapshot of the layer's shapes + glyphs; `composite` is its per-bake uniform
+ * (NDC rect + UV rect) bind group + buffer. Instead of re-rasterizing the
+ * layer's pack, `render()` composites `texture` through the textured-quad
+ * pipeline — UNDER the live geometry (in-main-pass, leading z-run) or OVER it
+ * (post-main pass, trailing z-run) per the bake's z-position (T-ZBAKE). A bake
+ * sandwiched between two live layers is DEMOTED (rasterized live for that frame).
+ */
+interface BakeRecord {
+  /** The cached layer (kept so `uncacheLayer(layer)` can find its pack). */
+  layer: Layer;
+  /** Single-sample bake texture (caller-owned; destroyed on uncache). */
+  texture: GPUTexture;
+  /** Composite uniform buffer (NDC + UV rect). */
+  uniform: GPUBuffer;
+  /** Composite bind group (uniform + bake texture view + sampler). */
+  bindGroup: GPUBindGroup;
+  /**
+   * Content + view fingerprint at bake time (P3-T1). The cache policy re-bakes a
+   * renderer-managed layer when `Renderer2D._cacheKeyFor` no longer matches
+   * (content version changed, or — for a world-space layer — the camera moved).
+   */
+  cacheKey: string;
+  /**
+   * `true` when the bake was created by the per-frame cache policy (`"always"`
+   * or `"auto"` hint), `false` when created by an explicit `Renderer2D.cacheLayer`
+   * call. The policy only auto-evicts / auto-drops bakes it manages, so a manual
+   * cacheLayer keeps its prior "caller owns the lifecycle" semantics.
+   */
+  managed: boolean;
+  /** Resident texture bytes (`w*h*4`) — summed against the memory budget (P3-T3). */
+  bytes: number;
+  /** Frame index of the last content change — staleness for eviction (P3-T3). */
+  lastChangeFrame: number;
+}
+/**
+ * A registered RETAINED layer. Its `UberPack` owns a STABLE GPU instance buffer
+ * managed by `RetainedTier` (keyed on the pack); the renderer draws it as a
+ * DISTINCT appended draw over its OWN bind group — it never joins the dynamic
+ * concat instance buffer (whose `@builtin(instance_index)` mapping and z stamp
+ * shift every frame as the live set grows/shrinks). The buffer is re-uploaded
+ * ONLY when `key` changes (or the pack's `version` advances under that key); an
+ * unchanged retained layer issues ZERO re-upload and still draws — the whole
+ * performance win. Mirrors the `_bakes` ownership model: keyed by `layer.pack`,
+ * evicted on `unretainLayer` + `destroy()`.
+ */
+interface RetainedRecord {
+  /** The retained layer (kept so `unretainLayer(layer)` can find its pack). */
+  layer: Layer;
+  /**
+   * Stable per-layer retention key. A change (or a `pack.version` bump under the
+   * same key) triggers exactly one rebuild + re-upload; an unchanged key skips
+   * the re-concat/re-upload entirely.
+   */
+  key: string;
+  /** `pack.version` captured at the last build — guards an in-place mutation. */
+  version: number;
+  /** `@group(1)` bind group over the tier's stable buffer for this pack. */
+  bindGroup: GPUBindGroup;
+  /**
+   * Instance count of the retained pack captured at build time
+   * (`pack.byteLength / INSTANCE_BYTES`). Stored so `render()` issues the
+   * appended `draw(4, count, …)` without recomputing it per frame.
+   */
+  count: number;
+  /** Camera slot for this layer's coordinate space. */
+  spaceSlot: number;
+  /**
+   * Whether this layer is `world`-space (informational; retained draws are
+   * unculled — they live outside the dynamic concat the cull stage narrows).
+   */
+  world: boolean;
+  /**
+   * Optional cell-binned grid over this pack's per-instance AABBs (built when
+   * `retainLayer(layer, key, { spatialIndex: true })`). The stable GPU buffer is
+   * uploaded in the grid's reordered slot order; on a `world`-space frame the
+   * renderer range-queries this index against the viewport frustum and issues
+   * one draw per visible cell-run — the v3 `cacheLayer({ spatialIndex: true })`
+   * equivalent. `null` when no index was requested or the pack was too small to
+   * index (draws as one full-span draw). The grid only narrows WHICH survivors
+   * draw, never their relative (frozen, per-slot) painter order.
+   */
+  grid: SpatialGrid | null;
+}
+//#endregion
+//#region src/oit/abuffer.d.ts
+/**
+ * Compile-time max K the resolve shader can sort/blend. The resolve pass
+ * (`oit-pipelines.ts`) sizes its per-pixel local arrays to this constant (WGSL
+ * arrays must be compile-time sized) and composites only `min(count, K, this)`
+ * slots. A runtime `K` larger than this would therefore be SILENTLY truncated
+ * by the resolve — fragments beyond slot 15 would be dropped in rasterization
+ * order with no signal — which violates the A-buffer's loud contract. So the
+ * {@link ABuffer} constructor hard-errors when `K` exceeds this cap.
+ *
+ * This is the single source of truth: `oit-pipelines.ts` imports it to size the
+ * resolve shader's local arrays, so the cap and the shader can never drift.
+ */
+declare const RESOLVE_MAX_K = 16;
+/** Bytes per A-buffer slot: `rgba` (packed unorm8x4 → u32) + `depth` (f32). */
+declare const SLOT_BYTES = 8;
+/** Bytes per head entry: one `atomic<u32>` insert counter per pixel. */
+declare const HEAD_BYTES = 4;
+/** Construction options for {@link ABuffer}. */
+interface ABufferOptions {
+  /** K — per-pixel fragment budget (`RendererConfig.oitFragmentsPerPixel`). */
+  fragmentsPerPixel: number;
+}
+/**
+ * Per-pixel bounded-K A-buffer (heads + slots) plus the build/resolve bind-group
+ * layouts and bind groups. When the slots buffer would exceed the device's
+ * `maxStorageBufferBindingSize`, {@link resize} auto-reduces K (with a console
+ * warning) rather than throwing. Prefer pre-clamping via {@link clampKForDevice}
+ * so the effective K is stable from construction.
+ */
+declare class ABuffer {
+  /**
+   * Per-pixel fragment budget (≥ 1). Set at construction; may be reduced at
+   * {@link resize} time when the slots buffer would exceed the device storage
+   * limit. Read the value after resize to get the effective K.
+   */
+  K: number;
+  /** `array<atomic<u32>>` insert counters — one per pixel. */
+  heads: GPUBuffer;
+  /** `array<OITNode>` of `width*height*K` slots. Slot `p*K + i` for pixel `p`. */
+  slots: GPUBuffer;
+  /** `{ width, height, K, _pad }` uniform read by the build + resolve shaders. */
+  viewportUniform: GPUBuffer;
+  /** Build-pass layout: heads + slots `storage`, viewport `uniform`. */
+  readonly buildLayout: GPUBindGroupLayout;
+  /** Resolve-pass layout: heads + slots `read-only-storage`, viewport `uniform`. */
+  readonly resolveLayout: GPUBindGroupLayout;
+  /** Bind group for the build pass (re-created on each {@link resize}). */
+  buildBindGroup: GPUBindGroup;
+  /** Bind group for the resolve pass (re-created on each {@link resize}). */
+  resolveBindGroup: GPUBindGroup;
+  private readonly device;
+  private width;
+  private height;
+  /**
+   * The opaque-pass depth view, supplied by the renderer after construction.
+   * `undefined` until {@link setDepthView} is called. The build bind group is
+   * not constructed until BOTH the A-buffer GPU buffers (`heads`/`slots`) AND
+   * this view are present — see {@link _buildBuildBindGroup}.
+   */
+  private depthView?;
+  constructor(device: GPUDevice, options: ABufferOptions);
+  /**
+   * (Re)allocate the heads + slots buffers for a `width × height` surface and
+   * rebuild the bind groups. No-op when the dimensions are unchanged.
+   *
+   * When the slots buffer (`pixels * K * SLOT_BYTES`) would exceed the device's
+   * `maxStorageBufferBindingSize`, K is auto-reduced to the largest value that
+   * fits (minimum 1) and a console warning is emitted. The effective K after the
+   * call is available as {@link K}. Prefer pre-clamping via
+   * {@link clampKForDevice} so K is stable from construction. (`heads` is
+   * `pixels * HEAD_BYTES`, far smaller, so slots are always the binding-limit
+   * gate.)
+   */
+  resize(width: number, height: number): void;
+  /**
+   * Supply (or refresh) the opaque depth view that will be bound at
+   * `@binding(3)` in every subsequent build pass.
+   *
+   * **Call-order contract:** Construction and resize are independent — the build
+   * bind group is only (re)created once BOTH the A-buffer GPU buffers AND the
+   * depth view are present. Callers may therefore call `setDepthView` before or
+   * after `resize` and the bind group will be correct:
+   *
+   * - `setDepthView` BEFORE `resize`: the view is stored; `resize` builds the
+   *   bind group when it allocates the buffers (because `depthView` is already
+   *   set by then).
+   * - `resize` BEFORE `setDepthView`: `resize` skips the build bind-group step
+   *   (buffers exist but no view yet); `setDepthView` builds it on arrival.
+   * - Either path produces one build bind group — no double-creation.
+   *
+   * The renderer must call this on construction (`createRenderer`) and again
+   * on every canvas resize (after `CanvasContext.depthView` is refreshed by
+   * `resizeCanvas`). Because `buildBindGroup` is recreated on every `resize`,
+   * the depth view is refreshed in lockstep with the buffer allocation — no
+   * staleness as long as the renderer always passes the freshest `ctx.depthView`.
+   *
+   * @param view The `GPUTextureView` for the `depth24plus` texture created by
+   *   `createDepth` in `context.ts`. MUST be a single-sample depth view —
+   *   multisampled depth cannot be bound as `texture_depth_2d`.
+   */
+  setDepthView(view: GPUTextureView): void;
+  /**
+   * (Re)build the build-pass bind group from the current heads/slots/viewport
+   * buffers and the opaque depth view.
+   *
+   * **No-op guard:** returns immediately when `depthView` is not yet available.
+   * This preserves order-independence: `resize` (which calls this) can run
+   * before `setDepthView` without crashing. The caller (`setDepthView`) will
+   * build the group on arrival of the view. This means `buildBindGroup` may be
+   * temporarily uninitialized between a `resize` and the first `setDepthView`;
+   * the renderer must not issue build passes in that window.
+   */
+  private _buildBuildBindGroup;
+  /**
+   * Create a **build-style** A-buffer bind-group layout suitable for a pipeline
+   * that binds the A-buffer at `@group(group)`. The entries are identical to
+   * {@link buildLayout} (heads + slots `storage`, viewport `uniform`) — a
+   * `GPUBindGroupLayout` does not encode the group index, so the layout is the
+   * same regardless of `group`; the index is fixed by the layout's POSITION in
+   * the pipeline layout's `bindGroupLayouts` array.
+   *
+   * Use this for the glyph / sprite OIT emit pipelines, which keep their own
+   * texture/atlas at `@group(2)` and the A-buffer at `@group(3)`:
+   *
+   * ```ts
+   * const abLayout = abuffer.buildLayoutAt(3);
+   * device.createPipelineLayout({
+   *   bindGroupLayouts: [cameraLayout, instanceLayout, atlasLayout, abLayout],
+   * });
+   * // then: pass.setBindGroup(3, abuffer.buildBindGroupFor());
+   * ```
+   *
+   * Passing `group === 2` returns the existing {@link buildLayout} object (the
+   * shape build slot), so callers can share one layout instance there.
+   *
+   * @param group The `@group(n)` index this layout will occupy (only used to
+   *   pick the shared label / reuse the canonical `@group(2)` layout; the entry
+   *   list is invariant).
+   */
+  buildLayoutAt(group: number): GPUBindGroupLayout;
+  /**
+   * The build-pass bind group (`heads`/`slots`/`oitViewport`) for binding the
+   * A-buffer at ANY group index. A `GPUBindGroup` is index-agnostic — the same
+   * object can be `setBindGroup(2, ...)` on the shape build pipeline and
+   * `setBindGroup(3, ...)` on the glyph/sprite emit pipelines in the same pass,
+   * as long as the pipeline's layout slot was created from a layout with the
+   * matching entries ({@link buildLayoutAt}). It is re-created on every
+   * {@link resize}, so always read it fresh (do not cache across a resize).
+   *
+   * Returns the SAME object as {@link buildBindGroup}; this accessor exists to
+   * make the "reuse the one bind group at a different slot" contract explicit at
+   * the emit call sites (Phases 2/3).
+   */
+  buildBindGroupFor(): GPUBindGroup;
+  /**
+   * Reset the per-pixel insert counters to 0 at the start of every frame. Only
+   * `heads` is cleared — `slots` are write-once per build pass and the resolve
+   * pass reads only the first `min(count, K)` per pixel, so stale slot bytes are
+   * never observed. There is no global counter to reset.
+   */
+  clearFrame(encoder: GPUCommandEncoder): void;
+  /** Release all GPU buffers. The bind-group layouts are not GPU-owned memory. */
+  destroy(): void;
+}
+//#endregion
+//#region src/pipelines/oit-pipelines.d.ts
+/** The two OIT render pipelines plus the build pipeline's explicit layout. */
+interface OITPipelines {
+  /**
+   * Explicit pipeline layout for the build pass:
+   * `[cameraLayout, instanceLayout, abuffer.buildLayout]`. Exposed so the
+   * renderer can confirm its bind-group ordering matches.
+   */
+  buildLayout: GPUPipelineLayout;
+  /**
+   * Build pass: assembled vertex + `oitBuild` fragment. `writeMask:0` (color
+   * masked), `depthWriteEnabled:false` + `depthCompare:"less"` (test against
+   * opaque depth, never write), `triangle-strip` (matches the uber vertex
+   * quad layout), single-sample.
+   */
+  buildPipeline: GPURenderPipeline;
+  /**
+   * Resolve pass: full-screen `triangle-list` (3 verts), premultiplied over
+   * blend, NO depth attachment.
+   */
+  resolvePipeline: GPURenderPipeline;
+}
+/** Bind-group layouts the build pass shares with the main passes (groups 0/1). */
+interface OITPipelineDeps {
+  /** `@group(0)` camera uniform layout (from {@link createPipelines}). */
+  cameraLayout: GPUBindGroupLayout;
+  /** `@group(1)` instances storage layout (from {@link createPipelines}). */
+  instanceLayout: GPUBindGroupLayout;
+}
+/**
+ * Build the OIT build + resolve pipelines.
+ *
+ * @param device  WebGPU device.
+ * @param format  Swapchain texture format (color target for both passes).
+ * @param abuffer A-buffer resources — supplies `@group(2)` build layout and the
+ *   `@group(0)` resolve layout.
+ * @param shader  Assembled uber-shader (T12). `shader.vertex` is reused verbatim
+ *   for the build vertex stage; `shader.oitBuild` is the build fragment — neither
+ *   is re-authored here.
+ * @param deps    The camera + instance bind-group layouts shared with the main
+ *   opaque/transparent passes, so ONE camera / ONE instances bind group binds
+ *   against the build pass too.
+ */
+declare function createOITPipelines(device: GPUDevice, format: GPUTextureFormat, abuffer: ABuffer, shader: AssembledShader, deps: OITPipelineDeps): OITPipelines;
+//#endregion
+//#region src/damage/auto-damage.d.ts
+/**
+ * Per-layer snapshot of the previous auto frame, used to diff against the
+ * current pack and derive damage regions (P4-T3). Captured at the END of an
+ * auto frame while `pack.aabbs` is still valid (before the caller's next-frame
+ * `clear()`).
+ */
+interface Snapshot {
+  /** `UberPack.version` at capture time — a cheap "did anything repack?" gate. */
+  packVersion: number;
+  /** Shape-instance count (`pack.aabbs` valid range is `count * 4` floats). */
+  count: number;
+  /**
+   * COPY of the valid prefix of `pack.aabbs` (`count * 4` floats, 4 per
+   * instance: `minX, minY, maxX, maxY`). Copied — NOT a live reference — so the
+   * caller's next-frame repack does not mutate it under us.
+   */
+  aabbs: Float32Array;
+  /**
+   * Per-instance style hash — one `u32` per instance, computed by XOR-folding
+   * the 8 u32 words at float offsets 8–15 of each packed instance record
+   * (`colorBits, typeFlag, order, lane0-4`). A hash mismatch on an instance
+   * whose AABB is geometrically unchanged (old AABB == new AABB) still produces
+   * a damage rect at that AABB position, so pure style changes (color, opacity,
+   * z-order, kind-specific lanes) are correctly caught by auto-damage without
+   * requiring the caller to hand-track damage manually.
+   */
+  styleHashes: Uint32Array;
+  /** `GlyphPack.version` at capture, or `0` when the layer has no glyph pack. */
+  glyphVersion: number;
+  /** Glyph-instance count (`glyphPack?.count ?? 0`). */
+  glyphCount: number;
+  /**
+   * The glyph pack's cumulative layer-space content bbox at capture (`null`
+   * when no plain glyphs). On a glyph-version change the diff damages
+   * `old ∪ new` of this bbox instead of promoting the frame to full (D10
+   * revised) — valid only while `glyphUnbounded` is false on BOTH sides.
+   */
+  glyphBbox: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  } | null;
+  /**
+   * Whether the pack held anchored / screen-sized glyphs at capture. Their
+   * pixels are camera-projected, so `glyphBbox` cannot bound them — a glyph
+   * change on such a layer keeps the full `"auto-damage-glyphs"` promote.
+   */
+  glyphUnbounded: boolean;
+  /**
+   * COPY of the pack's per-push records at capture, or `null` when the pack
+   * overflowed `GLYPH_PUSH_RECORD_CAP`. With records on BOTH sides the glyph
+   * diff matches unchanged pushes (same text/position/layout → identical
+   * pixels) and damages only the changed ones — without them, one changed HUD
+   * string damages the union of every text block in the layer. Copied (not a
+   * live reference): a push WITHOUT an intervening `clear()` appends to the
+   * pack's live array and must not grow this retained view.
+   */
+  glyphRecords: readonly GlyphPushRecord[] | null;
+}
+/**
+ * Per-renderer auto-damage state: a `WeakMap` of the most recent {@link
+ * Snapshot} per live {@link Layer}. Lazily constructed by the renderer the
+ * first time a `damage: "auto"` frame runs (zero-cost when auto is never used).
+ *
+ * P4-T2 surface: `has` / `get` (the seed gate reads these) + `update` (capture
+ * at frame end). The diff is added in P4-T3.
+ */
+declare class AutoDamageState {
+  private readonly _snapshots;
+  /** Whether a snapshot exists for `layer` (false → this layer needs seeding). */
+  has(layer: Layer): boolean;
+  /** The retained snapshot for `layer`, or `undefined` if none. */
+  get(layer: Layer): Snapshot | undefined;
+  /**
+   * Capture / refresh the snapshot for `layer` from its CURRENT pack state.
+   * Called at the end of every auto frame (seed or partial) for every live
+   * layer, so next frame's diff has a fresh baseline.
+   */
+  update(layer: Layer): void;
+  /**
+   * Refresh snapshots for every layer in `layers`. Convenience for the
+   * frame-end seed/update loop in the renderer.
+   */
+  updateAll(layers: readonly Layer[]): void;
+}
+//#endregion
+//#region src/layers/buffer-layer.d.ts
+type BufferLayerKind = "instances";
+/** A `d.arrayOf` over the v3 uber `InstanceStruct` (16 f / 64 B). The element
+ * type is {@link INSTANCE_LAYOUT}'s `tgpuStruct` — the GPU-layout source of
+ * truth — so a kernel-written buffer (`writeRectInstance`) lines up field-for-
+ * field with the live uber concat. */
+type InstanceArray = d.WgslArray<typeof INSTANCE_LAYOUT.tgpuStruct>;
+/**
+ * Options for an instance {@link BufferLayer} (v3 64 B `InstanceStruct` external
+ * buffer — the "bring-your-own-GPU-buffer" seam).
+ *
+ * This buffer holds the v3 uber `InstanceStruct` (16 f / 64 B, `schema/instance.ts`)
+ * — the SAME record the live `render()` concat packs and the SAME one a compute
+ * kernel emits via `writeRectInstance`. The renderer draws it through the
+ * external-instance pipelines (`pipelines/instance-pipelines.ts`), which decode
+ * `typeFlag`/lanes with the live uber per-kind geometry + SDF. No texture
+ * (instances are SDF primitives, not textured quads).
+ *
+ * An instance buffer stacks ABOVE all live geometry + bakes by submission order
+ * (no z-interleave) and carries a constant per-buffer near-z — the accepted
+ * limitation of the retained/bake post-passes.
+ */
+interface BufferLayerInstancesOptions {
+  kind: "instances";
+  /**
+   * Storage buffer of v3 uber instances, typically
+   * `root.createBuffer(d.arrayOf(INSTANCE_LAYOUT.tgpuStruct, N)).$usage("storage")`.
+   * Each record is the 64 B `InstanceStruct` (`schema/instance.ts`).
+   */
+  buffer: TgpuBuffer<InstanceArray> & StorageFlag;
+  /** How many instances from the buffer to draw this frame. Mutable on the returned layer. */
+  count: number;
+  /** Optional transform group applied to all instances in this buffer. */
+  group?: Group;
+  /** Coordinate space. Default: `"world"`. */
+  space?: LayerSpace;
+  /** CSS-pixel crop rectangle applied as a scissor on the GPU backend. */
+  clipRect?: FrameRect;
+  /**
+   * When `true`, routes into the opaque (depth-write) pass. Caller must guarantee
+   * every instance is fully opaque (`fill.a === 1`, `stroke.a === 1`). Default `false`.
+   */
+  opaque?: boolean;
+}
+type BufferLayerOptions = BufferLayerInstancesOptions;
+/**
+ * A drawable whose data lives entirely in a GPU buffer (no CPU `UberPack`).
+ * Use this to render output from a compute pass without a CPU round-trip.
+ *
+ * Holds `instances` (v3 uber 64 B `InstanceStruct`, decoded by the live uber
+ * per-kind geometry/SDF). See `schema/instance.ts` + `writeRectInstance` for the
+ * field encoding.
+ */
+declare class BufferLayer {
+  readonly kind: BufferLayerKind;
+  readonly space: LayerSpace;
+  readonly group: Group | null;
+  /** @internal */
+  readonly _buffer: TgpuBuffer<InstanceArray> & StorageFlag;
+  /** Number of items drawn this frame. Mutate freely between frames. */
+  count: number;
+  /** CSS-pixel crop rectangle. Mutable — renderer reads it at submit time. */
+  clipRect: FrameRect | undefined;
+  /** See option doc. Mutable. */
+  opaque: boolean;
+  /**
+   * Monotonic content version. The renderer folds `version` (with `count` and
+   * buffer identity) into its partial-redraw view fingerprint, so a change here
+   * demotes the next frame to a full (loadOp:"clear") repaint automatically.
+   *
+   * CALLER CONTRACT: a BufferLayer's GPU bytes change OUT-OF-BAND from the camera
+   * (a compute pass writes them), and the renderer cannot introspect buffer
+   * contents. So EVERY time a compute pass mutates the buffer this layer draws,
+   * the caller MUST {@link bumpVersion} (or set `version` directly). Forget to,
+   * and a damage frame will ghost (stale pixels outside the damage rects). Use
+   * {@link bumpVersion} from the same place you `compute(...)`.
+   */
+  version: number;
+  /**
+   * Treat this buffer's bounds as an occluder. Default `false`. Requires the
+   * caller to pass `occluderAabb` when enabling.
+   */
+  occluder: boolean;
+  /**
+   * World-space bounding box used when `occluder` is true. Caller supplies
+   * since the renderer cannot introspect buffer contents.
+   */
+  occluderAabb: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+  } | null;
+  constructor(options: BufferLayerOptions);
+  setClipRect(rect: FrameRect | undefined): this;
+  /**
+   * Set the draw count for the next frame AND bump {@link version} so the
+   * partial-redraw fingerprint observes the change. Convenience for the common
+   * "compute wrote N items this frame" path — equivalent to assigning `count`
+   * then calling {@link bumpVersion}.
+   */
+  setCount(count: number): this;
+  /**
+   * Bump {@link version} to signal the buffer's GPU contents changed. Call this
+   * from wherever you record the `compute(...)` pass that wrote the buffer, so
+   * the next `render()` repaints in full instead of ghosting on a damage frame.
+   */
+  bumpVersion(): this;
+}
+declare function createBufferLayer(options: BufferLayerOptions): BufferLayer;
+//#endregion
+//#region src/layers/custom-drawable.d.ts
+/**
+ * Context provided to {@link CustomDrawable.record} on every frame.
+ *
+ * The encoder is in the middle of a render pass — do NOT begin or end passes.
+ * The scissor rect (if any) is applied by the renderer before the call.
+ */
+interface CustomDrawableContext {
+  /** The active GPU device. */
+  device: GPUDevice;
+  /** The command encoder for the current frame. */
+  encoder: GPUCommandEncoder;
+  /**
+   * The scissor rect the renderer has applied (device pixels), or `null` when
+   * rendering full-viewport. Informational only — the renderer has already set
+   * the scissor on the pass.
+   */
+  scissor: FrameRect | null;
+  /** The coordinate space this drawable was created with. */
+  space: LayerSpace;
+  /**
+   * The renderer's shared per-frame camera bind group resolved for this
+   * drawable's `space`. Bind at `@group(0)`. The renderer supplies it via ctx
+   * (drawables must not fetch it themselves).
+   */
+  cameraBindGroup: GPUBindGroup;
+}
+/**
+ * A raw render-pass hook. Implement this to bring custom pipelines, bind
+ * groups, and draw calls into the renderer's frame. The renderer hands the
+ * pass encoder directly to `record`; the drawable issues its own GPU commands.
+ *
+ * Unlike v1 `CustomDrawable`:
+ *   - Any `space` is allowed (`"world"`, `"ui"`).
+ *   - Any tier is supported (opaque or transparent).
+ *   - Optional `clipRect` is supported — the renderer applies it as a scissor
+ *     before calling `record`.
+ */
+interface CustomDrawable {
+  /** Brand tag — used by `isCustomDrawable` runtime checks. */
+  readonly __customDrawable: true;
+  /** Coordinate space this drawable occupies. */
+  readonly space: LayerSpace;
+  /**
+   * Optional scissor rect (device pixels). The renderer applies this before
+   * invoking `record`. `undefined` = full viewport.
+   */
+  readonly clipRect: FrameRect | undefined;
+  /**
+   * When `true`, this drawable's output is fully opaque — the renderer may
+   * route it into the opaque pass (depth writes on). Default: `false`.
+   */
+  readonly opaque: boolean;
+  /**
+   * Called once per frame. `pass` is an active `GPURenderPassEncoder` — record
+   * pipelines, bind groups, and draw calls here. Do NOT begin or end the pass.
+   *
+   * @param pass   The active render pass encoder.
+   * @param ctx    Frame context (device, encoder, applied scissor, space).
+   */
+  record(pass: GPURenderPassEncoder, ctx: CustomDrawableContext): void;
+  /** Optional cleanup. The renderer does not manage the drawable's lifetime. */
+  destroy?(): void;
+}
+/** True when `node` is a `CustomDrawable` (brand-tag check). */
+declare function isCustomDrawable(node: unknown): node is CustomDrawable;
+interface CustomDrawableOptions {
+  /** Optional scissor rect (device pixels). Default: `undefined`. */
+  clipRect?: FrameRect;
+  /**
+   * When `true`, declares this drawable fully opaque. Default: `false`.
+   */
+  opaque?: boolean;
+  /** Optional cleanup callback invoked by {@link CustomDrawable.destroy}. */
+  onDestroy?: () => void;
+}
+/**
+ * Create a `CustomDrawable` from a `record` callback. Any `LayerSpace` is
+ * accepted; `clipRect` and `opaque` are optional.
+ *
+ * @param space   Coordinate space the drawable occupies.
+ * @param record  Called once per frame with the active render pass encoder.
+ * @param options Clip rect, opaque flag, and destroy hook.
+ */
+declare function createCustomDrawable(space: LayerSpace, record: (pass: GPURenderPassEncoder, ctx: CustomDrawableContext) => void, options?: CustomDrawableOptions): CustomDrawable;
+//#endregion
+//#region src/scene/renderer-registry.d.ts
+/**
+ * The {@link Renderer2D} most recently constructed against `canvas`, or
+ * `undefined` if none is registered. Debug/tooling lookup only (last-constructed
+ * wins — see the WeakMap above); not a general renderer registry.
+ */
+declare function rendererForCanvas(canvas: HTMLCanvasElement): Renderer2D | undefined;
+type RendererCreatedListener = (renderer: Renderer2D) => void;
+/** Record a newly-constructed renderer and notify subscribers. */
+/**
+ * Subscribe to renderer construction. The callback fires immediately for every
+ * still-live renderer, then again for each future construction. Returns an
+ * unsubscribe function. No strong renderer references are held in module scope
+ * (live renderers are tracked via pruned `WeakRef`s — D9), so subscribing does
+ * not keep a renderer alive.
+ */
+declare function onRendererCreated(cb: RendererCreatedListener): () => void;
+//#endregion
+//#region src/scene/view-fingerprint.d.ts
+/** Renderer-state snapshot for one `compute()` call. */
+interface FingerprintParams {
+  camera: {
+    x: number;
+    y: number;
+    zoom: number;
+    rotation: number;
+  };
+  ctxWidth: number;
+  ctxHeight: number;
+  dpr: number;
+  background: Color;
+  emphasisMirror: {
+    focusedKey: number;
+    dimAlpha: number;
+    t: number;
+  };
+  viewKey?: string;
+  bufferLayers?: readonly BufferLayer[] | null;
+  zOrderKey?: string;
+  visibilityKey?: string;
+  /** When capturing: a fresh `{}` the callee fills with per-part substrings. */
+  outParts?: Record<FingerprintPart, string>;
+}
+//#endregion
+//#region src/renderer-frame.d.ts
+/**
+ * Narrow read/delegation surface `Renderer2D` exposes to the frame spine. Every
+ * member here is a handle the phases READ or a method that delegates to an
+ * already-extracted collaborator (`tiers/encode.ts`, the camera/instance/bake/
+ * glyph/sprite/interop managers) — the phases never reach past this interface
+ * into renderer privates, and `Renderer2D` remains the sole owner of GPU
+ * lifetime + the public API.
+ *
+ * @internal
+ */
+interface FrameHost {
+  readonly frameRoot: {
+    device: GPUDevice;
+  };
+  readonly frameCtx: {
+    width: number;
+    height: number;
+    persistent: boolean;
+    backbufferView: GPUTextureView | null;
+    backbuffer: GPUTexture | null;
+    depthView: GPUTextureView;
+    gpuContext: GPUCanvasContext;
+    canvas: {
+      clientWidth?: number;
+      clientHeight?: number;
+    };
+  };
+  readonly frameConfig: {
+    readonly oit: boolean;
+    readonly partialRedraw: boolean;
+    readonly cull: boolean;
+    readonly onFrameTiming?: (t: ReturnType<typeof frameTiming>) => void;
+    readonly onGpuFrameTiming?: (ms: number) => void;
+  };
+  readonly frameAbuffer: {
+    clearFrame(encoder: GPUCommandEncoder): void;
+  } | null;
+  readonly frameOitPipelines: {
+    resolvePipeline: GPURenderPipeline;
+  } | null;
+  readonly frameUseOit: boolean;
+  readonly frameCamera: {
+    x: number;
+    y: number;
+    zoom: number;
+    rotation: number;
+  };
+  readonly frameDpr: number;
+  readonly frameBackground: Color;
+  readonly frameEmphasisMirror: {
+    focusedKey: number;
+    dimAlpha: number;
+    t: number;
+  };
+  readonly frameRetainedFarBand: boolean;
+  readonly frameCapturing: boolean;
+  readonly cameraUniformData: Float32Array;
+  cameraUniformSlotStrideFloats(): number;
+  readonly cameraUniformSlotStride: number;
+  cameraUniformBuffer(): GPUBuffer;
+  ensureCameraSlots(count: number): void;
+  ensureStaging(floats: number): void;
+  stagingArray(): Float32Array;
+  ensureCullAabbs(instances: number): Float32Array;
+  ensureInstanceCapacity(bytes: number): void;
+  instanceBuffer(): GPUBuffer;
+  hasBakes(): boolean;
+  hasRetained(): boolean;
+  bakeFor(pack: object): BakeRecord | undefined;
+  retainedFor(pack: object): RetainedRecord | undefined;
+  bakeCacheApplyCachePolicy(layers: readonly Layer[]): void;
+  bakeCacheClearDemotions(): void;
+  bakeCacheRecordDemotion(space: LayerSpace): void;
+  readonly cullStats: {
+    instancesTotal: number;
+    instancesDrawn: number;
+    instancesCulled: number;
+    commandsTotal: number;
+    drawRanges: number;
+    culled: boolean;
+  };
+  stampHeterogeneousOrder(ranges: readonly {
+    layer: Layer;
+    packBase: number;
+    instInPack: number;
+  }[], n: number, retainedPresent: boolean): void;
+  glyphUploadInstances(layers: readonly Layer[], sig: string, device: GPUDevice): {
+    glyphDraws: GlyphDraw[];
+  };
+  glyphPackId(pack: object): number;
+  uploadLayerSprites(layers: readonly Layer[]): number[];
+  encodeFull(pass: GPURenderPassEncoder, cmds: readonly RebasedCommand[], retained: readonly RetainedRecord[], useOit: boolean, bakedBelow: readonly BakeRecord[], phase?: "all" | "opaque" | "transparent"): number;
+  encodePartial(pass: GPURenderPassEncoder, cmds: readonly RebasedCommand[], retained: readonly RetainedRecord[], regions: readonly FrameRect[], clearValue: {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+  }, useOit: boolean, bakedBelow: readonly BakeRecord[], phase?: "all" | "opaque" | "transparent"): number;
+  encodeExempt(pass: GPURenderPassEncoder, cmds: readonly RebasedCommand[] | null, glyphDraws: readonly GlyphDraw[] | null, base: FrameRect | null): number;
+  encodeGlyphs(pass: GPURenderPassEncoder, draws: readonly GlyphDraw[]): number;
+  encodeGlyphsOitEmit(pass: GPURenderPassEncoder, draws: readonly GlyphDraw[]): number;
+  encodeSpritesOitEmit(pass: GPURenderPassEncoder, layers: readonly Layer[], bases: readonly number[]): number;
+  encodeLayerSprites(pass: GPURenderPassEncoder, layers: readonly Layer[], bases: readonly number[], oitOpaqueOnly: boolean): number;
+  encodeBufferLayer(pass: GPURenderPassEncoder, bl: BufferLayer): number;
+  frameApplyScissor(pass: GPURenderPassEncoder, rect: FrameRect | null): void;
+  cameraBindGroupForSpace(space: LayerSpace): GPUBindGroup;
+  compositePipeline(): {
+    pipeline: GPURenderPipeline;
+  } | null;
+  abufferHandle(): {
+    resolveBindGroup: GPUBindGroup;
+  } | null;
+  frameAutoDamage(): AutoDamageState | null;
+  setFrameAutoDamage(state: AutoDamageState): void;
+  setAutoFullReason(reason: string | null): void;
+  setAutoUpdateLayers(layers: readonly Layer[] | null): void;
+  clearFrameProvenance(): void;
+  noteAutoProvenance(perLayer: unknown): void;
+  fingerprintDecide(args: {
+    params: FingerprintParams;
+    hasDamageRegions: boolean;
+    fullFrame: boolean;
+    capturing: boolean;
+  }): {
+    viewChanged: boolean;
+    forcedReason: string | null;
+    changedParts: FingerprintPart[] | undefined;
+    visibilityChanged: boolean;
+    partial: boolean;
+  };
+  resolveGpuTimer(): {
+    timestampWrites: GPURenderPassTimestampWrites | undefined;
+    resolve(encoder: GPUCommandEncoder): {
+      read(): Promise<bigint>;
+    } | null;
+  } | null;
+  drainPendingCompute(encoder: GPUCommandEncoder): void;
+  refreshAutoSnapshots(): void;
+  emitFrameDebug(facts: FrameDebugLite): void;
+}
+/**
+ * The {@link FrameDebugFacts} fields the spine knows — everything EXCEPT
+ * `autoFullReason` and `autoProvenance`, which the renderer fills from its own
+ * state inside `emitFrameDebug` (they live in `_autoFullReason` /
+ * `_debugRetention.autoProvenance`, host-owned). Built only while capturing.
+ *
+ * @internal
+ */
+interface FrameDebugLite {
+  partial: boolean;
+  damageRegions: readonly FrameRect[] | null;
+  allDrawLayers: readonly Layer[];
+  layers: readonly (Layer | BufferLayer | CustomDrawable)[];
+  bakedBelow: readonly BakeRecord[];
+  bakedAbove: readonly BakeRecord[];
+  forcedReason: string | null;
+  viewChanged: boolean;
+  changedParts: FingerprintPart[] | undefined;
+  visibilityChanged: boolean;
+  demoteReason: string | null;
+  autoDerived: boolean;
+  fullFrameOpt: boolean;
+  annotation: {
+    reason?: string;
+    data?: Record<string, unknown>;
+  } | undefined;
+  totalMs: number;
+  uploadMs: number;
+  encodeMs: number;
+  drawCalls: number;
+  damageRects: number;
+}
+//#endregion
+//#region src/renderer.d.ts
+/** Per-frame options. Shaped like v1's `render(layers, { … })`. Supplying
+ * `regions` on a persistent renderer whose composite view is unchanged since
+ * the last frame activates the partial (damage-tracked) redraw path; `viewKey`
+ * lets the caller fold its own group transforms + data-domain state into the
+ * composite fingerprint (see {@link Renderer2D.viewFingerprint}). */
+interface RenderOptions {
+  /**
+   * Damage rects to repaint, in CSS pixels (`Bounds2D = {minX,minY,maxX,maxY}`).
+   * On a persistent frame with an unchanged view these activate the partial
+   * (damage-tracked) redraw path; otherwise they are ignored and a full repaint
+   * runs. An empty / absent list always means a full frame.
+   */
+  regions?: readonly Bounds2D[];
+  /** Force a full repaint this frame even if `regions` are supplied. */
+  fullFrame?: boolean;
+  /**
+   * Ask core to DERIVE the damage regions itself instead of the caller passing
+   * `regions` (decision D5). When `"auto"`, the renderer retains a per-layer
+   * snapshot of the previous auto frame (pack version + instance count + a copy
+   * of the per-instance world AABBs) and diffs it against the current pack to
+   * project the small `old ∪ new` rects of whatever moved (P4-T3). The interact
+   * demo's hand-rolled damage source is replaced by this.
+   *
+   * Precedence (D5): `fullFrame: true` > explicit `regions` > `damage: "auto"` >
+   * default full. So `damage: "auto"` is consulted ONLY when no explicit
+   * `regions` are supplied. The FIRST auto frame (or any frame with a layer
+   * lacking a snapshot) is a full repaint that SEEDS the snapshots
+   * (`fullCause.reason === "auto-damage-seed"`). A frame whose union damage
+   * exceeds 60% of the canvas promotes to full (`"auto-damage-area"`); a layer
+   * whose glyph version changed promotes to full (`"auto-damage-glyphs"`, D10 —
+   * glyph packs carry no per-glyph AABBs to diff). Otherwise the derived rects
+   * scissor a partial frame.
+   */
+  damage?: "auto";
+  /**
+   * Caller-supplied extension of the composite view fingerprint. The renderer
+   * draws flat `UberPack`s and cannot see the scene's `Group` transforms or a
+   * plot's data domain, so the caller (scene layer / plot / phylo) passes a
+   * string that changes whenever ANY active group transform or data domain
+   * changes. Folding it into the fingerprint fixes the old group-omission
+   * footgun (groups silently excluded, forcing manual `forceFullFrame()`):
+   * here a group move flips the fingerprint and forces a full frame
+   * automatically.
+   */
+  viewKey?: string;
+  /**
+   * Optional caller-supplied annotation (decision D7) — the caller's INTENT for
+   * this frame shown next to core's own decision in `FrameDebug.annotation`.
+   * `reason` is a free-form tag (e.g. `"hover-moved"`, `"pan"`); `data` is
+   * freeform extras. READ ONLY while the debug probe is capturing — the option
+   * is never touched on the zero-cost path (the property access itself is guarded,
+   * D8). Has no effect on rendering.
+   */
+  debug?: {
+    reason?: string;
+    data?: Record<string, unknown>;
+  };
+}
+/** Construction-time options for {@link Renderer2D}. */
+interface RendererConstructorOptions {
+  /** Partial config overriding {@link DEFAULT_CONFIG}. */
+  config?: Partial<RendererConfig>;
+  /**
+   * The three render pipelines + shared bind-group layouts, created by the
+   * caller via `createPipelines(root, format, assembleShader(...))`.
+   * Dependency-injected so the renderer is unit-testable without a GPU.
+   */
+  pipelines: Pipelines;
+  /** Initial camera state. Default `{ x: 0, y: 0, zoom: 1, rotation: 0 }`. */
+  camera?: CameraState;
+  /**
+   * Initial clear color. Legacy side-channel: folded into config as
+   * `initialBackground` at construction (it OVERRIDES `config.initialBackground`
+   * when supplied). Prefer `config.initialBackground`. Default fully transparent.
+   * Mutate the live value via {@link Renderer2D.setBackground}.
+   */
+  background?: Color;
+  /**
+   * Device-pixel ratio used to map CSS-pixel damage rects → device-pixel scissor
+   * rects (the canvas backing store / backbuffer is in device pixels). Default
+   * `1`. Also folded into the view fingerprint so a DPR change forces a full
+   * frame. Legacy side-channel: folded into config as `initialDpr` at
+   * construction (OVERRIDES `config.initialDpr` when supplied). Prefer
+   * `config.initialDpr`. Update the live value via {@link Renderer2D.setDpr}.
+   */
+  dpr?: number;
+  /**
+   * Order-independent-transparency resources. **Required** when `config.oit` is
+   * `true` (the {@link DEFAULT_CONFIG} default): the renderer never compiles
+   * WGSL itself (cf. {@link pipelines}), so the per-pixel A-buffer and the
+   * build/resolve pipelines are dependency-injected exactly like
+   * {@link Pipelines}. Construct both with
+   * `new ABuffer(device, { fragmentsPerPixel: config.oitFragmentsPerPixel })`
+   * and `createOITPipelines(device, format, abuffer, shader, { cameraLayout,
+   * instanceLayout })` (the OIT build layout is `[cameraLayout, instanceLayout,
+   * abuffer.buildLayout]`, so the A-buffer must exist before the pipelines).
+   * Ignored when `config.oit` is `false`; the renderer then routes transparent
+   * commands through the sorted alpha-blend {@link Pipelines.transparent} pass.
+   */
+  oit?: {
+    /** Per-pixel bounded-K A-buffer (heads + slots + viewport uniform). */abuffer: ABuffer; /** Build + resolve pipelines bound against the A-buffer + shared layouts. */
+    pipelines: OITPipelines;
+  };
+  /**
+   * The assembled uber-shader these pipelines were built from. OPTIONAL for the
+   * core render path (the renderer never compiles WGSL), but REQUIRED to use
+   * {@link Renderer2D.cacheLayer}: the RTT bake builds its own MSAA shape
+   * pipelines from this same source (`createBakePipelines`). When omitted,
+   * `cacheLayer` throws. {@link createRenderer} always supplies it.
+   */
+  shader?: AssembledShader;
+  /**
+   * Color-target format the pipelines were built against (the canvas format).
+   * Used by {@link Renderer2D.cacheLayer} to build the bake + composite
+   * pipelines at the same format. Legacy side-channel: folded into config as
+   * `colorFormat` at construction (OVERRIDES `config.colorFormat` when
+   * supplied). CONSTRAINED — must match the injected pipelines + swap chain
+   * (HARD boundary 3). Prefer `config.colorFormat`. Defaults to
+   * `navigator.gpu.getPreferredCanvasFormat()`.
+   */
+  format?: GPUTextureFormat;
+  /**
+   * Diagnostic logger for library output (warnings, GPU errors). Installed
+   * process-wide via {@link setLogger} when supplied so the diagnostic sites in
+   * unrelated modules pick it up too. Defaults to `console`.
+   */
+  logger?: Logger;
+}
+/**
+ * Per-frame frustum-cull statistics for the LAST {@link Renderer2D.render} call,
+ * read off the decoupled cull stage (`cull.ts`). Counts are over the DYNAMIC
+ * concat instance buffer
+ * only (the path the cull stage narrows); retained / baked / glyph draws live
+ * outside the concat and are not counted here.
+ *
+ * When `config.cull` is `false`, `culled` is `false`, `instancesCulled` is `0`,
+ * and `instancesDrawn === instancesTotal` (every command issues a full-span
+ * draw). `drawRanges` reflects the number of split draws the cull emitted —
+ * with cull off it equals `commandsTotal`.
+ */
+interface CullStats {
+  /** Total dynamic-concat instances considered this frame (before cull). */
+  instancesTotal: number;
+  /** Instances whose command survived the frustum cull (issued to draw). */
+  instancesDrawn: number;
+  /** Instances dropped by the frustum cull (`instancesTotal − instancesDrawn`). */
+  instancesCulled: number;
+  /** Draw commands gathered before cull narrowing. */
+  commandsTotal: number;
+  /** Draw ranges issued after cull narrowing (split draws against the concat). */
+  drawRanges: number;
+  /** Whether the frustum-cull stage actually ran this frame (`config.cull`). */
+  culled: boolean;
+}
+declare class Renderer2D implements FrameHost {
+  private readonly root;
+  private readonly ctx;
+  private readonly config;
+  private readonly pipelines;
+  private readonly abuffer;
+  private readonly oitPipelines;
+  private readonly _useOit;
+  private readonly _cameraUniform;
+  private readonly _instanceStaging;
+  private readonly clearColorBuffer;
+  private readonly clearColorData;
+  private clearColorBindGroup;
+  private readonly _emphasisBytes;
+  private readonly _emphasisU32;
+  private readonly _emphasisF32;
+  private _debug;
+  private _gpuTimer;
+  private _emphasisMirror;
+  private readonly _debugRetention;
+  private _camera;
+  private _background;
+  /** CSS→device pixel scale for scissor mapping; folded into the fingerprint. */
+  private _dpr;
+  private readonly _fingerprint;
+  private _autoDamage;
+  private _autoUpdateLayers;
+  private _autoFullReason;
+  private _pendingCompute;
+  private readonly _shader;
+  private readonly _format;
+  private readonly _bakeCache;
+  private readonly _retainedLayers;
+  private readonly _lastCullStats;
+  private get _compositePipelines();
+  /** Exposed for tests that inspect r["_bakes"] directly. Delegates to BakeCache. */
+  private get _bakes();
+  private readonly _interopEncoder;
+  private readonly _spriteEncoder;
+  private readonly _glyphEncoder;
+  constructor(owner: GPUOwner, canvas: HTMLCanvasElement, options: RendererConstructorOptions);
+  get width(): number;
+  get height(): number;
+  /**
+   * The canvas this renderer draws into. Exposed so tooling holding only a
+   * renderer (e.g. via {@link onRendererCreated}) can anchor DOM overlays.
+   */
+  get canvas(): HTMLCanvasElement;
+  /**
+   * Read-only snapshot of the live A-buffer (OIT) configuration, or `null` when
+   * `config.oit` is `false` (the sorted alpha-blend fallback). Side-effect free —
+   * reads already-resident state for tooling (e.g. `insomni-devtools`). The
+   * fields are STATIC config + the current slots-buffer allocation; this does NOT
+   * touch the GPU or read back per-pixel occupancy.
+   *
+   *   - `K`           — `config.oitFragmentsPerPixel` (per-pixel fragment budget).
+   *   - `maxK`        — {@link RESOLVE_MAX_K} compile-time resolve cap.
+   *   - `slotsBytes`  — current slots-buffer size (`width*height*K*SLOT_BYTES`),
+   *     reflecting the live backbuffer extent.
+   */
+  get oitInfo(): {
+    enabled: true;
+    K: number;
+    maxK: number;
+    slotsBytes: number;
+  } | null;
+  resize(w: number, h: number): void;
+  setCamera(state: CameraState): void;
+  setBackground(color: Color): void;
+  /** Set the CSS→device pixel ratio used for scissor mapping and the fingerprint. */
+  setDpr(dpr: number): void;
+  /**
+   * Set the global-emphasis state (Phase 4, decisions.md D2). Instances whose
+   * `lane4` emphasis key equals `focusedKey` render at full alpha; every other
+   * (`transparent` / OIT) instance is multiplied by `mix(1, dimAlpha, t)`.
+   *
+   * EXEMPT-ZERO (T-ZBAKE companion change): an instance with key `0` (the default
+   * `UberPack.append` writes — i.e. anything that never opted into emphasis, such
+   * as axis / grid / overlay shapes) is NEVER dimmed, regardless of `t`. Only
+   * instances tagged with a key ≥ 1 participate. So `focusedKey: 0` does NOT focus
+   * the default instances — key 0 is the opt-out sentinel, not a focus target;
+   * `focusedKey: 0, t: 1` dims every TAGGED instance and focuses none.
+   *
+   * This writes ONLY the 16-byte emphasis uniform — no instance repack — so
+   * animating `t` from 0→1 is a one-`writeBuffer` per frame. `t === 0` (the
+   * default, and the `dimAlpha` default of `1`) is an exact no-op.
+   *
+   * The opaque pass and text are intentionally NOT dimmed: dimming reduces alpha
+   * (a transparent effect), and the opaque pass's `a < 0.5` discard would punch
+   * holes. Emphasis-dimmable marks must therefore render in the transparent/OIT
+   * path (the same path plot's hover-dim already uses).
+   *
+   * Does NOT itself trigger a redraw — the caller renders after updating
+   * emphasis. Partial-redraw note (P4-T1, D6): emphasis is global GPU state the
+   * per-instance damage diff cannot observe, so it is folded into the view
+   * fingerprint (`viewFingerprint`) — a `setEmphasis` change between frames flips
+   * the fingerprint and forces the next frame full (`changed: ["emphasis"]`),
+   * which is what makes `damage:"auto"` sound without caller cooperation. A
+   * caller that already passes its own `regions` covering every dimmed/focused
+   * instance still works (its frame is just promoted to full); hand-gating
+   * full-frames-while-animating becomes redundant, not broken.
+   */
+  setEmphasis(state: {
+    focusedKey?: number;
+    dimAlpha?: number;
+    t?: number;
+  }): void;
+  /**
+   * Project the union of `layer`'s instances at `indices` into a single padded
+   * CSS-px damage region (Phase 4, P4-T2) — feed it to `render({ regions })` to
+   * repaint exactly the changed marks (a focused-point halo, a bring-to-front,
+   * an emphasis dim/undim). Uses the layer's live space view-projection (the
+   * SAME `viewProjectionForSpace` the draw uses), so the rect tracks the current
+   * camera/zoom/rotation. Returns `null` when no in-range index contributes
+   * (nothing to repaint). For several far-apart clusters, call once per cluster.
+   */
+  regionsFromLayerAabbs(layer: Layer, indices: Iterable<number>, pad?: number): Bounds2D | null;
+  /**
+   * Stateless opt-in DPR probe (HARD boundary 4). Returns the host's
+   * `window.devicePixelRatio` (or `1` when `window` is absent — SSR / Node /
+   * worker). The renderer NEVER calls this itself: the APP reads it and applies
+   * the result via {@link setDpr}, so device-pixel-ratio policy stays the app's
+   * decision and the renderer has no hidden `window` dependency. `static`
+   * because it reads no instance state.
+   * @param maxDpr Optional cap. Recommended: `Math.min(detectDpr(), 2)` on mobile
+   *   (fragment cost scales as DPR²). Pass this result to {@link setDpr}.
+   */
+  static detectDpr(): number;
+  /**
+   * Force the next `render()` to a full (loadOp:"clear") repaint, ignoring any
+   * damage `regions`. The composite fingerprint already covers camera, group
+   * transforms (via `viewKey`), dpr, size, and background; call this only for a
+   * backbuffer-content change the fingerprint can't observe (e.g. an external
+   * blit into the backbuffer, or a forced first frame).
+   */
+  forceFullFrame(): void;
+  /**
+   * Record a one-shot full-frame override AND its kebab-case `reason` (for
+   * `FrameDebug.fullReason`). Delegates to {@link ViewFingerprint.forceFull}.
+   */
+  private _forceFull;
+  /**
+   * The core-owned render-debug probe (decision D1) — the single source of truth
+   * for render-debug data. Lazily constructed on first access; constructing it
+   * does NOT enable capture (zero-cost-off, D8) — a presenter calls
+   * `renderer.debug.enable()` / `onFrame(...)` to start capturing. Replaces the v1
+   * public `setFrameDebug` / `config.onFrameDebug` (deleted).
+   */
+  get debug(): RendererDebug;
+  /**
+   * Whether the probe exists AND is capturing this frame. The single zero-cost-off
+   * gate read once per `render()`: with no probe (or an idle one) the renderer
+   * builds no FrameDebug record, retains no layer array / fingerprint parts, and
+   * reads no `cssBox` from the DOM.
+   */
+  private get _capturing();
+  /**
+   * Release the per-frame debug retention — the caller layer array, SpaceMap,
+   * AND the prev-frame fingerprint parts. Called by the probe when it stops
+   * capturing (disable / last listener removed) so no scene graph or part
+   * record is held while nothing is watching (the zero-cost invariant).
+   * Delegates layer/SpaceMap/autoProvenance release to {@link DebugRetention}.
+   */
+  private releaseDebugRetention;
+  /**
+   * Build the narrow {@link DebugHost} the probe drives. All methods are invoked
+   * by the probe ONLY while capturing; keeping them in a closure avoids exposing
+   * renderer internals on the public surface.
+   */
+  private _debugHost;
+  /**
+   * Queue a compute callback for the next {@link render}. The callback receives
+   * the frame's `GPUCommandEncoder`; open one or more `beginComputePass()` on it
+   * and dispatch. Callbacks run in submission order, immediately before the
+   * render pass (and after the OIT heads-clear), so their outputs are visible to
+   * any draw in the same frame — including a {@link BufferLayer} reading a buffer
+   * the compute pass just wrote.
+   *
+   * The caller owns its compute pipelines, bind groups, ping-pong, and dispatch
+   * order. This is the v3 equivalent of v1's `compute(encoder => …)`, minus the
+   * eager submit: nothing is dispatched until {@link render} is called (which
+   * drains the queue). Mirrors `clearFrame` in being recorded onto the frame
+   * encoder before `beginRenderPass` — a `beginComputePass` inside a render pass
+   * is illegal, so this hook is the supported place for it.
+   *
+   * IMPORTANT (partial-redraw contract): a compute pass that mutates a buffer a
+   * {@link BufferLayer} draws MUST bump that layer's `version` (or the renderer
+   * cannot tell the GPU bytes changed and a damage frame will ghost). See
+   * {@link BufferLayer.version}.
+   */
+  compute(cb: (encoder: GPUCommandEncoder) => void): void;
+  /**
+   * The `@group(0)` camera bind-group layout (the 6-float `Camera { vpCol0,
+   * vpCol1, vpCol2 }` uniform, visible to the vertex stage). Exposed so a
+   * consumer that builds its OWN camera-bound draw (a `CustomDrawable`, a
+   * particle pipeline) can bind against the renderer's live per-space camera
+   * slots without re-deriving the layout. Pair with {@link cameraBindGroupForSpace}
+   * to get the matching bind group for a coordinate space.
+   */
+  getCameraBindGroupLayout(): GPUBindGroupLayout;
+  /** The active GPU device. Exposed so a `CustomDrawable` can build pipelines. */
+  get device(): GPUDevice;
+  /** The renderer's color attachment format — a custom pipeline's target format. */
+  get colorFormat(): GPUTextureFormat;
+  /**
+   * The camera bind group for a coordinate `space` — bound against
+   * {@link getCameraBindGroupLayout} over the renderer's shared per-frame camera
+   * buffer at that space's slot. A pan/zoom rewrites only the camera buffer, so
+   * this bind group is stable across frames; a caller-built draw binds it at
+   * `@group(0)`.
+   */
+  cameraBindGroupForSpace(space: LayerSpace): GPUBindGroup;
+  /** Current resolved camera state (live `_camera`, fully defaulted). */
+  getCamera(): {
+    x: number;
+    y: number;
+    zoom: number;
+    rotation: number;
+  };
+  /**
+   * World→screen view matrix for the live camera (CSS-pixel screen space), via
+   * the shared `worldToCssMatrix`. The world camera baseline is CSS px (zoom=1 ⇒
+   * 1 world unit = 1 CSS px), so this builds `viewFromCamera` over the CSS-px
+   * viewport (`ctx.width/height ÷ dpr`) — independent of dpr in its output. This
+   * is the `world`-space VIEW (camera) matrix, NOT the full NDC view-projection;
+   * `screenToWorld` / `worldToScreen` invert / apply it. (For the NDC matrix a
+   * draw uploads, see `viewProjectionForSpace`.)
+   */
+  getViewMatrix(): Mat3;
+  /**
+   * Map a CSS-pixel screen point to world coordinates (inverse of the live
+   * world-space view matrix). Returns the input unchanged if the view matrix is
+   * singular (zoom 0) — matching v1's `screenToWorld` fallback.
+   */
+  screenToWorld(sx: number, sy: number): Vec2;
+  /** Map a world point to its CSS-pixel screen position (forward view matrix). */
+  worldToScreen(wx: number, wy: number): Vec2;
+  /**
+   * Set the live camera so `bounds` fits the viewport (optional padding factor
+   * in (0,1]). Reuses the shared `cameraStateForBounds` solver, then routes
+   * through `setCamera` so the result is a normal live-camera mutation (a moved
+   * camera flips the view fingerprint → next frame is a full repaint).
+   *
+   * The world camera baseline is CSS px, so the solver is fed the **CSS-px**
+   * viewport (`ctx.width/height ÷ dpr`) — the resulting `zoom` is then in CSS-px
+   * units and renders identically across dpr (the renderer applies dpr once,
+   * matrix-side, in `viewProjectionForSpace`).
+   */
+  fitCameraToBounds(bounds: Bounds2D, options?: FitCameraToBoundsOptions): void;
+  /**
+   * Bake a layer's shapes + glyphs into an offscreen single-sample texture and
+   * register it, so subsequent `render()` calls COMPOSITE the snapshot instead
+   * of re-packing / re-rasterizing the layer's geometry every frame. The
+   * composite is z-aware (T-ZBAKE): the bake lands UNDER all live geometry when
+   * its z-band sits below the first live layer, OVER all live geometry when it
+   * sits above the last, and is DEMOTED back to a live draw for any frame in
+   * which it is sandwiched between two live layers (z-order is always honored).
+   * The bake also draws the layer's MSDF glyphs INSIDE the bake pass
+   * (`tiers/bake.ts`) — so a cached layer's text is part of the snapshot and
+   * does not desynchronize during pan/zoom.
+   *
+   * The bake runs at `config.msaaBakes`× MSAA and resolves into a canvas-sized
+   * single-sample texture. `bakeViewProjection(layer.space, …)` FREEZES the
+   * camera at cache time for a `world`-space layer; `ui`/`device` layers bake in
+   * their own coordinate space. A subsequent camera move does NOT re-bake the
+   * layer — the caller must `uncacheLayer` + `cacheLayer` to refresh.
+   *
+   * Requires the renderer to have been constructed with an assembled `shader`
+   * (use {@link createRenderer}, which supplies it) — the bake builds its own
+   * MSAA shape pipelines from that source. Throws otherwise.
+   *
+   * Caching a layer forces the next frame to a full repaint (a new composited
+   * texture changes pixels the damage fingerprint cannot observe).
+   */
+  cacheLayer(layer: Layer, managed?: boolean): void;
+  /**
+   * Drop a layer's bake: destroy the bake texture + composite uniform, remove
+   * the registration (so `render()` resumes rasterizing the layer's pack live),
+   * and force the next frame to a full repaint (the composited pixels vanish
+   * from outside any damage rect). No-op when the layer is not cached.
+   */
+  uncacheLayer(layer: Layer): void;
+  /** True iff `layer`'s pack has a registered bake (composited, not live). */
+  isCached(layer: Layer): boolean;
+  /**
+   * Cached-layer textures the memory-budget policy evicted on the most recent
+   * `render()` (P3-T3). Empty when nothing was evicted. Surfaced so a caller /
+   * test can confirm what the budget dropped rather than mistaking a silent
+   * eviction for "everything stayed cached". Returns a copy.
+   */
+  get lastEvictedCaches(): readonly {
+    space: LayerSpace;
+    bytes: number;
+  }[];
+  /**
+   * Bakes DEMOTED on the most recent `render()` (T-ZBAKE): a layer whose pack
+   * has a registered bake but which sits SANDWICHED between two live layers in
+   * the z-sorted stack, so its bake could not be composited soundly (it would
+   * either occlude or be occluded incorrectly relative to the live layers it is
+   * meant to interleave with). A demoted bake stays LIVE for that frame — its
+   * pack still holds the CPU bytes, so the live draw is visually identical to the
+   * composite. Empty when no bake was sandwiched. Surfaced (mirroring
+   * {@link lastEvictedCaches}) so a caller / test can confirm a bake was kept
+   * live rather than mistaking it for a cache miss. Returns a copy.
+   */
+  get lastDemotedBakes(): readonly {
+    space: LayerSpace;
+  }[];
+  /**
+   * Frustum-cull statistics for the most recent {@link render} call, read off
+   * the decoupled cull stage (`cull.ts`). Returned BY COPY so a caller can hold
+   * the value
+   * across frames without it mutating under them. See {@link CullStats} for the
+   * field semantics (counts are over the dynamic concat buffer only).
+   */
+  get lastCullStats(): CullStats;
+  /**
+   * Mark `layer` RETAINED under a stable `key`. A retained layer hands its
+   * `UberPack` to the {@link RetainedTier}, which keeps a STABLE GPU instance
+   * buffer for it. On subsequent `render()` calls a retained pack is NOT
+   * re-concatenated into the dynamic instance buffer or re-uploaded — it draws
+   * as a DISTINCT appended draw over its own stable buffer (design option B:
+   * separate bound draw, NOT in the live concat, because the concat's
+   * `@builtin(instance_index)` mapping and per-frame z stamp shift as the live
+   * set changes size frame to frame).
+   *
+   * Re-upload happens ONLY when `key` changes (or the pack's `version` advances
+   * under the same key) — the unchanged-key path is a pure draw from the stable
+   * buffer (zero `writeBuffer`), which is the entire performance win. The
+   * internal painter order of a retained pack is FROZEN at build time via
+   * `stampRetainedOrder`. When `_retainedLayers.farBand` is on (default), the
+   * frozen order is mapped into the RESERVED FAR BAND `[Z_SPLIT, 1)` of the
+   * global NDC depth domain so the OIT opaque-occlusion gate (which compares a
+   * live glyph's depth against the retained pack's opaque depth) compares
+   * COMMENSURABLE values — without this, the two depths live in incommensurable
+   * private domains and the gate silently drops all labels behind a retained
+   * branch. Live shapes are compressed into `(0, Z_SPLIT)` the same frame,
+   * preserving all live-vs-live occlusion while ensuring live glyphs have
+   * `z < Z_SPLIT <= retainedZ`.
+   *
+   * **Precondition for `_retainedLayers.farBand` correctness**: all retained content
+   * must be z-BEHIND all live content (i.e. no retained instance should occlude a
+   * live-transparent fragment from above). All current callers satisfy this
+   * invariant (phylo overzoom is the bottom of the z-stack; the navigator
+   * overview is clipped to a minimap rect). A future caller that needs retained
+   * content z-INTERLEAVED with live geometry should use Strategy 2 (per-record
+   * viewport `minDepth/maxDepth` depth-range remap in `encodeRetained`) instead
+   * of `retainLayer`.
+   *
+   * Retained content stacks ABOVE the dynamic concat by submission order
+   * (accepted; the renderer does NOT z-interleave a retained buffer with dynamic
+   * geometry — this is the same semantics as before, now made explicit).
+   *
+   * Calling `retainLayer` with a NEW key for an already-retained layer evicts
+   * the old stable buffer and rebuilds. Mirrors the `cacheLayer`/`_bakes`
+   * ownership model (keyed by `layer.pack`); the next frame is forced full (a
+   * newly-built retained draw changes pixels the damage fingerprint can't see).
+   *
+   * T-CULLNAV: pass `{ spatialIndex: true }` (the v3 `cacheLayer({ spatialIndex
+   * })` equivalent) to build a cell-binned grid over the pack's per-instance
+   * AABBs. The pack's instance bytes are REORDERED into cell-contiguous slot
+   * order before upload, and on a `world`-space frame the renderer range-queries
+   * the grid against the viewport frustum and issues one draw per visible
+   * cell-run — collapsing a huge baked overzoom tile into a handful of draws.
+   * The reorder permutes WHICH survivors draw, never their relative painter
+   * order (the frozen per-slot z is re-stamped over the reordered slots), so the
+   * retained buffer still stacks by submission and never joins the dynamic
+   * `z = 1 − (gi+0.5)/N` stamp. Below the grid's `minItems` (or for degenerate
+   * bounds) the index is skipped and the pack draws as one full-span draw.
+   */
+  retainLayer(layer: Layer, key: string, opts?: {
+    spatialIndex?: boolean;
+  }): void;
+  /**
+   * Drop a layer's retention: evict its stable GPU buffer from the
+   * {@link RetainedLayers} (and its inner {@link RetainedTier}), remove the
+   * registration so `render()` resumes drawing the layer live through the
+   * dynamic concat, and force the next frame full. No-op when the layer is not
+   * retained.
+   */
+  unretainLayer(layer: Layer): void;
+  /** True iff `layer`'s pack is registered as retained (drawn from a stable buffer). */
+  isRetained(layer: Layer): boolean;
+  /**
+   * PHASE-4 — heterogeneous z-order reconciliation (the correctness crux).
+   *
+   * The renderer stamps SHAPE `order` in a GLOBAL cross-layer painter domain:
+   * shape global index `g ∈ [0, N)` (N = `totalInstances`, all live shapes
+   * concatenated in draw order) maps to `order = 1 - (g + 0.5)/N`. That global
+   * domain is what makes the shared depth buffer occlude opaque shapes ACROSS
+   * layers (layer 0's shapes are farther than layer 1's). `Layer.finalizeOrder()`
+   * instead works in a PER-LAYER domain (`1 - (i + 0.5)/T`, T = the layer's own
+   * shape+glyph+sprite count) — a DIFFERENT scale. The two must be reconciled so
+   * a glyph/sprite lands at the correct depth relative to BOTH its own layer's
+   * shapes and the whole live stack.
+   *
+   * Reconciliation: each layer's shapes occupy global indices `[packBase,
+   * packBase + instInPack)`. `finalizeOrder()` returns `shapeOrderSeq` — each
+   * pack shape's PER-LAYER interleave seq (ascending in pack order) — and stamps
+   * each glyph/sprite a per-layer local order `L = 1 - (s + 0.5)/T` (T = the
+   * layer's shape+glyph+sprite count). From `L` we recover the glyph/sprite's
+   * local seq `s` and count how many of the layer's SHAPES were pushed before it
+   * (`shapesBefore` = #`shapeOrderSeq` < s). That places it at the global
+   * fractional shape index `packBase + shapesBefore - 0.25`: just FARTHER than
+   * the layer's `shapesBefore`-th shape and just NEARER than its
+   * `(shapesBefore-1)`-th — exactly its push position relative to the layer's
+   * shapes — then `order = 1 - (fracIndex + 0.5)/N`. The `-0.25` breaks the
+   * depth-test tie so an opaque shape pushed AFTER a glyph (nearer) OCCLUDES it
+   * and one pushed BEFORE (farther) is OCCLUDED BY it.
+   *
+   * A glyph-/sprite-only layer (no shape seqs) maps every instance to
+   * `packBase - 0.25`: just NEARER than the last shape of all PRIOR layers and
+   * just FARTHER than the first shape of the next — correct painter order for a
+   * text/sprite-only band.
+   *
+   * `N` (the denominator) is the FULL un-culled shape count, so a glyph's order
+   * is independent of frustum-cull survivor densification — stable across a pure
+   * pan, which keeps the version-gated glyph upload cache sound (the cull may
+   * re-densify SHAPE depth without touching glyph order). Under heavy cull a
+   * glyph follows the un-culled painter scale while drawn shapes are densified;
+   * relative order among ON-SCREEN (surviving) neighbors is preserved
+   * (densification is monotonic), so the interleave a viewer can SEE is correct.
+   * Documented approximation; exact survivor-densified glyph depth is a follow-up
+   * if a measured artifact appears.
+   *
+   * @param ranges          Per-live-layer `{ layer, packBase, instInPack }` in draw order.
+   *   `packBase` = count of shapes in all prior live layers.
+   * @param n               Total live shape count N (the global painter denominator).
+   * @param retainedPresent When true AND `_retainedLayers.farBand` is on,
+   *   glyph/sprite `order` values are compressed by `* Z_SPLIT` so they land
+   *   inside `(0, Z_SPLIT)` — the same band as live shapes — and remain strictly
+   *   below the retained far band `[Z_SPLIT, 1)`. Without this compression a
+   *   glyph-only layer (e.g. `labelLayer`) would compute an `order` near 1.0
+   *   (full-range denominator), which the OIT gate would wrongly compare against
+   *   a retained branch's far-band depth and silently drop. The `ORDER_EPS` clamp
+   *   is applied AFTER compression so it pins to the compressed open range
+   *   `(0, Z_SPLIT)`.
+   */
+  private _stampHeterogeneousOrder;
+  /**
+   * Draw one frame. Packs from `layers` are uploaded in submission order into
+   * one storage buffer; their `DrawCommand`s are issued in a single render
+   * pass — opaque first, then transparent, with the explicit per-instance
+   * `order` as the sole depth source.
+   *
+   * `opts` mirrors v1's `render(layers, { … })`. When `opts.regions` are
+   * supplied on a persistent renderer whose composite view is unchanged since
+   * the last frame, the frame takes the partial (damage-tracked) path:
+   * `loadOp:"load"` preserves untouched pixels and only the padded damage rects
+   * are erased + repainted under a scissor. Any view change (camera, group
+   * transforms via `viewKey`, dpr, size, background), an absent/empty
+   * `regions`, `fullFrame:true`, `forceFullFrame()`, or a non-persistent
+   * renderer falls back to a full (`loadOp:"clear"`) repaint.
+   *
+   * `layers` may also include {@link BufferLayer}s (GPU-resident buffers from a
+   * compute pass). A BufferLayer CANNOT join the concatenated dynamic instance
+   * buffer (it owns its own buffer with the v1 schema), so it draws as a DISTINCT
+   * bound draw in a post-main-pass region, stacking ABOVE all dynamic geometry +
+   * bakes by submission order (no z-interleave). A BufferLayer's `version` /
+   * `count` / buffer identity are folded into the partial-redraw fingerprint, so
+   * a changed buffer demotes the frame to full automatically — provided the
+   * caller bumps `version` when its compute pass mutates the buffer.
+   */
+  render(layers: readonly (Layer | BufferLayer | CustomDrawable)[], opts?: RenderOptions): void;
+  /** @internal */
+  get frameRoot(): {
+    device: GPUDevice;
+  };
+  /** @internal */
+  get frameCtx(): FrameHost["frameCtx"];
+  /** @internal */
+  get frameConfig(): FrameHost["frameConfig"];
+  /** @internal */
+  get frameAbuffer(): FrameHost["frameAbuffer"];
+  /** @internal */
+  get frameOitPipelines(): FrameHost["frameOitPipelines"];
+  /** @internal */
+  get frameUseOit(): boolean;
+  /** @internal */
+  get frameCamera(): {
+    x: number;
+    y: number;
+    zoom: number;
+    rotation: number;
+  };
+  /** @internal */
+  get frameDpr(): number;
+  /** @internal */
+  get frameBackground(): Color;
+  /** @internal */
+  get frameEmphasisMirror(): {
+    focusedKey: number;
+    dimAlpha: number;
+    t: number;
+  };
+  /** @internal */
+  get frameRetainedFarBand(): boolean;
+  /** @internal */
+  get frameCapturing(): boolean;
+  /** @internal */
+  get cameraUniformData(): Float32Array;
+  /** @internal */
+  cameraUniformSlotStrideFloats(): number;
+  /** @internal */
+  get cameraUniformSlotStride(): number;
+  /** @internal */
+  cameraUniformBuffer(): GPUBuffer;
+  /** @internal */
+  ensureCameraSlots(count: number): void;
+  /** @internal */
+  ensureStaging(floats: number): void;
+  /** @internal */
+  stagingArray(): Float32Array;
+  /** @internal */
+  ensureCullAabbs(instances: number): Float32Array;
+  /** @internal */
+  ensureInstanceCapacity(bytes: number): void;
+  /** @internal */
+  instanceBuffer(): GPUBuffer;
+  /** @internal */
+  hasBakes(): boolean;
+  /** @internal */
+  hasRetained(): boolean;
+  /** @internal */
+  bakeFor(pack: object): BakeRecord | undefined;
+  /** @internal */
+  retainedFor(pack: object): RetainedRecord | undefined;
+  /** @internal */
+  bakeCacheApplyCachePolicy(layers: readonly Layer[]): void;
+  /** @internal */
+  bakeCacheClearDemotions(): void;
+  /** @internal */
+  bakeCacheRecordDemotion(space: LayerSpace): void;
+  /** @internal */
+  get cullStats(): CullStats;
+  /** @internal */
+  stampHeterogeneousOrder(ranges: readonly {
+    layer: Layer;
+    packBase: number;
+    instInPack: number;
+  }[], n: number, retainedPresent: boolean): void;
+  /** @internal */
+  glyphUploadInstances(layers: readonly Layer[], sig: string, device: GPUDevice): {
+    glyphDraws: GlyphDraw[];
+  };
+  /** @internal */
+  glyphPackId(pack: object): number;
+  /** @internal */
+  uploadLayerSprites(layers: readonly Layer[]): number[];
+  /** @internal */
+  encodeFull(pass: GPURenderPassEncoder, cmds: readonly RebasedCommand[], retained: readonly RetainedRecord[], useOit: boolean, bakedBelow: readonly BakeRecord[], phase?: "all" | "opaque" | "transparent"): number;
+  /** @internal */
+  encodePartial(pass: GPURenderPassEncoder, cmds: readonly RebasedCommand[], retained: readonly RetainedRecord[], regions: readonly FrameRect[], clearValue: {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+  }, useOit: boolean, bakedBelow: readonly BakeRecord[], phase?: "all" | "opaque" | "transparent"): number;
+  /** @internal */
+  encodeExempt(pass: GPURenderPassEncoder, cmds: readonly RebasedCommand[] | null, glyphDraws: readonly GlyphDraw[] | null, base: FrameRect | null): number;
+  /** @internal */
+  encodeGlyphs(pass: GPURenderPassEncoder, draws: readonly GlyphDraw[]): number;
+  /** @internal */
+  frameApplyScissor(pass: GPURenderPassEncoder, rect: FrameRect | null): void;
+  /** @internal */
+  encodeGlyphsOitEmit(pass: GPURenderPassEncoder, draws: readonly GlyphDraw[]): number;
+  /** @internal */
+  encodeSpritesOitEmit(pass: GPURenderPassEncoder, layers: readonly Layer[], bases: readonly number[]): number;
+  /** @internal */
+  encodeLayerSprites(pass: GPURenderPassEncoder, layers: readonly Layer[], bases: readonly number[], oitOpaqueOnly: boolean): number;
+  /** @internal */
+  encodeBufferLayer(pass: GPURenderPassEncoder, bl: BufferLayer): number;
+  /** @internal */
+  abufferHandle(): {
+    resolveBindGroup: GPUBindGroup;
+  } | null;
+  /** @internal */
+  compositePipeline(): {
+    pipeline: GPURenderPipeline;
+  } | null;
+  /** @internal */
+  frameAutoDamage(): AutoDamageState | null;
+  /** @internal */
+  setFrameAutoDamage(state: AutoDamageState): void;
+  /** @internal */
+  setAutoFullReason(reason: string | null): void;
+  /** @internal */
+  setAutoUpdateLayers(layers: readonly Layer[] | null): void;
+  /** @internal */
+  clearFrameProvenance(): void;
+  /** @internal */
+  noteAutoProvenance(perLayer: unknown): void;
+  /** @internal */
+  fingerprintDecide(args: {
+    params: FingerprintParams;
+    hasDamageRegions: boolean;
+    fullFrame: boolean;
+    capturing: boolean;
+  }): {
+    viewChanged: boolean;
+    forcedReason: string | null;
+    changedParts: FingerprintPart[] | undefined;
+    visibilityChanged: boolean;
+    partial: boolean;
+  };
+  /** @internal */
+  resolveGpuTimer(): {
+    timestampWrites: GPURenderPassTimestampWrites | undefined;
+    resolve(encoder: GPUCommandEncoder): {
+      read(): Promise<bigint>;
+    } | null;
+  } | null;
+  /** @internal */
+  drainPendingCompute(encoder: GPUCommandEncoder): void;
+  /** @internal */
+  refreshAutoSnapshots(): void;
+  /** @internal */
+  emitFrameDebug(f: FrameDebugLite): void;
+  /**
+   * Assemble + dispatch the {@link FrameDebug} record — see {@link emitFrameDebug}.
+   * Called ONLY when the probe is capturing (the caller guards). Delegates
+   * SpaceMap + Layer retention to {@link DebugRetention} via `capture()`.
+   */
+  private _emitFrameDebug;
+  /** Release renderer-owned GPU resources. The renderer is unusable after. */
+  destroy(): void;
+  /**
+   * Bind the camera bind group for `slot` at `@group(0)` unless it is already
+   * bound. Returns the now-bound slot so the caller can thread it through a loop
+   * (commands are grouped by layer, so the rebind fires only at layer/space
+   * boundaries — typically once or twice per frame). Pass `bound = -1` to force
+   * a bind (e.g. after the clear-quad rebinds `@group(0)`).
+   */
+  private _bindCameraSlot;
+  /**
+   * Build the {@link EncodeCtx} the encode tier (`tiers/encode.ts`) draws
+   * against: read-only renderer handles plus the scissor/camera/clear-color
+   * primitives bound to this renderer. Constructed fresh per encode call (a
+   * handful per frame) so it always reflects lazily-built pipelines / bind
+   * groups; allocating a small handle object is negligible against the draws.
+   */
+  private _encodeCtx;
+  /** Full-frame encode — see {@link encodeFull}. */
+  private _encodeFull;
+  /** Partial (damage-tracked) encode — see {@link encodePartial}. */
+  private _encodePartial;
+  /** OIT-exempt overlay encode — see {@link encodeExempt}. */
+  private _encodeExempt;
+  /** Upload the premultiplied background into the clear-quad uniform. */
+  private _writeClearColor;
+  /**
+   * Set the scissor for one command within a padded damage rect. Returns
+   * `false` (skip the draw) when the command carries a non-null `clipRect` whose
+   * intersection with the padded rect is zero-area. A `null`/absent clip never
+   * culls (the padded rect passes through).
+   */
+  private _scissorForCommand;
+  /**
+   * Set a device-pixel scissor from a CSS-pixel rect. `null` restores the full
+   * attachment. CSS→device uses `_dpr`; the rect is floored on the near corner
+   * and ceiled on the far corner (so a damage rect never under-covers a partial
+   * device pixel), then clamped to the attachment bounds.
+   */
+  private applyScissor;
+  /**
+   * Lazily build + cache the clear-quad bind group. The clear-quad pipeline uses
+   * `layout:"auto"`, so its group-0 layout is only available off the compiled
+   * pipeline (`getBindGroupLayout(0)`), not from the shared explicit layouts.
+   */
+  private _ensureClearColorBindGroup;
+  /**
+   * Ensure the camera buffer + bind groups hold at least `count` slots (P3-T8
+   * per-(space × group) routing). Delegates growth to {@link CameraUniform.ensureSlots}.
+   *
+   * When the buffer is reallocated (ensureSlots returns `true`), any bind group
+   * built against the OLD buffer (the live-glyph + interop per-slot camera bind
+   * groups) is invalidated and reset to `null` here so it rebuilds lazily against
+   * the new buffer on its next use. A group-tagged draw is rare relative to a pure
+   * pan; this grow happens at most a handful of times before the pool stabilizes.
+   */
+  private _ensureCameraSlots;
+  /**
+   * Facade: encode the live MSDF glyph draws (direct-color path). Delegates to
+   * {@link GlyphEncoder.encode}. Called on the non-OIT main pass and the
+   * post-resolve EXEMPT pass.
+   */
+  private _encodeGlyphs;
+  /**
+   * Facade: encode glyph OIT-emit appends into the A-buffer build sweep.
+   * Delegates to {@link GlyphEncoder.encodeOitEmit}. The binding-3 opaqueDepth
+   * gate is preserved byte-identically (see `GlyphEncoder.encodeOitEmit` docs).
+   */
+  private _encodeGlyphsOitEmit;
+  /** Facade: delegate BufferLayer encode to the interop encoder. */
+  private _encodeBufferLayer;
+  /** Facade: upload all sprite-bearing layers' packs and return base offsets. */
+  private _uploadLayerSprites;
+  /** Facade: draw per-texture sprite commands in the post-main pass. */
+  private _encodeLayerSprites;
+  /** Facade: encode transparent-sprite OIT-emit appends into the A-buffer. */
+  private _encodeSpritesOitEmit;
+}
+/**
+ * @internal Test helper — used only by unit tests that supply pre-built
+ * `Pipelines` without a real GPU. Application code should use
+ * {@link createRenderer}, which assembles the shader, pipelines, and
+ * (when `config.oit` is on) the OIT A-buffer automatically.
+ */
+declare function createTestRenderer(owner: GPUOwner, canvas: HTMLCanvasElement, pipelines: Pipelines, config?: Partial<RendererConfig>): Renderer2D;
+/** Construction options for {@link createRenderer} — the batteries-included
+ * factory. Everything is optional; the defaults give a working OIT renderer. */
+interface RendererOptions {
+  /** Partial config overriding {@link DEFAULT_CONFIG}. */
+  config?: Partial<RendererConfig>;
+  /** Initial camera state. */
+  camera?: CameraState;
+  /** Initial clear color. */
+  background?: Color;
+  /** CSS→device pixel ratio. */
+  dpr?: number;
+  /** Diagnostic logger for library output. Defaults to `console`. */
+  logger?: Logger;
+  /**
+   * Color-target format the pipelines + A-buffer are built against. Defaults to
+   * `navigator.gpu.getPreferredCanvasFormat()` — the same format
+   * `createCanvasContext` configures the swap chain with — so the assembled
+   * pipelines match the canvas the renderer renders into.
+   */
+  format?: GPUTextureFormat;
+}
+/**
+ * Batteries-included v3 renderer factory. Given a GPU owner + canvas it does the
+ * full assembly the renderer constructor intentionally does NOT do (the
+ * constructor takes pre-built pipelines so it stays GPU-compilation-free and
+ * unit-testable):
+ *
+ *   1. `assembleShader(ORDERED_KINDS, INSTANCE_LAYOUT.wgslAccessor)` — one
+ *      uber-shader from every kind in `typeFlag` order.
+ *   2. `createPipelines(root, format, shader)` — opaque / transparent /
+ *      clear-quad pipelines + shared camera/instance layouts.
+ *   3. When `config.oit` is on (the {@link DEFAULT_CONFIG} default): an
+ *      {@link ABuffer} sized to the canvas + `createOITPipelines(...)`, injected
+ *      into the constructor so the default config renders order-independent
+ *      transparency out of the box. When `config.oit` is `false` no OIT
+ *      resources are built and the renderer uses the sorted alpha-blend path.
+ *
+ * The advanced DI path (`new Renderer2D(owner, canvas, { pipelines, oit })`)
+ * stays available for callers that share pipelines across renderers or supply
+ * their own A-buffer.
+ */
+declare function createRenderer(owner: GPUOwner, canvas: HTMLCanvasElement, options?: RendererOptions): Renderer2D;
+//#endregion
+export { RendererConfig as $, SEGMENT_FLOATS as $n, CurveRecord as $t, SpatialGridResult as A, TYPE_SEGMENT as An, mixColor as Ar, TextStyleTable as At, FrameDebugListener as B, ARC_FLOATS as Bn, STROKE_MAX_POINTS as Bt, ABuffer as C, PrimitiveKind as Cn, hex as Cr, GlyphPackFlags as Ct, SLOT_BYTES as D, TYPE_ELLIPSE as Dn, hsv as Dr, TextOutline as Dt, RESOLVE_MAX_K as E, TYPE_CURVE as En, hslToRgba as Er, TextGradient as Et, CullResult as F, INSTANCE_LAYOUT as Fn, SpriteShape as Ft, LayerSummary as G, CURVE_FLOATS as Gn, packStrokeFlags as Gt, FRAME_RING_CAPACITY as H, CURVE_CAP_BUTT as Hn, StrokeInstanceRecord as Ht, CulledRange as I, deriveLayout as In, DrawCommand as It, DebugRect as J, EllipseShape as Jn, TriangleRecord as Jt, summarize as K, CircleShape as Kn, stroke as Kt, cullCommands as L, INSTANCE_BYTES as Ln, UberPack as Lt, buildSpatialGrid as M, TYPE_STROKE_PATH as Mn, withAlpha as Mr, SPRITE_FLOATS as Mt, queryRanges as N, TYPE_TRIANGLE as Nn, SpriteCommand as Nt, SpatialGrid as O, TYPE_GLYPH as On, lerpColor as Or, TextShadow as Ot, CullCommand as P, WorldAABB as Pn, SpritePack as Pt, LayerDebugInfo as Q, RectShape as Qn, CurveCap as Qt, worldFrustumAabb as R, INSTANCE_FIELDS as Rn, nextByteCapacity as Rt, createOITPipelines as S, assembleShader as Sn, fade as Sr, GlyphPack as St, HEAD_BYTES as T, TYPE_CIRCLE as Tn, hslToRgb as Tr, BlockGeometry as Tt, FrameRing as U, CURVE_CAP_ROUND as Un, StrokePathShape as Ut, RendererDebug as V, ArcShape as Vn, STROKE_SEGMENTS_PER_INSTANCE as Vt, FrameSummary as W, CURVE_CAP_SQUARE as Wn, chunkStroke as Wt, FrameDebug as X, PolygonOpts as Xn, ArcRecord as Xt, FingerprintPart as Y, LineShape as Yn, triangle as Yt, FrameTiming as Z, PolygonShape$1 as Zn, arc as Zt, BufferLayerKind as _, getLogger as _n, Color as _r, GroupedTriangleRecord as _t, RendererOptions as a, CircleRecord as an, SegmentShape as ar, convertRect as at, OITPipelineDeps as b, createPipelines as bn, cssHex as br, createLayer as bt, onRendererCreated as c, rect as cn, LineCap as cr, GroupedArcRecord as ct, CustomDrawableContext as d, project as dn, RectRingOptions as dr, GroupedEllipseRecord as dt, curve as en, SHAPE_BYTES as er, DebugSize as et, CustomDrawableOptions as f, Group as fn, TessellatedTriangle as fr, GroupedRectRecord as ft, BufferLayerInstancesOptions as g, Logger as gn, BLACK as gr, GroupedTextShape as gt, BufferLayer as h, resolveGroupTransform as hn, tessellatePolyline as hr, GroupedStrokeShape as ht, RendererConstructorOptions as i, ellipse as in, SPRITE_FLOATS$1 as ir, captureSpaceMap as it, SpatialRange as j, TYPE_SPRITE as jn, rgba as jr, SPRITE_BYTES as jt, SpatialGridOptions as k, TYPE_RECT as kn, lighten as kr, TextStyle as kt, rendererForCanvas as l, LayerSpace as ln, LineJoin as lr, GroupedCircleRecord as lt, isCustomDrawable as m, createGroup as mn, polylineRectRing as mr, GroupedShape as mt, RenderOptions as n, segment as nn, SHAPE_ELLIPSE as nr, RectXYWH as nt, createRenderer as o, circle as on, TRIANGLE_FLOATS as or, CacheHint as ot, createCustomDrawable as p, GroupOptions as pn, polylineEllipseRing as pr, GroupedSegmentRecord as pt, DEFAULT_CONFIG as q, CurveShape as qn, strokeInstanceCount as qt, Renderer2D as r, EllipseRecord as rn, SHAPE_RECT as rr, SpaceMap as rt, createTestRenderer as s, RectRecord as sn, EllipseRingOptions as sr, GroupedAnchoredStringShape as st, CullStats as t, SegmentRecord as tn, SHAPE_CIRCLE as tr, DebugSpace as tt, CustomDrawable as u, ProjectOptions as un, PolylineShape as ur, GroupedCurveRecord as ut, BufferLayerOptions as v, setLogger as vn, TRANSPARENT as vr, Layer as vt, ABufferOptions as w, TYPE_ARC as wn, hsl as wr, GlyphTextShape as wt, OITPipelines as x, AssembledShader as xn, darken as xr, GlyphMetricsOut as xt, createBufferLayer as y, Pipelines as yn, WHITE as yr, LayerOptions as yt, AABB as z, INSTANCE_FLOATS as zn, ORDERED_KINDS as zt };