insomni 0.2.0-alpha.0

package/dist/internal.mjs

@@ -0,0 +1,566 @@
+import { n as resolveRoot } from "./root-CHradZKM.mjs";
+import { a as ARC_FLOATS, c as CURVE_CAP_SQUARE, d as SHAPE_BYTES, f as SHAPE_CIRCLE, g as TRIANGLE_FLOATS, l as CURVE_FLOATS, m as SHAPE_RECT, o as CURVE_CAP_BUTT, p as SHAPE_ELLIPSE, s as CURVE_CAP_ROUND, u as SEGMENT_FLOATS } from "./assemble-BT3CXbSx.mjs";
+import { $ as repackCurves, A as packCamera, B as HEAD_BYTES, C as COMPOSITE_UNIFORM_BYTES, Ct as FRAME_RING_CAPACITY, D as bakeViewProjection, Dt as convertRect, E as packFullScreenComposite, Et as captureSpaceMap, G as cullCommands, H as SLOT_BYTES, K as worldFrustumAabb, M as GLYPH_PARAMS_BYTES, N as GLYPH_PARAMS_FLOATS, O as createBakePipelines, P as createGlyphPipeline, Q as repackArcs, R as createOITPipelines, S as RetainedTier, St as RendererDebug, T as createCompositePipeline, Tt as summarize, U as buildSpatialGrid, W as queryRanges, _ as INSTANCE_DRAW_BYTES, a as blitBackbuffer, at as nextByteCapacity, b as createInstancePipelines, et as repackSegments, g as spriteOitEmitWgsl, h as createSpritePipelines, i as createTestRenderer, it as UberPack, j as runBakePass, k as createBakeTexture, m as createSpriteOitEmitPipeline, s as resolveGroupTransform, t as project, v as INSTANCE_DRAW_FLOATS, w as COMPOSITE_UNIFORM_FLOATS, wt as FrameRing, x as instanceOitEmitWgsl, y as createInstanceOitEmitPipeline, z as ABuffer } from "./space-CeDnj6eu.mjs";
+import { l as SpriteSchema, s as ShapeSchema } from "./pipeline-BWCAZTKx.mjs";
+import { i as padFrameRect } from "./frame-mHNdKRpF.mjs";
+import { a as SPATIAL_HASH_WORKGROUP_SIZE, i as SPATIAL_HASH_PARAMS_WGSL, n as CLEAR_SPATIAL_HASH_WGSL, r as SPATIAL_HASH_PARAMS_BYTES, t as BUILD_SPATIAL_HASH_WGSL } from "./spatial-hash-C1crBjTo.mjs";
+import { DirtyChannel, ManualScheduler, PointerRouter, RAFScheduler, RectSpace, SceneNode, SceneRoot, rectOverlaps } from "./spatial.mjs";
+import "typegpu";
+//#region src/shared/dynamic-buffer.ts
+function nextPow2(value) {
+	if (value <= 1) return 1;
+	if (value > 1073741824) return 2 ** Math.ceil(Math.log2(value));
+	value--;
+	value |= value >> 1;
+	value |= value >> 2;
+	value |= value >> 4;
+	value |= value >> 8;
+	value |= value >> 16;
+	value++;
+	return value;
+}
+//#endregion
+//#region src/pack/region-index.ts
+/**
+* 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();
+* ```
+*/
+var RegionIndex = class {
+	/** group identity → byte span in the current pack. */
+	_spans = /* @__PURE__ */ new Map();
+	/** Accumulated dirty ranges for this frame (may overlap / be out of order). */
+	_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, byteOffset) {
+		this._spans.set(groupId, {
+			start: byteOffset,
+			end: byteOffset
+		});
+	}
+	/**
+	* 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, byteOffset) {
+		const span = this._spans.get(groupId);
+		if (span !== void 0) span.end = byteOffset;
+	}
+	/**
+	* Reset all span records for a new frame. Call before re-packing. Does NOT
+	* clear dirty ranges (use `clearDirty` for that).
+	*/
+	reset() {
+		this._spans.clear();
+	}
+	/**
+	* 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) {
+		const span = this._spans.get(groupId);
+		if (span === void 0 || span.end === span.start) return;
+		this._dirty.push({
+			byteOffset: span.start,
+			byteLength: span.end - span.start
+		});
+	}
+	/**
+	* 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() {
+		if (this._dirty.length === 0) return [];
+		const sorted = this._dirty.slice().sort((a, b) => a.byteOffset - b.byteOffset);
+		const out = [{
+			byteOffset: sorted[0].byteOffset,
+			byteLength: sorted[0].byteLength
+		}];
+		for (let i = 1; i < sorted.length; i++) {
+			const last = out[out.length - 1];
+			const cur = sorted[i];
+			const lastEnd = last.byteOffset + last.byteLength;
+			if (cur.byteOffset <= lastEnd) {
+				const curEnd = cur.byteOffset + cur.byteLength;
+				if (curEnd > lastEnd) last.byteLength = curEnd - last.byteOffset;
+			} else out.push({
+				byteOffset: cur.byteOffset,
+				byteLength: cur.byteLength
+			});
+		}
+		return out;
+	}
+	/**
+	* Clear accumulated dirty ranges. Call after the GPU upload is complete.
+	* Does NOT reset span records — use `reset()` for that.
+	*/
+	clearDirty() {
+		this._dirty.length = 0;
+	}
+	/**
+	* Return the recorded byte span for a group, or `undefined` if the group
+	* was not packed this frame. For testing / debugging only.
+	*/
+	spanOf(groupId) {
+		const s = this._spans.get(groupId);
+		return s !== void 0 ? {
+			start: s.start,
+			end: s.end
+		} : void 0;
+	}
+};
+//#endregion
+//#region src/tiers/tile-replay.ts
+/**
+* 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.
+*/
+var TileGrid = class {
+	/** Tile edge length in device px (== {@link RendererConfig.tileSize}). */
+	cellSize;
+	cols;
+	rows;
+	/** Flat row-major array: `buckets[tileId]` = cmdIndex list (insertion order). */
+	buckets;
+	constructor(canvasW, canvasH, cellSize) {
+		if (cellSize <= 0) throw new RangeError(`TileGrid: cellSize must be positive, got ${cellSize}`);
+		this.cellSize = cellSize;
+		this.cols = Math.max(1, Math.ceil(canvasW / cellSize));
+		this.rows = Math.max(1, Math.ceil(canvasH / cellSize));
+		this.buckets = Array.from({ length: this.cols * this.rows }, () => []);
+	}
+	/** Row-major tile id for a `(col, row)` cell. */
+	tileId(col, row) {
+		return row * this.cols + col;
+	}
+	/**
+	* 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, minY, maxX, maxY) {
+		const s = this.cellSize;
+		const c0 = Math.max(0, Math.floor((minX - 1) / s));
+		const r0 = Math.max(0, Math.floor((minY - 1) / s));
+		const c1 = Math.min(this.cols - 1, Math.floor((maxX + 1) / s));
+		const r1 = Math.min(this.rows - 1, Math.floor((maxY + 1) / s));
+		const ids = [];
+		for (let r = r0; r <= r1; r++) for (let c = c0; c <= c1; c++) ids.push(this.tileId(c, r));
+		return ids;
+	}
+	/**
+	* 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, dpr) {
+		const padded = padFrameRect(rect, 1);
+		const minX = padded.x * dpr;
+		const minY = padded.y * dpr;
+		const maxX = (padded.x + padded.width) * dpr;
+		const maxY = (padded.y + padded.height) * dpr;
+		return new Set(this.tilesForAabb(minX, minY, maxX, maxY));
+	}
+	/**
+	* 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, aabb) {
+		const ids = this.tilesForAabb(aabb.minX, aabb.minY, aabb.maxX, aabb.maxY);
+		for (const id of ids) this.buckets[id].push(cmdIndex);
+	}
+	/**
+	* 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) {
+		const seen = /* @__PURE__ */ new Set();
+		const result = [];
+		for (const id of tileIds) {
+			const bucket = this.buckets[id];
+			if (bucket === void 0) continue;
+			for (const cmdIndex of bucket) if (!seen.has(cmdIndex)) {
+				seen.add(cmdIndex);
+				result.push(cmdIndex);
+			}
+		}
+		return result.sort((a, b) => a - b);
+	}
+	/** Total tile count (`cols × rows`). */
+	get totalTiles() {
+		return this.cols * this.rows;
+	}
+};
+/**
+* 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.
+*/
+const FULL_FRAME_TILE_FRACTION = .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`.
+*/
+function dirtyTileSet(grid, regions, dpr) {
+	const dirty = /* @__PURE__ */ new Set();
+	for (const region of regions) for (const id of grid.tilesForRect(region, dpr)) dirty.add(id);
+	if (dirty.size / grid.totalTiles > .5) return null;
+	return dirty;
+}
+//#endregion
+//#region src/damage/spine.ts
+const FULL_PLANE_INTEREST = [{
+	rect: {
+		x: -1e9,
+		y: -1e9,
+		w: 2e9,
+		h: 2e9
+	},
+	kind: "paint"
+}];
+/**
+* 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.
+*/
+var FrameSpine = class {
+	channel;
+	scheduler;
+	#unsubscribe;
+	constructor({ scheduler, onFlush }) {
+		this.scheduler = scheduler ?? new RAFScheduler();
+		this.channel = new DirtyChannel(RectSpace, this.scheduler);
+		this.#unsubscribe = this.channel.subscribe(() => FULL_PLANE_INTEREST, (dirty) => onFlush(dirty));
+	}
+	/**
+	* Accumulate damage and schedule a flush. An empty regions array is a
+	* fast-path no-op — nothing is scheduled.
+	*/
+	mark(regions) {
+		if (regions.length === 0) return;
+		this.channel.mark(regions);
+	}
+	/**
+	* Dispose the spine. Removes the subscriber and cancels any pending
+	* scheduled flush.
+	*/
+	dispose() {
+		this.#unsubscribe();
+		this.scheduler.cancel?.();
+	}
+};
+/**
+* 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
+*/
+function createTestSpine(onFlush) {
+	const scheduler = new ManualScheduler();
+	return {
+		spine: new FrameSpine({
+			scheduler,
+			onFlush
+		}),
+		pump: () => scheduler.pump()
+	};
+}
+//#endregion
+//#region src/damage/scene-root.ts
+/**
+* Type guard for {@link PaintCtx}. Guards the `paint(ctx: unknown)` downcast in
+* {@link GpuSceneNode}: the structural contract is that the recursive descent
+* always passes a live `PaintCtx` object — but the method signature is `unknown`
+* to satisfy the base `SceneNode.paint` contract, which does not know about v3
+* frame state. The guard makes the expectation explicit and avoids a bare `as`.
+*/
+function isPaintCtx(ctx) {
+	return ctx !== null && typeof ctx === "object" && "layer" in ctx && "projectOpts" in ctx;
+}
+var GpuSceneNode = class extends SceneNode {
+	/**
+	* 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) {
+		if (!isPaintCtx(ctx)) throw new Error("[insomni v3] GpuSceneNode.paint called with a non-PaintCtx argument. Only the v3 frame spine should call paint(); use drawSelf(ctx) directly for programmatic repaints.");
+		this.drawSelf(ctx);
+		for (const child of this.children) child.paint(ctx);
+	}
+	/**
+	* 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.
+	*/
+	projectBounds(ctx, space = "ui") {
+		const b = this.bounds;
+		return project(b.x, b.y, b.x + b.w, b.y + b.h, space, ctx.projectOpts);
+	}
+	/** Mark a visual-only change: repaint, no data/layout rebuild. */
+	invalidatePaint(rect) {
+		this.markDamaged("paint", rect);
+	}
+	/** Mark a layout change (bounds/children moved). Triggers doLayout + paint. */
+	invalidateLayout(rect) {
+		this.markDamaged("layout", rect);
+	}
+	/** Mark a data change (inputs replaced). Triggers rebuildData → layout → paint. */
+	invalidateData(rect) {
+		this.markDamaged("data", rect);
+	}
+};
+var GpuSceneRoot = class extends SceneRoot {
+	/** The scene layer that descendant nodes paint into. */
+	layer;
+	/** The underlying v3 WebGPU renderer. */
+	gpu;
+	/** Reverse-z pointer routing with per-pointerId capture/drag/hover. */
+	pointer;
+	/**
+	* 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;
+	_spine;
+	_projectOpts;
+	_groups;
+	_dataKey;
+	/** Our own copy of the timing hook — the base keeps `onFrameTiming` private,
+	* and we override `_renderFrame`, so we read it directly. */
+	_onFrameTiming;
+	/** Damage regions handed to the in-flight `beginFrame`; consumed by `endFrame`. */
+	_currentRegions = [];
+	constructor(gpu, layer, options) {
+		const inertRenderer = {
+			beginFrame() {},
+			endFrame() {}
+		};
+		const baseOpts = {
+			scheduler: options.scheduler,
+			onFrameTiming: options.onFrameTiming
+		};
+		super(inertRenderer, baseOpts);
+		this.gpu = gpu;
+		this.layer = layer;
+		this.fullFrame = options.fullFrame ?? false;
+		this._projectOpts = options.projectOpts;
+		this._groups = options.groups;
+		this._dataKey = options.dataKey;
+		this._onFrameTiming = options.onFrameTiming;
+		this._spine = new FrameSpine({
+			scheduler: options.scheduler,
+			onFlush: (dirty) => this._renderFrameV3(dirty)
+		});
+		this.pointer = new PointerRouter(this);
+	}
+	/** Stash the frame's damage regions and clear the scene layer. */
+	beginFrame(regions) {
+		this._currentRegions = regions;
+		this.layer.clear();
+	}
+	/**
+	* 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() {
+		this.gpu.render([this.layer], {
+			regions: this._currentRegions.map(rectToBounds),
+			fullFrame: this.fullFrame,
+			viewKey: this._viewKey()
+		});
+	}
+	/**
+	* 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) {
+		this._spine.mark([damage]);
+	}
+	/** Force a full repaint of the whole root bounds on the next scheduled frame. */
+	requestPaint() {
+		this._emitDamage({
+			rect: this.bounds,
+			kind: "paint"
+		});
+	}
+	/**
+	* 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) {
+		this._emitDamage({
+			rect,
+			kind: "paint"
+		});
+	}
+	/**
+	* 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.
+	*/
+	_renderFrameV3(dirty) {
+		const timing = this._onFrameTiming;
+		const t0 = timing ? performance.now() : 0;
+		for (const d of dirty) {
+			const node = d.node;
+			if (d.kind === "data" && node?.rebuildData) node.rebuildData();
+		}
+		for (const d of dirty) {
+			const node = d.node;
+			if (d.kind !== "paint" && node?.doLayout) node.doLayout();
+		}
+		const regions = this.fullFrame ? [this.bounds] : dirty.map((d) => d.rect);
+		const t1 = timing ? performance.now() : 0;
+		this.beginFrame(regions);
+		const ctx = {
+			layer: this.layer,
+			projectOpts: this._projectOpts()
+		};
+		const paintedNodes = this._paintCulledRecursive(this, regions, ctx);
+		this.endFrame();
+		if (timing) timing({
+			layoutMs: t1 - t0,
+			paintMs: performance.now() - t1,
+			paintedNodes
+		});
+	}
+	/**
+	* 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.
+	*/
+	_paintCulledRecursive(node, regions, ctx) {
+		let painted = 0;
+		for (const child of node.children) {
+			let hit = false;
+			for (const region of regions) if (rectOverlaps(region, child.bounds)) {
+				hit = true;
+				break;
+			}
+			if (!hit) continue;
+			child.drawSelf(ctx);
+			painted++;
+			painted += this._paintCulledRecursive(child, regions, ctx);
+		}
+		return painted;
+	}
+	/**
+	* 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.
+	*/
+	_viewKey() {
+		let key = "";
+		const groups = this._groups?.();
+		if (groups) for (const g of groups) {
+			const m = resolveGroupTransform(g);
+			key += `${m[0]},${m[1]},${m[3]},${m[4]},${m[6]},${m[7]};`;
+		}
+		const dk = this._dataKey?.();
+		if (dk !== void 0) key += `|${dk}`;
+		return key;
+	}
+	/**
+	* 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) {
+		return this.pointer.dispatch(e);
+	}
+	/** Dispose the frame spine (removes the subscriber, cancels any pending flush). */
+	dispose() {
+		this._spine.dispose();
+	}
+};
+/** Convert a spatial `Rect` to the renderer's `Bounds2D` damage-region shape. */
+function rectToBounds(r) {
+	return {
+		minX: r.x,
+		minY: r.y,
+		maxX: r.x + r.w,
+		maxY: r.y + r.h
+	};
+}
+//#endregion
+export { ABuffer, ARC_FLOATS, BUILD_SPATIAL_HASH_WGSL, CLEAR_SPATIAL_HASH_WGSL, COMPOSITE_UNIFORM_BYTES, COMPOSITE_UNIFORM_FLOATS, CURVE_CAP_BUTT, CURVE_CAP_ROUND, CURVE_CAP_SQUARE, CURVE_FLOATS, FRAME_RING_CAPACITY, FULL_FRAME_TILE_FRACTION, FrameRing, FrameSpine, GLYPH_PARAMS_BYTES, GLYPH_PARAMS_FLOATS, GpuSceneNode, GpuSceneRoot, HEAD_BYTES, INSTANCE_DRAW_BYTES, INSTANCE_DRAW_FLOATS, RegionIndex, RendererDebug, 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, ShapeSchema, 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 };

package/dist/logger-DSyBF3Y_.mjs

@@ -0,0 +1,15 @@
+//#region src/core/logger.ts
+let _logger = console;
+/**
+* Install the process-wide diagnostic logger. Pass `null`/`undefined` to reset
+* back to the {@link console} default.
+*/
+function setLogger(logger) {
+	_logger = logger ?? console;
+}
+/** The active diagnostic logger. Defaults to {@link console}. */
+function getLogger() {
+	return _logger;
+}
+//#endregion
+export { setLogger as n, getLogger as t };