insomni 0.2.0-alpha.0

package/dist/internal.d.mts

@@ -0,0 +1,892 @@
+import { i as ShapeSchema, o as SpriteSchema } from "./pipeline-DE3a1Pnk.mjs";
+import { $ as RendererConfig, $n as SEGMENT_FLOATS, A as SpatialGridResult, B as FrameDebugListener, Bn as ARC_FLOATS, C as ABuffer, D as SLOT_BYTES, F as CullResult, G as LayerSummary, Gn as CURVE_FLOATS, H as FRAME_RING_CAPACITY, Hn as CURVE_CAP_BUTT, I as CulledRange, It as DrawCommand, K as summarize, L as cullCommands, Lt as UberPack, M as buildSpatialGrid, N as queryRanges, O as SpatialGrid, P as CullCommand, R as worldFrustumAabb, Rt as nextByteCapacity, S as createOITPipelines, St as GlyphPack, T as HEAD_BYTES, U as FrameRing, Un as CURVE_CAP_ROUND, V as RendererDebug, W as FrameSummary, Wn as CURVE_CAP_SQUARE, _r as Color, at as convertRect, b as OITPipelineDeps, er as SHAPE_BYTES, et as DebugSize, fn as Group, it as captureSpaceMap, j as SpatialRange, k as SpatialGridOptions, ln as LayerSpace, nr as SHAPE_ELLIPSE, nt as RectXYWH, or as TRIANGLE_FLOATS, r as Renderer2D, rr as SHAPE_RECT, rt as SpaceMap, s as createTestRenderer, tr as SHAPE_CIRCLE, tt as DebugSpace, un as ProjectOptions, vt as Layer, x as OITPipelines, xn as AssembledShader } from "./renderer-DzZqd1bY.mjs";
+import { N as FrameRect, S as Mat3, n as CameraState, t as Bounds2D } from "./camera-view-DHmMiKvP.mjs";
+import { _ as resolveRoot, g as GPUOwner } from "./text-font-D7GGDtTK.mjs";
+import { D as SpatialRenderer2D, E as SpatialPointerEvent, S as Scheduler, T as SpatialFrameTiming, b as SceneRoot, g as Rect, i as DirtyRegion, m as PointerRouter, r as DirtyChannel, t as Damage, v as SceneNode } from "./spatial-Bd3Ay8I2.mjs";
+import { StorageFlag, TgpuBindGroup, TgpuBuffer, TgpuRoot, d } from "typegpu";
+
+//#region src/shared/dynamic-buffer.d.ts
+declare function nextPow2(value: number): number;
+//#endregion
+//#region src/gpu/spatial-hash.d.ts
+declare const SPATIAL_HASH_WORKGROUP_SIZE = 64;
+declare const SPATIAL_HASH_PARAMS_BYTES = 32;
+declare const SPATIAL_HASH_PARAMS_WGSL = "\nstruct SpatialHashParams {\n  rangeStart: u32,\n  rangeCount: u32,\n  bucketMask: u32,\n  bucketCount: u32,\n  invCellSize: f32,\n  weight: f32,\n  _pad0: f32,\n  _pad1: f32,\n};\n\nconst EMPTY_SLOT: u32 = 0xffffffffu;\nconst DEAD_CELL_COORD: i32 = 2147483647;\n\nfn hashCell(cell: vec2i, mask: u32) -> u32 {\n  let x = bitcast<u32>(cell.x);\n  let y = bitcast<u32>(cell.y);\n  var h = x * 0x9e3779b9u;\n  h = (h << 6u) ^ (h >> 2u) ^ (y * 0x85ebca6bu);\n  return h & mask;\n}\n\nfn worldCell(pos: vec2f, invCellSize: f32) -> vec2i {\n  return vec2i(floor(pos * invCellSize));\n}\n";
+declare const CLEAR_SPATIAL_HASH_WGSL = "\nstruct SpatialHashParams {\n  rangeStart: u32,\n  rangeCount: u32,\n  bucketMask: u32,\n  bucketCount: u32,\n  invCellSize: f32,\n  weight: f32,\n  _pad0: f32,\n  _pad1: f32,\n};\n\nconst EMPTY_SLOT: u32 = 0xffffffffu;\nconst DEAD_CELL_COORD: i32 = 2147483647;\n\nfn hashCell(cell: vec2i, mask: u32) -> u32 {\n  let x = bitcast<u32>(cell.x);\n  let y = bitcast<u32>(cell.y);\n  var h = x * 0x9e3779b9u;\n  h = (h << 6u) ^ (h >> 2u) ^ (y * 0x85ebca6bu);\n  return h & mask;\n}\n\nfn worldCell(pos: vec2f, invCellSize: f32) -> vec2i {\n  return vec2i(floor(pos * invCellSize));\n}\n\n@group(0) @binding(0) var<storage, read_write> heads: array<atomic<u32>>;\n@group(0) @binding(1) var<uniform> params: SpatialHashParams;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3u) {\n  let i = gid.x;\n  if (i >= params.bucketCount) {\n    return;\n  }\n  atomicStore(&heads[i], EMPTY_SLOT);\n}\n";
+declare const BUILD_SPATIAL_HASH_WGSL = "\nstruct SpatialHashParams {\n  rangeStart: u32,\n  rangeCount: u32,\n  bucketMask: u32,\n  bucketCount: u32,\n  invCellSize: f32,\n  weight: f32,\n  _pad0: f32,\n  _pad1: f32,\n};\n\nconst EMPTY_SLOT: u32 = 0xffffffffu;\nconst DEAD_CELL_COORD: i32 = 2147483647;\n\nfn hashCell(cell: vec2i, mask: u32) -> u32 {\n  let x = bitcast<u32>(cell.x);\n  let y = bitcast<u32>(cell.y);\n  var h = x * 0x9e3779b9u;\n  h = (h << 6u) ^ (h >> 2u) ^ (y * 0x85ebca6bu);\n  return h & mask;\n}\n\nfn worldCell(pos: vec2f, invCellSize: f32) -> vec2i {\n  return vec2i(floor(pos * invCellSize));\n}\n\n@group(0) @binding(0) var<storage, read_write> heads: array<atomic<u32>>;\n@group(0) @binding(1) var<storage, read_write> next: array<u32>;\n@group(0) @binding(2) var<storage, read_write> cells: array<vec2i>;\n@group(0) @binding(3) var<storage, read> nodeIds: array<u32>;\n@group(0) @binding(4) var<storage, read> positions: array<vec4f>;\n@group(0) @binding(5) var<storage, read> alive: array<u32>;\n@group(0) @binding(6) var<uniform> params: SpatialHashParams;\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) gid: vec3u) {\n  let role = gid.x;\n  if (role >= params.rangeCount) {\n    return;\n  }\n\n  let entry = params.rangeStart + role;\n  let nodeId = nodeIds[entry];\n  next[entry] = EMPTY_SLOT;\n\n  if (alive[nodeId] == 0u) {\n    cells[entry] = vec2i(DEAD_CELL_COORD);\n    return;\n  }\n\n  let cell = worldCell(positions[nodeId].xy, params.invCellSize);\n  cells[entry] = cell;\n  let bucket = hashCell(cell, params.bucketMask);\n  let prev = atomicExchange(&heads[bucket], entry);\n  next[entry] = prev;\n}\n";
+//#endregion
+//#region src/pack/region-index.d.ts
+/** A byte range within the `UberPack` buffer that must be re-uploaded. */
+interface DirtyRange {
+  /** Byte offset of the dirty span within the `UberPack` buffer. */
+  byteOffset: number;
+  /** Byte length of the dirty span. */
+  byteLength: number;
+}
+/**
+ * Maps group identities to their byte spans within the `UberPack` buffer, and
+ * maintains an accumulated set of dirty byte ranges for the current frame.
+ *
+ * Default region granularity = one `Group` object. Callers that do not use
+ * explicit group tracking can pass a single sentinel object as `groupId`.
+ *
+ * Usage per frame:
+ * ```ts
+ * regions.reset();
+ * for (const [group, items] of scene.byGroup()) {
+ *   regions.beginRegion(group, pack.byteLength);
+ *   for (const item of items) pack.append(...);
+ *   regions.endRegion(group, pack.byteLength);
+ * }
+ * // At mutation time:
+ * regions.markDirty(hoveredGroup);
+ * // Before upload:
+ * const ranges = regions.coalesced();
+ * regions.clearDirty();
+ * ```
+ */
+declare class RegionIndex {
+  /** group identity → byte span in the current pack. */
+  private _spans;
+  /** Accumulated dirty ranges for this frame (may overlap / be out of order). */
+  private _dirty;
+  /**
+   * Record the byte offset at which a group's instances BEGIN being packed.
+   * `byteOffset` is the value of `UberPack.byteLength` BEFORE the first
+   * `append` call for this group.
+   */
+  beginRegion(groupId: object, byteOffset: number): void;
+  /**
+   * Record the byte offset at which a group's instances END being packed.
+   * `byteOffset` is the value of `UberPack.byteLength` AFTER the last
+   * `append` call for this group.
+   */
+  endRegion(groupId: object, byteOffset: number): void;
+  /**
+   * Reset all span records for a new frame. Call before re-packing. Does NOT
+   * clear dirty ranges (use `clearDirty` for that).
+   */
+  reset(): void;
+  /**
+   * Mark a group's byte span as dirty. If the group has no recorded span
+   * (e.g. not packed this frame), this is a no-op.
+   */
+  markDirty(groupId: object): void;
+  /**
+   * Return the minimal, sorted, non-overlapping set of dirty byte ranges.
+   *
+   * - Output is sorted ascending by `byteOffset`.
+   * - Adjacent or overlapping input ranges are merged into a single output range.
+   * - Non-destructive: does not mutate the internal `_dirty` list.
+   * - Returns an empty array when no ranges are dirty.
+   */
+  coalesced(): DirtyRange[];
+  /**
+   * Clear accumulated dirty ranges. Call after the GPU upload is complete.
+   * Does NOT reset span records — use `reset()` for that.
+   */
+  clearDirty(): void;
+  /**
+   * Return the recorded byte span for a group, or `undefined` if the group
+   * was not packed this frame. For testing / debugging only.
+   */
+  spanOf(groupId: object): {
+    start: number;
+    end: number;
+  } | undefined;
+}
+//#endregion
+//#region src/pack/repack-v1.d.ts
+/**
+ * Repack `count` v1-stride segment records (`SEGMENT_FLOATS` floats each) into a
+ * freshly-allocated v3 instance buffer (`count * INSTANCE_FLOATS` floats).
+ * Byte-identical to looping `Layer.pushSegment` over the same records.
+ */
+declare function repackSegments(src: ArrayLike<number>, count: number): Float32Array;
+/**
+ * Repack `count` v1-stride curve records (`CURVE_FLOATS` floats each) into a
+ * freshly-allocated v3 instance buffer. Byte-identical to looping
+ * `Layer.pushCurve` over the same records.
+ */
+declare function repackCurves(src: ArrayLike<number>, count: number): Float32Array;
+/**
+ * Repack `count` v1-stride arc records (`ARC_FLOATS` floats each) into a
+ * freshly-allocated v3 instance buffer. Byte-identical to looping
+ * `Layer.pushArc` over the same records.
+ */
+declare function repackArcs(src: ArrayLike<number>, count: number): Float32Array;
+//#endregion
+//#region src/target/blit.d.ts
+/**
+ * Copy the entire persistent backbuffer onto the swap-chain texture.
+ *
+ * Both textures share the same format, size, and sample count (single-sample),
+ * so this is a raw texel copy — no sampler, blend, or premultiply round-trip.
+ *
+ * Always copies the full `width × height`. Never pass a sub-rect: a partial
+ * copy leaves pixels outside the rect cleared on the presented physical buffer
+ * (see the module header). Width/height are in DEVICE pixels (the backbuffer /
+ * swap-chain texel dimensions).
+ *
+ * @param encoder Command encoder for the current frame (the copy is recorded
+ *   after `pass.end()` and before `device.queue.submit`).
+ * @param src     Persistent backbuffer texture (`ctx.backbuffer`).
+ * @param dst     Swap-chain texture (`ctx.gpuContext.getCurrentTexture()`).
+ * @param width   Device-pixel width of both textures (`ctx.width`).
+ * @param height  Device-pixel height of both textures (`ctx.height`).
+ */
+declare function blitBackbuffer(encoder: GPUCommandEncoder, src: GPUTexture, dst: GPUTexture, width: number, height: number): void;
+//#endregion
+//#region src/tiers/retained.d.ts
+/**
+ * Metadata for a single UberPack's stable GPU buffer.  Stored in the
+ * WeakMap keyed on the pack itself.
+ */
+interface RetainedRecord {
+  /** Stable GPU buffer — NOT re-uploaded when damage is clear. */
+  gpuBuffer: GPUBuffer;
+  /** Byte capacity of gpuBuffer. */
+  gpuCapacityBytes: number;
+  /** Frames elapsed since the start of the current shrink window. */
+  framesSinceCheck: number;
+  /** Peak byte usage observed within the current shrink window. */
+  windowPeakBytes: number;
+}
+/**
+ * WeakMap-keyed retained tier: manages stable GPU instance buffers for
+ * `UberPack` instances whose paint and data damage bits are both clear.
+ *
+ * Lifecycle per frame:
+ * ```ts
+ * if (!tier.has(pack)) {
+ *   tier.build(pack);          // damage present — reallocate/upload
+ * }
+ * tier.tickShrink(pack);       // always call at frame end
+ * const rec = tier.get(pack)!; // use rec.gpuBuffer for draw calls
+ * ```
+ */
+declare class RetainedTier {
+  private readonly root;
+  private readonly records;
+  constructor(root: TgpuRoot);
+  /**
+   * Returns `true` iff a retained record exists for `pack` (damage-miss path:
+   * caller skips `build`).  The RetainedTier itself never suppresses a build
+   * — that decision belongs to the caller.
+   */
+  has(pack: UberPack): boolean;
+  /**
+   * Retrieve the retained record for `pack` without triggering a build.
+   * Returns `undefined` if `has(pack)` is false.
+   */
+  get(pack: UberPack): RetainedRecord | undefined;
+  /**
+   * Build or rebuild the GPU buffer for `pack`.  Call only when paint/data
+   * damage is present.
+   *
+   * - Reuses the existing buffer if it is large enough (range write only).
+   * - Reallocates with the pow2-then-1.25× policy when the buffer is too small.
+   */
+  build(pack: UberPack): RetainedRecord;
+  /**
+   * Advance the shrink window for `pack`.  Call once per frame per retained
+   * pack (regardless of whether `build` was called this frame).
+   *
+   * After `SHRINK_WINDOW_FRAMES` consecutive frames where the peak byte usage
+   * is below `gpuCapacityBytes / SHRINK_PEAK_RATIO`, the GPU buffer is
+   * reallocated to a smaller size.
+   */
+  tickShrink(pack: UberPack): void;
+  /**
+   * Destroy the GPU buffer for `pack` and remove its record.  Call when the
+   * layer is uncached or destroyed.
+   */
+  evict(pack: UberPack): void;
+  /**
+   * Drop all retained state. This method is intentionally a no-op: the WeakMap
+   * holds no strong references and cannot iterate to destroy GPU buffers — callers
+   * MUST call `evict(pack)` for every registered pack before calling `destroy()`.
+   * After this call the `RetainedTier` is unusable.
+   *
+   * Contract: all GPU buffers are the owner's responsibility. `destroy()` does
+   * not destroy them; failing to evict before drop leaks GPU memory.
+   */
+  destroy(): void;
+}
+//#endregion
+//#region src/tiers/tile-replay.d.ts
+/** Screen-device-px AABB used by {@link TileGrid.assign}. Mirrors the v3
+ * `WorldAABB` shape (`kinds/kind.ts`) but in already-projected screen pixels. */
+interface ScreenAABB {
+  minX: number;
+  minY: number;
+  maxX: number;
+  maxY: number;
+}
+/**
+ * Row-major grid of command buckets over screen device-px space. The grid is
+ * built once per layout: every command is assigned to the tiles its dilated
+ * AABB touches, and a dirty-rect query returns the union of the touched tiles'
+ * buckets.
+ */
+declare class TileGrid {
+  /** Tile edge length in device px (== {@link RendererConfig.tileSize}). */
+  readonly cellSize: number;
+  readonly cols: number;
+  readonly rows: number;
+  /** Flat row-major array: `buckets[tileId]` = cmdIndex list (insertion order). */
+  private readonly buckets;
+  constructor(canvasW: number, canvasH: number, cellSize: number);
+  /** Row-major tile id for a `(col, row)` cell. */
+  tileId(col: number, row: number): number;
+  /**
+   * Rasterize an AABB (device px, half-open `[min, max)`) to the tile ids it
+   * touches. The AABB is dilated by +1px on every side before rasterizing so a
+   * shape's analytic anti-aliased fringe (which spills ≤1px past the geometric
+   * edge) is conservatively included — a shape sitting on a tile seam lands in
+   * both tiles. Out-of-range cells are clamped to the grid; a fully off-grid
+   * AABB yields an empty list.
+   */
+  tilesForAabb(minX: number, minY: number, maxX: number, maxY: number): number[];
+  /**
+   * Rasterize a {@link FrameRect} (CSS px) to a tile-id set. The rect is first
+   * padded by 1px — the SAME `padFrameRect(rect, 1)` the T22 clear-quad step
+   * applies — then converted to device px via `dpr`, then handed to
+   * {@link tilesForAabb} (which adds its own +1px AA dilation). The query rect
+   * thus covers at least the pixels the per-rect erase will actually repaint.
+   */
+  tilesForRect(rect: FrameRect, dpr: number): Set<number>;
+  /**
+   * Assign a command (by its index in the renderer's command array) to every
+   * tile its screen AABB intersects. The same +1px AA dilation as
+   * {@link tilesForAabb} applies, so a command straddling a tile boundary is
+   * dropped into every touched bucket — the dirty-rect query then issues it
+   * exactly once per region pass (via {@link commandsForTiles} dedup).
+   */
+  assign(cmdIndex: number, aabb: ScreenAABB): void;
+  /**
+   * Union of command indices across a set of tile ids, deduplicated and sorted
+   * ascending. Ascending = original scene/submission order, so the caller's
+   * opaque-reverse sweep (`for i = n-1 … 0`) and transparent-forward sweep match
+   * v1's painter stacking. A command in two dirty tiles appears once.
+   */
+  commandsForTiles(tileIds: Set<number>): number[];
+  /** Total tile count (`cols × rows`). */
+  get totalTiles(): number;
+}
+/**
+ * Full-frame fallback threshold. When the dirty-tile fraction exceeds this,
+ * {@link dirtyTileSet} returns `null` so the caller skips bucket replay and runs
+ * a single full-frame pass instead — thousands of scissor switches across most
+ * of the canvas cost more than one unscissored re-render.
+ */
+declare const FULL_FRAME_TILE_FRACTION = 0.5;
+/**
+ * Map damage regions to the set of tile ids to replay. Unions the tiles each
+ * region touches (via {@link TileGrid.tilesForRect}). Returns `null` — NOT an
+ * empty set — when the dirty fraction strictly exceeds
+ * {@link FULL_FRAME_TILE_FRACTION}, signalling "fall back to a full frame". An
+ * empty/zero-area region set returns an empty `Set` (nothing to replay), which
+ * the caller distinguishes from `null`.
+ */
+declare function dirtyTileSet(grid: TileGrid, regions: readonly FrameRect[], dpr: number): Set<number> | null;
+//#endregion
+//#region src/damage/spine.d.ts
+interface FrameSpineOptions {
+  /**
+   * Scheduler implementation. Defaults to RAFScheduler (production). Pass a
+   * ManualScheduler (or createTestSpine) for deterministic unit tests.
+   */
+  scheduler?: Scheduler;
+  /**
+   * Called each flush with the coalesced dirty regions. Fires only when at
+   * least one non-empty mark() was accumulated since the last flush.
+   */
+  onFlush: (regions: DirtyRegion) => void;
+}
+/**
+ * Frame-loop primitive for v3. Owns a DirtyChannel<DirtyRegion> wired to a
+ * Scheduler. Callers mark damage via mark(); the channel coalesces and
+ * schedules a single flush that invokes onFlush with the union of all marked
+ * regions. Empty flushes (no mark since last pump) are suppressed by the
+ * DirtyChannel itself.
+ *
+ * T61's GpuSceneRoot owns one FrameSpine and delegates damage marking to it.
+ */
+declare class FrameSpine {
+  #private;
+  readonly channel: DirtyChannel<DirtyRegion>;
+  readonly scheduler: Scheduler;
+  constructor({
+    scheduler,
+    onFlush
+  }: FrameSpineOptions);
+  /**
+   * Accumulate damage and schedule a flush. An empty regions array is a
+   * fast-path no-op — nothing is scheduled.
+   */
+  mark(regions: DirtyRegion): void;
+  /**
+   * Dispose the spine. Removes the subscriber and cancels any pending
+   * scheduled flush.
+   */
+  dispose(): void;
+}
+/**
+ * Creates a FrameSpine backed by a ManualScheduler. Call pump() to drain
+ * any pending flush synchronously.
+ *
+ * @example
+ * const { spine, pump } = createTestSpine((r) => calls.push(r));
+ * spine.mark([{ rect: { x: 0, y: 0, w: 10, h: 10 }, kind: "paint" }]);
+ * pump(); // fires onFlush once
+ */
+declare function createTestSpine(onFlush: (r: DirtyRegion) => void): {
+  spine: FrameSpine;
+  pump: () => void;
+};
+//#endregion
+//#region src/pipelines/glyph-pipelines.d.ts
+/**
+ * Per-bake glyph parameters uniform. 16 bytes (one vec4f slot):
+ *   pxRange   — atlas distance range in texels (`GlyphAtlas.pxRange`).
+ *   atlasSize — atlas side length in texels (`GlyphAtlas.atlasSize`).
+ *   _pad0, _pad1 — reserved (keep the uniform 16-byte aligned).
+ *
+ * Both values are constant for one atlas, so one upload per bake is enough.
+ */
+declare const GLYPH_PARAMS_FLOATS = 4;
+declare const GLYPH_PARAMS_BYTES: number;
+/**
+ * Bind-group layouts + render pipeline for the MSDF glyph bake pass.
+ *
+ * `cameraLayout` / `instanceLayout` are structurally identical to
+ * `Pipelines.cameraLayout` / `.instanceLayout`, but they are built HERE
+ * (own objects) so the glyph pipeline does not depend on `pipelines.ts` plumbing
+ * the bake never receives. The bake builds ONE camera bind group + ONE instances
+ * bind group against the bake-shape layouts and reuses them for the glyph draw —
+ * see the binding-compatibility note in `tiers/bake.ts`.
+ */
+interface GlyphPipelineSet {
+  /** Transparent (alpha-blended, depth-test-only) MSDF glyph pipeline. */
+  pipeline: GPURenderPipeline;
+  /** `@group(0)` camera uniform layout (Camera { vpCol0, vpCol1, vpCol2 }). */
+  cameraLayout: GPUBindGroupLayout;
+  /** `@group(1)` read-only instance storage layout. */
+  instanceLayout: GPUBindGroupLayout;
+  /** `@group(2)` atlas texture + sampler + glyph-params uniform layout. */
+  atlasLayout: GPUBindGroupLayout;
+}
+/**
+ * Build the MSDF glyph bake pipeline + its three bind-group layouts.
+ *
+ * @param device      The GPU device (from `root.device`).
+ * @param format      Bake color-target format (the canvas/ctx format).
+ * @param sampleCount MSAA sample count — `config.msaaBakes` (1 | 4). MUST match
+ *   the shape bake pipelines and the bake pass's color/depth attachments.
+ */
+declare function createGlyphPipeline(device: GPUDevice, format: GPUTextureFormat, sampleCount: number): GlyphPipelineSet;
+//#endregion
+//#region src/tiers/bake.d.ts
+/**
+ * Write a 3x3 view-projection `Mat3` plus the viewport/dpr tail into the
+ * 10-float Camera uniform layout. `viewportDevW`/`viewportDevH` are the render
+ * target's DEVICE-pixel extent; `dpr` the device pixel ratio. They default to 0
+ * for the bake path (anchored text re-projects live, not from a bake), where
+ * only the matrix prefix is meaningful.
+ */
+declare function packCamera(vp: Mat3, out: Float32Array, viewportDevW?: number, viewportDevH?: number, dpr?: number): void;
+/** Minimal canvas-size source — width/height in device pixels. */
+interface BakeSizeSource {
+  readonly width: number;
+  readonly height: number;
+}
+/**
+ * Compute the bake-time view projection for a layer.
+ *
+ *   - `world`  : `projection(w, h) x scaling(dpr) x viewFromCamera(camera,
+ *     w/dpr, h/dpr)` (CSS-px camera baseline) — the camera is FROZEN at the
+ *     instant the bake is requested (the matrix is computed from the camera
+ *     snapshot passed in; subsequent camera mutation does not alter the
+ *     returned matrix).
+ *   - `ui`     : `projection(w / dpr, h / dpr)` (CSS-px coordinate space).
+ *
+ * `cacheSize` overrides the target dimensions (matches v1's `layer.cacheSize`);
+ * when absent the canvas `ctx` size is used.
+ */
+declare function bakeViewProjection(space: LayerSpace, ctx: BakeSizeSource, camera: CameraState, dpr: number, cacheSize?: {
+  width: number;
+  height: number;
+}): Mat3;
+/**
+ * Allocate the single-sample bake target texture. The MSAA pass resolves into
+ * this; it is also `TEXTURE_BINDING` so the composited result can be sampled
+ * back as a sprite by the layer that owns the bake. Caller must `destroy()` it.
+ */
+declare function createBakeTexture(device: GPUDevice, format: GPUTextureFormat, width: number, height: number): GPUTexture;
+/**
+ * The pipelines a bake draws with. Built once per (format, sampleCount) and
+ * reused across bakes. ALL pipelines share `sampleCount` and `DEPTH_FORMAT` so
+ * one MSAA color + one MSAA depth attachment serve every draw in the pass.
+ */
+interface BakePipelineSet {
+  /** Opaque shape pass (depth write on, src-replace). MSAA. */
+  shapeOpaque: GPURenderPipeline;
+  /** Transparent shape pass (depth test only, premultiplied src-over). MSAA. */
+  shapeTransparent: GPURenderPipeline;
+  /** MSDF glyph pipeline + its bind-group layouts. MSAA. */
+  glyph: GlyphPipelineSet;
+  /** `@group(0)` camera layout shared by shape + glyph passes. */
+  cameraLayout: GPUBindGroupLayout;
+  /** `@group(1)` instance-storage layout shared by shape + glyph passes. */
+  instanceLayout: GPUBindGroupLayout;
+}
+/**
+ * Build the bake pipeline set for a `(format, sampleCount)` pair.
+ *
+ * The shape pipelines reuse `assembleShader`'s `vertex` + `opaque` / `transparent`
+ * WGSL VERBATIM — the same source the main (single-sample) pipelines use — but
+ * are created with `multisample: { count: sampleCount }`. Their `@group(0)` and
+ * `@group(1)` layouts are structurally identical to `Pipelines.cameraLayout`
+ * / `.instanceLayout` (and to the glyph pipeline's), so ONE camera bind group +
+ * ONE instances bind group bind against every draw in the bake pass.
+ *
+ * @param sampleCount `config.msaaBakes` (1 | 4).
+ */
+declare function createBakePipelines(device: GPUDevice, format: GPUTextureFormat, shader: AssembledShader, sampleCount: number): BakePipelineSet;
+/** Inputs the bake draws into the target. */
+interface BakeInput {
+  /** Shape instances (UberPack). May be empty (text-only bake). */
+  shapes: UberPack;
+  /**
+   * Optional glyph instances (GlyphPack). When present and non-empty, drawn
+   * after the shapes, inside the SAME render pass.
+   */
+  glyphs?: GlyphPack | null;
+  /**
+   * MSDF atlas the glyphs reference: provides the texture/sampler and the
+   * `pxRange` / `atlasSize` for the screen-px AA. Required iff `glyphs` is
+   * non-empty.
+   */
+  atlas?: BakeAtlas | null;
+}
+/**
+ * The atlas facts the glyph pass needs. A `GlyphAtlas` (`text/text-font.ts`)
+ * satisfies this — `atlas.texture.view` is the bindable `GPUTextureView`.
+ */
+interface BakeAtlas {
+  /** Atlas texture (its `.view` is bound to `@group(2) @binding(0)`). */
+  readonly texture: {
+    readonly view: GPUTextureView;
+  };
+  /** Distance range in atlas texels. */
+  readonly pxRange: number;
+  /** Atlas side length in texels (square). */
+  readonly atlasSize: number;
+}
+/** Per-call bake options. */
+interface BakeOptions {
+  /** Caller-owned single-sample resolve target (from `createBakeTexture`). */
+  target: GPUTexture;
+  /** Target width in pixels. */
+  width: number;
+  /** Target height in pixels. */
+  height: number;
+  /** Frozen view-projection (from `bakeViewProjection`). */
+  viewProjection: Mat3;
+  /** Clear color for the bake (typically transparent). */
+  clearColor: Color;
+  /**
+   * Sampler for the glyph atlas (filtering). Only needed when glyphs are drawn.
+   * The renderer owns/caches this; the bake binds it for one pass.
+   */
+  glyphSampler?: GPUSampler | null;
+  /**
+   * Optional crop rect in DEVICE pixels (the layer's `clipRect` resolved by the
+   * caller). When set, the bake pass is scissored to it so the snapshot matches
+   * the clipped live render — geometry outside the rect stays the cleared
+   * (transparent) background and never composites. `null`/absent = no crop.
+   */
+  clip?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  } | null;
+}
+/**
+ * Run a single-submit RTT bake pass: `config.msaaBakes`x MSAA -> resolve into
+ * `opts.target`. Shapes (opaque reverse, transparent forward) then glyphs
+ * (transparent, scene order) are drawn into ONE render pass so the baked
+ * snapshot is complete — no live text re-emission needed on top.
+ *
+ * Scratch MSAA color + depth textures and all per-bake GPU buffers are created
+ * and destroyed within this call. The camera uniform / instances buffers /
+ * glyph-params uniform are uploaded fresh each bake (a bake is a rare,
+ * settle-time event — not a per-frame cost).
+ */
+declare function runBakePass(device: GPUDevice, config: RendererConfig, input: BakeInput, pipelines: BakePipelineSet, opts: BakeOptions): void;
+//#endregion
+//#region src/damage/scene-root.d.ts
+interface PaintCtx {
+  /** The in-scope scene layer that descendant nodes paint into. */
+  readonly layer: Layer;
+  /** Per-frame inputs for the `project` hook (camera / group / dpr / viewport). */
+  readonly projectOpts: ProjectOptions;
+}
+declare abstract class GpuSceneNode extends SceneNode {
+  /**
+   * Emit this node's geometry into `ctx.layer`. Called with the live frame
+   * context — NO `gpuRoot()` re-walk. Implementations push shapes via the
+   * `Layer.pushXxx` API and may read `ctx.projectOpts` for screen-pixel math.
+   */
+  abstract drawSelf(ctx: PaintCtx): void;
+  /**
+   * Paint this node's WHOLE subtree (self + every descendant), threading the
+   * SAME `ctx`. This is the uncull­ed entry used when a caller wants to force a
+   * subtree repaint regardless of damage. The damage-tracked frame path does NOT
+   * call this — it uses {@link GpuSceneRoot}'s recursive cull, which tests every
+   * node's bounds against the damage regions and prunes missed subtrees. Keeping
+   * the cull out of `paint` means a hit subtree still walks fully, while the cull
+   * decides which subtrees to enter.
+   */
+  paint(ctx: unknown): void;
+  /**
+   * Project this node's bounds to a screen-pixel `FrameRect` via the T21
+   * `project` hook. Call this BEFORE `markDamaged` when a node authors in a
+   * non-`ui` space so the emitted damage rect already lives in the screen-pixel
+   * space the cull + scissor share. (For a plain `ui` scene graph the bounds are
+   * already CSS px and `markDamaged` may be called directly.)
+   *
+   * `space` defaults to `"ui"` — the natural space for a CSS-pixel scene graph
+   * whose `bounds` are authored in screen pixels.
+   */
+  protected projectBounds(ctx: PaintCtx, space?: "world" | "ui"): FrameRect;
+  /** Mark a visual-only change: repaint, no data/layout rebuild. */
+  invalidatePaint(rect?: Rect): void;
+  /** Mark a layout change (bounds/children moved). Triggers doLayout + paint. */
+  invalidateLayout(rect?: Rect): void;
+  /** Mark a data change (inputs replaced). Triggers rebuildData → layout → paint. */
+  invalidateData(rect?: Rect): void;
+}
+interface GpuSceneRootOptions {
+  /**
+   * Scheduler for the FrameSpine (and the base SceneRoot's inert channel).
+   * Defaults to a RAFScheduler in production; pass a ManualScheduler (or use a
+   * test spine) for deterministic unit tests.
+   */
+  scheduler?: Scheduler;
+  /**
+   * Repaint every node on any damage and ignore the per-node cull. Default
+   * `false` — the recursive cull is the whole point. Set `true` only as a
+   * cost-comparison baseline or when the scene layer is cleared+re-emitted whole
+   * each frame and culled-out nodes would otherwise vanish.
+   */
+  fullFrame?: boolean;
+  /** Optional per-frame CPU timing hook (layout vs paint, painted-node count). */
+  onFrameTiming?: (timing: SpatialFrameTiming) => void;
+  /**
+   * Per-frame `project` inputs (camera / group / dpr / viewport). A thunk so the
+   * caller can update the camera/dpr/viewport between frames without rebuilding
+   * the root. The returned options seed `PaintCtx.projectOpts` and the `viewKey`
+   * fold. Required so the screen-pixel project space matches the renderer.
+   */
+  projectOpts: () => ProjectOptions;
+  /**
+   * Active group transforms folded into the `viewKey`. A thunk re-read each
+   * frame: whenever ANY returned group's compounded transform changes, the
+   * folded key changes and the renderer forces a full frame (no ghosting). Pass
+   * the groups whose moves should invalidate the partial path.
+   */
+  groups?: () => readonly Group[];
+  /**
+   * Extra data-domain key folded into the `viewKey` after the group transforms.
+   * Change it whenever a non-transform input (a plot's data domain, a palette)
+   * changes the whole-canvas mapping. A thunk re-read each frame.
+   */
+  dataKey?: () => string;
+}
+declare class GpuSceneRoot extends SceneRoot implements SpatialRenderer2D {
+  /** The scene layer that descendant nodes paint into. */
+  readonly layer: Layer;
+  /** The underlying v3 WebGPU renderer. */
+  readonly gpu: Renderer2D;
+  /** Reverse-z pointer routing with per-pointerId capture/drag/hover. */
+  readonly pointer: PointerRouter;
+  /**
+   * When `true`, repaint every node on any damage and ignore the per-node cull
+   * (set from {@link GpuSceneRootOptions.fullFrame}, default `false`).
+   * Passed through to `endFrame()` so the renderer does a full repaint.
+   */
+  fullFrame: boolean;
+  private readonly _spine;
+  private readonly _projectOpts;
+  private readonly _groups?;
+  private readonly _dataKey?;
+  /** Our own copy of the timing hook — the base keeps `onFrameTiming` private,
+   * and we override `_renderFrame`, so we read it directly. */
+  private readonly _onFrameTiming?;
+  /** Damage regions handed to the in-flight `beginFrame`; consumed by `endFrame`. */
+  private _currentRegions;
+  constructor(gpu: Renderer2D, layer: Layer, options: GpuSceneRootOptions);
+  /** Stash the frame's damage regions and clear the scene layer. */
+  beginFrame(regions: readonly Rect[]): void;
+  /**
+   * Submit one v3 GPU frame. Each damage `Rect` maps to ONE `Bounds2D` region
+   * (1:1 — never unioned), so the renderer's per-rect scissor path repaints each
+   * disjoint rect independently. `viewKey` folds the active group transforms +
+   * data key so a group move forces a full frame.
+   */
+  endFrame(): void;
+  /**
+   * Called by `SceneNode.markDamaged` (structural-type contract:
+   * `typeof root._emitDamage === "function"`). Routes the damage into the
+   * FrameSpine instead of the base SceneRoot's own channel, so a single
+   * coalesced flush per frame drives `_renderFrameV3`.
+   */
+  _emitDamage(damage: Damage): void;
+  /** Force a full repaint of the whole root bounds on the next scheduled frame. */
+  requestPaint(): void;
+  /**
+   * Mark a paint-damage region directly on the root (CSS px). Useful when an
+   * external surface (a resize, a host overlay) damages a screen rect that is
+   * not owned by a single node. Routes through the spine like any node damage.
+   */
+  requestPaintRegion(rect: Rect): void;
+  /**
+   * Run one frame from a coalesced dirty set. Mirrors the base SceneRoot
+   * pipeline (rebuildData on data-damage, doLayout on non-paint damage) but
+   * replaces the one-level `_paintCulled` with the recursive cull and uses our
+   * own `beginFrame`/`endFrame`. `fullFrame` repaints the whole bounds.
+   */
+  private _renderFrameV3;
+  /**
+   * Recursive damage cull — the v3 fix for v1's one-level cull. For each child
+   * of `node`: if its bounds miss EVERY region, prune the entire subtree (no
+   * `drawSelf`, no recursion into ITS children). On a hit, paint the child via
+   * `drawSelf(ctx)` and recurse — so the SAME per-region test applies at every
+   * depth, not just the root's direct children. A leaf deep in a large container
+   * therefore repaints only the nodes whose AABB actually touches a damage rect,
+   * and the cost scales with the damaged area, not the scene size.
+   *
+   * Pruning a missed subtree is sound: a node's bounds are expected to bound its
+   * own painted geometry (and, when it `clipsOverflow`, its descendants too), so
+   * a subtree whose AABB misses every damage rect contributes nothing inside any
+   * rect. (Nodes that paint outside their declared bounds must widen `bounds`.)
+   *
+   * Note: this does NOT call `GpuSceneNode.paint` (which would recurse
+   * unconditionally and defeat the deep cull) — it owns the descent itself.
+   */
+  private _paintCulledRecursive;
+  /**
+   * Composite `viewKey`: fold every active group's compounded transform, then
+   * the data key, into one string. Handed to `render(..., { viewKey })`; a
+   * change flips the renderer's view fingerprint and forces a full frame.
+   */
+  private _viewKey;
+  /**
+   * Dispatch a pointer event through the {@link PointerRouter}: `down` hit-tests
+   * (reverse-z, last-child-wins, depth-first — the inherited `SceneRoot.hitTest`)
+   * and captures by `pointerId`; `move`/`up`/`cancel` route to the captured node
+   * (or, for an uncaptured `move`, re-hit). Returns the receiving node or null.
+   */
+  dispatchPointer(e: SpatialPointerEvent): SceneNode | null;
+  /** Dispose the frame spine (removes the subscriber, cancels any pending flush). */
+  dispose(): void;
+}
+/** Convert a spatial `Rect` to the renderer's `Bounds2D` damage-region shape. */
+declare function rectToBounds(r: Rect): Bounds2D;
+//#endregion
+//#region src/pipelines/composite-pipelines.d.ts
+/**
+ * Composite-quad uniform: destination NDC rect + source UV rect. 8 floats / 32
+ * bytes (two vec4f):
+ *   rectNdc = (ndcMinX, ndcMinY, ndcMaxX, ndcMaxY)
+ *   rectUv  = (uvMinX,  uvMinY,  uvMaxX,  uvMaxY)
+ */
+declare const COMPOSITE_UNIFORM_FLOATS = 8;
+declare const COMPOSITE_UNIFORM_BYTES: number;
+/** Bind-group layout + pipeline for the textured-quad composite. */
+interface CompositePipelineSet {
+  /** Premultiplied-over textured-quad pipeline (no depth, single-sample). */
+  pipeline: GPURenderPipeline;
+  /**
+   * In-MAIN-PASS composite variant (T-ZBAKE). Identical shader / bind-group
+   * layout / topology / target blend as {@link pipeline}, but it declares the
+   * main pass's depth attachment (WebGPU requires a pipeline's `depthStencil` to
+   * match the pass it runs in) while neither writing nor testing depth
+   * (`depthWriteEnabled:false`, `depthCompare:"always"`). A bake is a translucent
+   * IMAGE — writing depth would let it occlude live geometry through its own
+   * transparent texels — so depth is intentionally inert. Drawn at the START of
+   * the main pass (full frame) or right after the per-rect erase (partial frame)
+   * so the LEADING z-run of bakes lands UNDER all live geometry.
+   */
+  pipelineInPass: GPURenderPipeline;
+  /**
+   * `@group(0)` layout: the composite uniform (vertex+fragment) + the sampled
+   * texture + a filtering sampler.
+   */
+  layout: GPUBindGroupLayout;
+}
+/**
+ * Build the textured-quad composite pipeline + its bind-group layout.
+ *
+ * @param device WebGPU device.
+ * @param format Color-target format (the canvas/backbuffer format).
+ */
+declare function createCompositePipeline(device: GPUDevice, format: GPUTextureFormat): CompositePipelineSet;
+/**
+ * Fill the composite uniform for a full-screen bake (the cacheLayer case): the
+ * destination covers the whole NDC viewport and the source samples the entire
+ * texture, with the Y-UV flipped so a texture rendered in NDC (+y up) reads back
+ * upright in UV (v=0 at top).
+ */
+declare function packFullScreenComposite(out: Float32Array): void;
+//#endregion
+//#region src/pipelines/sprite-pipelines.d.ts
+/** A built sprite pipeline pair (opaque + transparent variants share layouts). */
+interface SpritePipelineSet {
+  /** Opaque variant: depth-write on, src-replace, alpha-discard at 0.5. */
+  opaque: GPURenderPipeline;
+  /** Transparent variant: depth-test only, premultiplied ALPHA_BLEND. */
+  transparent: GPURenderPipeline;
+  /** `@group(0)` camera layout — 6-float Camera, binds the v3 camera slots. */
+  cameraLayout: GPUBindGroupLayout;
+  /** `@group(1)` read-only-storage layout over the external sprite buffer. */
+  bufferLayout: GPUBindGroupLayout;
+  /** `@group(2)` texture + sampler layout. */
+  textureLayout: GPUBindGroupLayout;
+  /** Per-draw `InteropDraw { z }` uniform layout (`@group(N)`). */
+  drawLayout: GPUBindGroupLayout;
+  /** Group index of the {@link drawLayout} — 3 for sprites. */
+  drawGroup: number;
+}
+/**
+ * Built sprite OIT emit pipeline. Appends premultiplied `(rgba, depth)` fragments
+ * into the shared A-buffer at `@group(3)` instead of alpha-blending to the color
+ * target. The existing opaque/transparent sprite pipelines stay; Phase 4 routes
+ * transparent sprites to this pipeline when OIT is enabled.
+ */
+interface SpriteOitEmitPipeline {
+  /** The single pipeline: `writeMask:0`, depth-test-only, OIT A-buffer append. */
+  pipeline: GPURenderPipeline;
+  /** `@group(0)` camera layout — 6-float Camera, binds v3 camera slots. */
+  cameraLayout: GPUBindGroupLayout;
+  /** `@group(1)` read-only-storage layout over the `SpriteSchema` buffer. */
+  bufferLayout: GPUBindGroupLayout;
+  /** `@group(2)` texture + sampler layout (one texture per draw command). */
+  textureLayout: GPUBindGroupLayout;
+  /**
+   * `@group(3)` A-buffer layout (build-style: heads + slots `storage`, viewport
+   * `uniform`). Created via {@link ABuffer.buildLayoutAt}(3).
+   */
+  abufferLayout: GPUBindGroupLayout;
+}
+/**
+ * WGSL for the sprite OIT emit pipeline. The VS reads per-instance `sp.order`
+ * (float offset 15, stamped by Phase 1 {@link SpritePack.stampOrder}) for
+ * `out.pos.z` so sprites z-interleave with shapes/glyphs in true push order.
+ * The FS computes premultiplied color, calls `oitAppend`, and returns `vec4f(0.0)`
+ * into a `writeMask:0` target.
+ *
+ * @internal — exported for unit testing only.
+ */
+declare function spriteOitEmitWgsl(): string;
+/**
+ * Build the SPRITE OIT emit pipeline. Samples the per-command texture at
+ * `@group(2)` and appends premultiplied fragments into the shared A-buffer at
+ * `@group(3)`. Writes no color (`writeMask:0`); depth-tests but does not write
+ * (`depthWriteEnabled:false`).
+ *
+ * Bind-group convention (per design.md):
+ *   `@group(0)` — 6-float Camera (v3 camera slots)
+ *   `@group(1)` — read-only-storage `SpriteSchema` array
+ *   `@group(2)` — texture + sampler (one per draw command)
+ *   `@group(3)` — A-buffer (via `abuffer.buildLayoutAt(3)` / `buildBindGroupFor()`)
+ *
+ * @param device  WebGPU device.
+ * @param format  Color attachment format (must match the render pass; `writeMask:0`
+ *   means nothing is written, but the target format must still be declared).
+ * @param abuffer {@link ABuffer} instance — provides `buildLayoutAt(3)` for the
+ *   pipeline layout and `buildBindGroupFor()` for per-pass bind.
+ * @param sampleCount Multi-sample count for the main render pass (1 for live OIT —
+ *   NOT the bake MSAA count; see design.md §Risks "MSAA mismatch").
+ */
+declare function createSpriteOitEmitPipeline(device: GPUDevice, format: GPUTextureFormat, abuffer: ABuffer, sampleCount?: number): SpriteOitEmitPipeline;
+/**
+ * Build the SPRITE pipeline pair (v1 64 B `SpriteSchema` external buffer
+ * + a texture). `@group(0)` = 6-float Camera (v3 slots), `@group(1)` =
+ * read-only-storage `SpriteSchema` array, `@group(2)` = texture + sampler,
+ * `@group(3)` = `InteropDraw { z }`. Drives the `Layer.pushSprite` path
+ * (`_encodeLayerSprites`) — textured quads accumulated CPU-side into a per-layer
+ * `SpritePack` (e.g. plot's heatmap geom drawing a compute texture).
+ */
+declare function createSpritePipelines(device: GPUDevice, format: GPUTextureFormat): SpritePipelineSet;
+//#endregion
+//#region src/pipelines/instance-pipelines.d.ts
+/** Per-buffer draw uniform: a single near-z, 16 B (one vec4f slot). Shared
+ * wire format with `sprite-pipelines.ts` (same `InteropDraw` WGSL struct). */
+declare const INSTANCE_DRAW_FLOATS = 4;
+declare const INSTANCE_DRAW_BYTES: number;
+/** A built external-instance pipeline pair (opaque + transparent share layouts). */
+interface InstancePipelineSet {
+  /** Opaque variant: depth-write on, src-replace, alpha-discard at 0.5. */
+  opaque: GPURenderPipeline;
+  /** Transparent variant: depth-test only, premultiplied ALPHA_BLEND. */
+  transparent: GPURenderPipeline;
+  /** `@group(0)` camera layout — 6-float Camera, binds the v3 camera slots. */
+  cameraLayout: GPUBindGroupLayout;
+  /** `@group(1)` read-only-storage layout over the external `Instance` buffer. */
+  bufferLayout: GPUBindGroupLayout;
+  /** Per-buffer `InteropDraw { z }` uniform layout (`@group(2)`). */
+  drawLayout: GPUBindGroupLayout;
+  /** Group index of {@link drawLayout} — always 2 for instances. */
+  drawGroup: number;
+}
+/**
+ * Build the EXTERNAL-INSTANCE pipeline pair (v3 64 B `Instance` external buffer).
+ *
+ * `@group(0)` = 6-float Camera (binds v3 camera slots), `@group(1)` =
+ * read-only-storage `array<InstanceStruct>`, `@group(2)` = `InteropDraw { z }`.
+ * Opaque + transparent variants share all three layouts.
+ */
+declare function createInstancePipelines(device: GPUDevice, format: GPUTextureFormat): InstancePipelineSet;
+/** A built external-instance OIT-emit pipeline. Appends premultiplied `(rgba,
+ * depth)` into the shared A-buffer at `@group(3)` instead of blending. */
+interface InstanceOitEmitPipeline {
+  /** The single pipeline: `writeMask:0`, depth-test-only, OIT A-buffer append. */
+  pipeline: GPURenderPipeline;
+  /** `@group(0)` camera layout — 6-float Camera, binds v3 camera slots. */
+  cameraLayout: GPUBindGroupLayout;
+  /** `@group(1)` read-only-storage layout over the external `Instance` buffer. */
+  bufferLayout: GPUBindGroupLayout;
+  /** `@group(2)` per-buffer `InteropDraw { z }` uniform layout. */
+  drawLayout: GPUBindGroupLayout;
+  /** `@group(3)` A-buffer layout (via {@link ABuffer.buildLayoutAt}(3)). */
+  abufferLayout: GPUBindGroupLayout;
+}
+/**
+ * WGSL for the external-instance OIT-emit pipeline. Same SDF switch as the
+ * opaque/transparent variants; the FS calls `oitAppend` with the premultiplied
+ * `outColor` and the per-buffer near-z (`in.pos.z`, written from `drawParams.z`
+ * in the vertex stage) so external instances composite through the unchanged
+ * resolve pass.
+ *
+ * @internal — exported for unit testing only.
+ */
+declare function instanceOitEmitWgsl(): string;
+/**
+ * Build the EXTERNAL-INSTANCE OIT-emit pipeline. Shares the vertex stage with
+ * {@link createInstancePipelines} (so the geometry expansion + near-z stamp are
+ * identical) and appends premultiplied fragments into the shared A-buffer at
+ * `@group(3)`. Writes no color (`writeMask:0`); depth-tests but does not write.
+ *
+ * Bind-group convention:
+ *   `@group(0)` — 6-float Camera (v3 camera slots)
+ *   `@group(1)` — read-only-storage `array<InstanceStruct>`
+ *   `@group(2)` — `InteropDraw { z }` per-buffer near-z
+ *   `@group(3)` — A-buffer (via `abuffer.buildLayoutAt(3)` / `buildBindGroupFor()`)
+ */
+declare function createInstanceOitEmitPipeline(device: GPUDevice, format: GPUTextureFormat, abuffer: ABuffer, sampleCount?: number): InstanceOitEmitPipeline;
+//#endregion
+export { ABuffer, ARC_FLOATS, BUILD_SPATIAL_HASH_WGSL, type BakeAtlas, type BakeInput, type BakeOptions, type BakePipelineSet, type BakeSizeSource, CLEAR_SPATIAL_HASH_WGSL, COMPOSITE_UNIFORM_BYTES, COMPOSITE_UNIFORM_FLOATS, CURVE_CAP_BUTT, CURVE_CAP_ROUND, CURVE_CAP_SQUARE, CURVE_FLOATS, type CompositePipelineSet, type CullCommand, type CullResult, type CulledRange, type DebugSize, type DebugSpace, type DirtyRange, type DirtyRegion, type DrawCommand, FRAME_RING_CAPACITY, FULL_FRAME_TILE_FRACTION, type FrameDebugListener, FrameRing, FrameSpine, type FrameSpineOptions, type FrameSummary, GLYPH_PARAMS_BYTES, GLYPH_PARAMS_FLOATS, type GPUOwner, type GlyphPipelineSet, GpuSceneNode, GpuSceneRoot, type GpuSceneRootOptions, HEAD_BYTES, INSTANCE_DRAW_BYTES, INSTANCE_DRAW_FLOATS, type InstanceOitEmitPipeline, type InstancePipelineSet, type LayerSummary, type OITPipelineDeps, type OITPipelines, type PaintCtx, type RectXYWH, RegionIndex, RendererDebug, type RetainedRecord, RetainedTier, SEGMENT_FLOATS, SHAPE_BYTES, SHAPE_CIRCLE, SHAPE_ELLIPSE, SHAPE_RECT, SLOT_BYTES, SPATIAL_HASH_PARAMS_BYTES, SPATIAL_HASH_PARAMS_WGSL, SPATIAL_HASH_WORKGROUP_SIZE, type ScreenAABB, ShapeSchema, type SpaceMap, type SpatialGrid, type SpatialGridOptions, type SpatialGridResult, type SpatialRange, type SpriteOitEmitPipeline, type SpritePipelineSet, SpriteSchema, TRIANGLE_FLOATS, TileGrid, UberPack, bakeViewProjection, blitBackbuffer, buildSpatialGrid, captureSpaceMap, convertRect, createBakePipelines, createBakeTexture, createCompositePipeline, createGlyphPipeline, createInstanceOitEmitPipeline, createInstancePipelines, createOITPipelines, createSpriteOitEmitPipeline, createSpritePipelines, createTestRenderer, createTestSpine, cullCommands, dirtyTileSet, instanceOitEmitWgsl, nextByteCapacity, nextPow2, packCamera, packFullScreenComposite, queryRanges, rectToBounds, repackArcs, repackCurves, repackSegments, resolveRoot, runBakePass, spriteOitEmitWgsl, summarize, worldFrustumAabb };