@godot-scene-web/canvas 0.1.0

package/dist/index.js

@@ -0,0 +1,4763 @@
+//#region src/color.ts
+/**
+* Premultiplied colour composition — the arithmetic the batcher writes into an
+* instance and the fragment shader repeats on the GPU, in one place so the two
+* can be checked against each other (and against `html`'s CPU tint bake).
+*
+* TWO CONVENTIONS MEET HERE, and mixing them up is the classic renderer bug:
+*
+* - a **premultiplied** colour carries `(r·a, g·a, b·a, a)`. That is what the
+*   draw-list's tints are, what every texture in {@link ./textures} is uploaded
+*   as, what the fragment emits, and what the canvas is declared as. Composing
+*   two premultiplied colours is a plain componentwise multiply.
+* - a **straight** colour carries `(r, g, b, a)` with the channels independent.
+*   The only thing that wants straight colour is the 3x3 colour matrix, because
+*   the matrix is defined on the texture's own RGB — multiply a premultiplied
+*   colour by it and a 50%-alpha pixel is transformed as if it were half as
+*   bright.
+*
+* Everything below is sRGB-domain: no linearization anywhere. That is not a
+* shortcut, it is the contract — the matrices come from Godot HSV materials that
+* Godot itself applies to sRGB texture bytes, and `html`'s
+* `applyColorMatrixToPixels` (the CPU bake of the same transform, used by the DOM
+* renderer) applies them to sRGB bytes too. Linearizing here would make the GPU
+* path disagree with the DOM path it is meant to replace.
+*/
+/** Row-major 3x3 identity, the value slot 0 of a batch's matrix table holds. */
+const IDENTITY_COLOR_MATRIX = [
+	1,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	1
+];
+function createRgba() {
+	return {
+		r: 1,
+		g: 1,
+		b: 1,
+		a: 1
+	};
+}
+function clamp01(value) {
+	if (!(value > 0)) return 0;
+	return value < 1 ? value : 1;
+}
+/**
+* Straight `(r,g,b,a)` -> premultiplied, clamped. The shape a producer has (a
+* Godot `modulate` is straight) turned into the shape {@link QuadView} wants.
+*/
+function premultiply(r, g, b, a, out) {
+	const alpha = clamp01(a);
+	out.r = clamp01(r) * alpha;
+	out.g = clamp01(g) * alpha;
+	out.b = clamp01(b) * alpha;
+	out.a = alpha;
+	return out;
+}
+/**
+* Premultiplied -> straight, with the `a === 0` hole filled with black. The
+* inverse of {@link premultiply} up to that hole (a fully transparent
+* premultiplied pixel has forgotten its colour, so nothing can recover it).
+*/
+function unpremultiply(colour, out) {
+	const a = colour.a;
+	if (a <= 0) {
+		out.r = 0;
+		out.g = 0;
+		out.b = 0;
+		out.a = 0;
+		return out;
+	}
+	out.r = colour.r / a;
+	out.g = colour.g / a;
+	out.b = colour.b / a;
+	out.a = a;
+	return out;
+}
+/**
+* Compose two PREMULTIPLIED colours — a texel times its quad's tint. A plain
+* componentwise multiply, which is the whole reason the premultiplied form is
+* worth keeping: with straight colours this would need the alpha handled apart
+* from the channels it has already scaled.
+*/
+function modulatePremultiplied(source, tint, out) {
+	out.r = source.r * tint.r;
+	out.g = source.g * tint.g;
+	out.b = source.b * tint.b;
+	out.a = source.a * tint.a;
+	return out;
+}
+/**
+* Apply a row-major 3x3 to STRAIGHT sRGB channels in 0..1, clamped — the float
+* twin of `html`'s `applyColorMatrixToPixels` (which works in 0..255 bytes and
+* clamps because it writes a `Uint8ClampedArray`) and of the colour-matrix branch
+* in the executor's fragment shader. All three must agree; `colour.test.ts`
+* asserts the first two against each other pixel for pixel.
+*
+* Alpha is untouched, exactly as `feColorMatrix` with only the RGB rows set.
+*/
+function applyColorMatrix01(colour, matrix, offset, out) {
+	const r = colour.r;
+	const g = colour.g;
+	const b = colour.b;
+	out.r = clamp01(matrix[offset] * r + matrix[offset + 1] * g + matrix[offset + 2] * b);
+	out.g = clamp01(matrix[offset + 3] * r + matrix[offset + 4] * g + matrix[offset + 5] * b);
+	out.b = clamp01(matrix[offset + 6] * r + matrix[offset + 7] * g + matrix[offset + 8] * b);
+	out.a = colour.a;
+	return out;
+}
+/**
+* The full per-fragment colour law, on the CPU: a PREMULTIPLIED texel, its
+* optional colour matrix, and the quad's PREMULTIPLIED tint, in the order the
+* shader applies them (un-premultiply, transform, re-premultiply, modulate).
+*
+* This exists so a pixel test can state the number it expects from the same
+* expression the GPU evaluates rather than from a second, hand-derived one.
+*/
+function shadeQuadPixel(texel, matrix, matrixOffset, tint, out) {
+	if (matrix) {
+		unpremultiply(texel, out);
+		applyColorMatrix01(out, matrix, matrixOffset, out);
+		out.r *= out.a;
+		out.g *= out.a;
+		out.b *= out.a;
+	} else {
+		out.r = texel.r;
+		out.g = texel.g;
+		out.b = texel.b;
+		out.a = texel.a;
+	}
+	return modulatePremultiplied(out, tint, out);
+}
+/** True when the 9 floats at `offset` are the identity, i.e. a no-op slot. */
+function isIdentityColorMatrix(matrix, offset = 0) {
+	for (let i = 0; i < 9; i += 1) if (matrix[offset + i] !== IDENTITY_COLOR_MATRIX[i]) return false;
+	return true;
+}
+/**
+* True when the 9 floats at `a`/`b` are equal — the batcher's matrix-table
+* dedupe. EXACT equality, deliberately: the table's job is to notice that many
+* cards carry the same computed tint, and an epsilon would merge two tints a
+* scene meant to differ. The corollary is that a `Float32Array` and a plain
+* `number[]` holding "the same" value do not match (`0.3` and its f32 round-trip
+* are different numbers), so a caller that wants dedupe should keep one storage
+* width — which the draw-list and this package both do.
+*/
+function colorMatricesEqual(a, aOffset, b, bOffset) {
+	for (let i = 0; i < 9; i += 1) if (a[aOffset + i] !== b[bOffset + i]) return false;
+	return true;
+}
+//#endregion
+//#region src/draw-list.ts
+/**
+* The draw-list IR for a Godot 2D scene: a flat, ordered recording of what one
+* frame paints, produced by walking `CanvasItem`s in draw order and consumed by
+* a GPU executor (a later wave). It is deliberately dumb — no scene concepts, no
+* nodes, no styles, just quads, indexed textured meshes, nine-patches,
+* polylines and clip pushes/pops in
+* the order they must hit the framebuffer.
+*
+* Storage is a set of pooled parallel typed arrays, not an array of command
+* objects:
+*
+* - `kinds` / `floatOffsets` / `intOffsets` are one entry per command,
+* - `floats` and `ints` are arenas that every command's numeric payload is
+*   appended into (a quad writes 16 floats + 3 ints, a polyline writes a
+*   5-float header plus 2 floats per point, …),
+* - `colorMatrices` is a side arena for the rare 3x3 color transform,
+* - `textures` is the ONLY object side-array — a texture handle cannot live in
+*   a typed array.
+*
+* That layout exists so a frame costs zero garbage: `reset()` rewinds the write
+* cursors and the same buffers are refilled next frame, and reading a command
+* back fills a caller-owned view instead of allocating one. Arrays grow on
+* demand (capacity doubling) and never shrink.
+*
+* All geometry is in DESIGN space (the scene's own coordinate system); mapping
+* design space to device pixels is the executor's job.
+*/
+/** A textured/solid rectangle: the workhorse command. */
+const DRAW_QUAD = 0;
+/** A 9-sliced rectangle; the executor expands it to up to 9 quads. */
+const DRAW_NINE_PATCH = 1;
+/** A flattened, constant-width line strip. */
+const DRAW_POLYLINE = 2;
+/** Push a scissor/clip rect; every later command is clipped until the pop. */
+const DRAW_CLIP_PUSH = 3;
+/** Pop the most recent clip rect. */
+const DRAW_CLIP_POP = 4;
+/**
+* A run of glyphs from one face, at one size, in one colour.
+*
+* The ONLY command that is not reducible to a textured quad, which is why it
+* exists as its own kind rather than as sugar over `pushQuad`. Its glyphs are
+* outlines evaluated per fragment (see `@godot-scene-web/hb-gpu`), so they carry
+* an atlas slot id instead of a source rect and stay crisp under rotation and
+* scale — the whole reason for the kind. An executor with no glyph pass
+* installed skips it.
+*/
+const DRAW_GLYPHS = 5;
+/** An arbitrary triangle list with one texture and per-mesh premultiplied tint. */
+const DRAW_TEXTURED_MESH = 6;
+/** A screen-dependent pass executed at this exact painter position. */
+const DRAW_SCREEN_EFFECT = 7;
+/** A caller-owned GPU pass executed directly into the current framebuffer. */
+const DRAW_EXTERNAL_EFFECT = 8;
+/** Indexed by {@link DrawCommandKind}; for debugging and test assertions. */
+const DRAW_COMMAND_NAMES = [
+	"quad",
+	"ninePatch",
+	"polyline",
+	"clipPush",
+	"clipPop",
+	"glyphs",
+	"texturedMesh",
+	"screenEffect",
+	"externalEffect"
+];
+/** Godot `CanvasItemMaterial.BLEND_MODE_MIX`: normal alpha compositing. */
+const BLEND_MIX = 0;
+/** Godot `BLEND_MODE_ADD`. */
+const BLEND_ADD = 1;
+/** Godot `BLEND_MODE_SUB`. */
+const BLEND_SUB = 2;
+/** Godot `BLEND_MODE_MUL`. */
+const BLEND_MUL = 3;
+/** Bit in a command's packed flags int: mirror the source rect horizontally. */
+const FLIP_H = 1;
+/** Bit in a command's packed flags int: mirror the source rect vertically. */
+const FLIP_V = 2;
+function createDrawListPatchView(capacity = 16) {
+	const indices = [];
+	let marks = new Int32Array(Math.max(1, capacity));
+	let generation = 0;
+	let revision = 0;
+	let overflowed = false;
+	const view = {
+		get indices() {
+			return indices;
+		},
+		get revision() {
+			return revision;
+		},
+		get overflowed() {
+			return overflowed;
+		}
+	};
+	Object.assign(view, {
+		begin(nextRevision) {
+			indices.length = 0;
+			generation += 1;
+			if (generation === 2147483647) {
+				marks.fill(0);
+				generation = 1;
+			}
+			revision = nextRevision;
+			overflowed = false;
+		},
+		overflow() {
+			overflowed = true;
+		},
+		add(index) {
+			if (index >= marks.length) {
+				let length = marks.length;
+				while (length <= index) length *= 2;
+				const next = new Int32Array(length);
+				next.set(marks);
+				marks = next;
+			}
+			if (marks[index] === generation) return;
+			marks[index] = generation;
+			indices.push(index);
+		}
+	});
+	return view;
+}
+const QUAD_FLOATS = 16;
+const QUAD_INTS = 3;
+const NINE_PATCH_FLOATS = 20;
+const NINE_PATCH_INTS = QUAD_INTS;
+const POLYLINE_HEADER_FLOATS = 5;
+const POLYLINE_INTS = 1;
+const TEXTURED_MESH_HEADER_FLOATS = 10;
+const TEXTURED_MESH_HEADER_INTS = 3;
+const GLYPHS_SPREAD_OFFSET = 11;
+const GLYPHS_INK_X_OFFSET = 12;
+const GLYPHS_INK_Y_OFFSET = 13;
+const GLYPHS_INK_WIDTH_OFFSET = 14;
+const GLYPHS_INK_HEIGHT_OFFSET = 15;
+const GLYPHS_INK_OUTSET_OFFSET = 16;
+const GLYPHS_HEADER_FLOATS = 17;
+const GLYPHS_HEADER_INTS = 1;
+const CLIP_FLOATS = 6;
+const COLOR_MATRIX_FLOATS$1 = 9;
+const DEFAULT_COMMAND_CAPACITY = 256;
+const DEFAULT_FLOAT_CAPACITY = 256 * QUAD_FLOATS;
+const DEFAULT_INT_CAPACITY = 256 * QUAD_INTS;
+const DEFAULT_COLOR_MATRIX_CAPACITY = 8;
+const IDENTITY_MATRIX_2D = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+const IDENTITY_COLOR_MATRIX$1 = [
+	1,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	1
+];
+/** A fresh quad view: identity transform, opaque white, mix blend, no matrix. */
+function createQuadView() {
+	return {
+		m: Float32Array.from(IDENTITY_MATRIX_2D),
+		w: 0,
+		h: 0,
+		srcX: 0,
+		srcY: 0,
+		srcW: 0,
+		srcH: 0,
+		r: 1,
+		g: 1,
+		b: 1,
+		a: 1,
+		blend: 0,
+		flipH: false,
+		flipV: false,
+		hasColorMatrix: false,
+		colorMatrix: Float32Array.from(IDENTITY_COLOR_MATRIX$1)
+	};
+}
+/** A fresh nine-patch view: a quad view with zero margins. */
+function createNinePatchView() {
+	return {
+		...createQuadView(),
+		marginLeft: 0,
+		marginTop: 0,
+		marginRight: 0,
+		marginBottom: 0
+	};
+}
+/** A fresh polyline view with room for `pointCapacity` points. */
+function createPolylineView(pointCapacity = 8) {
+	return {
+		points: new Float32Array(Math.max(1, pointCapacity) * 2),
+		pointCount: 0,
+		width: 1,
+		r: 1,
+		g: 1,
+		b: 1,
+		a: 1
+	};
+}
+/** A reusable textured mesh view with room for the requested topology. */
+function createTexturedMeshView(vertexCapacity = 4, indexCapacity = 6) {
+	const vertices = Math.max(1, Math.floor(vertexCapacity));
+	return {
+		m: Float32Array.from(IDENTITY_MATRIX_2D),
+		positions: new Float32Array(vertices * 2),
+		uvs: new Float32Array(vertices * 2),
+		vertexCount: 0,
+		indices: new Uint32Array(Math.max(1, Math.floor(indexCapacity))),
+		indexCount: 0,
+		r: 1,
+		g: 1,
+		b: 1,
+		a: 1,
+		blend: 0
+	};
+}
+/** A fresh glyph-run view with room for `glyphCapacity` glyphs. */
+function createGlyphsView(glyphCapacity = 32) {
+	const capacity = Math.max(1, glyphCapacity);
+	return {
+		m: Float32Array.from(IDENTITY_MATRIX_2D),
+		pixelsPerEm: 16,
+		r: 1,
+		g: 1,
+		b: 1,
+		a: 1,
+		slots: new Int32Array(capacity),
+		positions: new Float32Array(capacity * 2),
+		glyphCount: 0,
+		spreadPx: 0,
+		localInkX: NaN,
+		localInkY: NaN,
+		localInkWidth: NaN,
+		localInkHeight: NaN,
+		localInkOutset: NaN
+	};
+}
+/** A fresh clip-rect view: empty rect, square corners, no outset. */
+function createClipRectView() {
+	return {
+		x: 0,
+		y: 0,
+		w: 0,
+		h: 0,
+		cornerRadius: 0,
+		outsetX: 0
+	};
+}
+/**
+* Copy an `html` {@link ColorMatrix} into a quad/nine-patch view and arm it.
+* Passing `null` disarms the view's matrix (leaving its contents alone), which
+* is the shape most callers have: a computed transform that is usually absent.
+*/
+function setViewColorMatrix(view, matrix) {
+	if (!matrix) {
+		view.hasColorMatrix = false;
+		return;
+	}
+	const rows = matrix.rows;
+	const out = view.colorMatrix;
+	out[0] = rows[0][0];
+	out[1] = rows[0][1];
+	out[2] = rows[0][2];
+	out[3] = rows[1][0];
+	out[4] = rows[1][1];
+	out[5] = rows[1][2];
+	out[6] = rows[2][0];
+	out[7] = rows[2][1];
+	out[8] = rows[2][2];
+	view.hasColorMatrix = true;
+}
+function grownFloats(current, needed) {
+	let capacity = Math.max(1, current.length);
+	while (capacity < needed) capacity *= 2;
+	const next = new Float32Array(capacity);
+	next.set(current);
+	return next;
+}
+/** Preserve an omitted optional producer field as an unknown IR value. */
+function finiteOrNaN(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : NaN;
+}
+function grownInts(current, needed) {
+	let capacity = Math.max(1, current.length);
+	while (capacity < needed) capacity *= 2;
+	const next = new Int32Array(capacity);
+	next.set(current);
+	return next;
+}
+function grownObjects(current, needed) {
+	let capacity = Math.max(1, current.length);
+	while (capacity < needed) capacity *= 2;
+	const next = new Array(capacity).fill(null);
+	for (let index = 0; index < current.length; index += 1) next[index] = current[index];
+	return next;
+}
+const fragmentStorage = /* @__PURE__ */ new WeakMap();
+function requireFragmentStorage(fragment) {
+	const storage = fragmentStorage.get(fragment);
+	if (!storage) throw new TypeError("draw-list appendFragment() needs a fragment created by createDrawListFragment()");
+	return storage;
+}
+function fillFragmentPayloadLengths(list, index, out) {
+	const kind = list.kindAt(index);
+	const intAt = list.intOffsetAt(index);
+	const requireInt = (offset, label) => {
+		const value = list.ints[intAt + offset];
+		if (!Number.isInteger(value) || value < 0) throw new RangeError(`draw-list ${label} at command ${index} is malformed`);
+		return value;
+	};
+	switch (kind) {
+		case 0:
+			out.floats = QUAD_FLOATS;
+			out.ints = QUAD_INTS;
+			return;
+		case 1:
+			out.floats = NINE_PATCH_FLOATS;
+			out.ints = NINE_PATCH_INTS;
+			return;
+		case 2:
+			out.floats = POLYLINE_HEADER_FLOATS + requireInt(0, "polyline point count") * 2;
+			out.ints = POLYLINE_INTS;
+			return;
+		case 3:
+			out.floats = CLIP_FLOATS;
+			out.ints = 0;
+			return;
+		case 4:
+		case 7:
+		case 8:
+			out.floats = 0;
+			out.ints = 0;
+			return;
+		case 5: {
+			const glyphs = requireInt(0, "glyph count");
+			out.floats = GLYPHS_HEADER_FLOATS + glyphs * 2;
+			out.ints = GLYPHS_HEADER_INTS + glyphs;
+			return;
+		}
+		case 6: {
+			const vertices = requireInt(0, "textured mesh vertex count");
+			const indexes = requireInt(1, "textured mesh index count");
+			out.floats = TEXTURED_MESH_HEADER_FLOATS + vertices * 4;
+			out.ints = TEXTURED_MESH_HEADER_INTS + indexes;
+			return;
+		}
+		default: throw new RangeError(`draw-list command ${index} has an unknown kind ${kind}`);
+	}
+}
+function fillFragmentStoragePayloadLengths(storage, index, out) {
+	if (!Number.isInteger(index) || index < 0 || index >= storage.count) throw new RangeError(`draw-list fragment index ${index} out of range (count ${storage.count})`);
+	const kind = storage.kinds[index];
+	const intAt = storage.intOffsets[index];
+	switch (kind) {
+		case 0:
+			out.floats = QUAD_FLOATS;
+			out.ints = QUAD_INTS;
+			return;
+		case 1:
+			out.floats = NINE_PATCH_FLOATS;
+			out.ints = NINE_PATCH_INTS;
+			return;
+		case 2: {
+			const points = storage.ints[intAt];
+			if (!Number.isInteger(points) || points < 0) throw new RangeError(`draw-list fragment polyline point count at command ${index} is malformed`);
+			out.floats = POLYLINE_HEADER_FLOATS + points * 2;
+			out.ints = POLYLINE_INTS;
+			return;
+		}
+		case 3:
+			out.floats = CLIP_FLOATS;
+			out.ints = 0;
+			return;
+		case 4:
+		case 7:
+		case 8:
+			out.floats = 0;
+			out.ints = 0;
+			return;
+		case 5: {
+			const glyphs = storage.ints[intAt];
+			if (!Number.isInteger(glyphs) || glyphs < 0) throw new RangeError(`draw-list fragment glyph count at command ${index} is malformed`);
+			out.floats = GLYPHS_HEADER_FLOATS + glyphs * 2;
+			out.ints = GLYPHS_HEADER_INTS + glyphs;
+			return;
+		}
+		case 6: {
+			const vertices = storage.ints[intAt];
+			const indexes = storage.ints[intAt + 1];
+			if (!Number.isInteger(vertices) || vertices < 0) throw new RangeError(`draw-list fragment textured mesh vertex count at command ${index} is malformed`);
+			if (!Number.isInteger(indexes) || indexes < 0) throw new RangeError(`draw-list fragment textured mesh index count at command ${index} is malformed`);
+			out.floats = TEXTURED_MESH_HEADER_FLOATS + vertices * 4;
+			out.ints = TEXTURED_MESH_HEADER_INTS + indexes;
+			return;
+		}
+		default: throw new RangeError(`draw-list fragment command ${index} has an unknown kind ${kind}`);
+	}
+}
+/**
+* Create reusable storage for a retained command fragment. The fragment holds
+* only draw-list data and opaque caller references; it never creates or owns a
+* DOM node, a WebGL object, or an executor.
+*/
+function createDrawListFragment(options = {}) {
+	const commandCapacity = Math.max(1, options.commandCapacity ?? DEFAULT_COMMAND_CAPACITY);
+	const storage = {
+		kinds: new Int32Array(commandCapacity),
+		floatOffsets: new Int32Array(commandCapacity),
+		intOffsets: new Int32Array(commandCapacity),
+		textures: new Array(commandCapacity).fill(null),
+		screenEffects: new Array(commandCapacity).fill(null),
+		externalEffects: new Array(commandCapacity).fill(null),
+		floats: new Float32Array(Math.max(1, options.floatCapacity ?? DEFAULT_FLOAT_CAPACITY)),
+		ints: new Int32Array(Math.max(1, options.intCapacity ?? DEFAULT_INT_CAPACITY)),
+		colorMatrices: new Float32Array(Math.max(1, options.colorMatrixCapacity ?? DEFAULT_COLOR_MATRIX_CAPACITY) * COLOR_MATRIX_FLOATS$1),
+		sourceMatrixIndexes: new Int32Array(Math.max(1, options.colorMatrixCapacity ?? DEFAULT_COLOR_MATRIX_CAPACITY)),
+		count: 0,
+		floatLength: 0,
+		intLength: 0,
+		colorMatrixCount: 0,
+		maxClipDepth: 0
+	};
+	function reset() {
+		for (let index = 0; index < storage.count; index += 1) {
+			storage.textures[index] = null;
+			storage.screenEffects[index] = null;
+			storage.externalEffects[index] = null;
+		}
+		storage.count = 0;
+		storage.floatLength = 0;
+		storage.intLength = 0;
+		storage.colorMatrixCount = 0;
+		storage.maxClipDepth = 0;
+	}
+	function ensureCommand(needed) {
+		if (needed <= storage.kinds.length) return;
+		const capacity = storage.kinds.length * 2;
+		const nextKinds = new Int32Array(capacity);
+		nextKinds.set(storage.kinds);
+		storage.kinds = nextKinds;
+		const nextFloatOffsets = new Int32Array(capacity);
+		nextFloatOffsets.set(storage.floatOffsets);
+		storage.floatOffsets = nextFloatOffsets;
+		const nextIntOffsets = new Int32Array(capacity);
+		nextIntOffsets.set(storage.intOffsets);
+		storage.intOffsets = nextIntOffsets;
+		storage.textures = grownObjects(storage.textures, needed);
+		storage.screenEffects = grownObjects(storage.screenEffects, needed);
+		storage.externalEffects = grownObjects(storage.externalEffects, needed);
+	}
+	function matrixIndexFor(source, sourceIndex) {
+		for (let index = 0; index < storage.colorMatrixCount; index += 1) if (storage.sourceMatrixIndexes[index] === sourceIndex) return index;
+		const sourceAt = sourceIndex * COLOR_MATRIX_FLOATS$1;
+		if (sourceIndex < 0 || sourceAt + COLOR_MATRIX_FLOATS$1 > source.colorMatrices.length) throw new RangeError(`draw-list color matrix ${sourceIndex} is malformed`);
+		const nextCount = storage.colorMatrixCount + 1;
+		if (nextCount * COLOR_MATRIX_FLOATS$1 > storage.colorMatrices.length) storage.colorMatrices = grownFloats(storage.colorMatrices, nextCount * COLOR_MATRIX_FLOATS$1);
+		if (nextCount > storage.sourceMatrixIndexes.length) storage.sourceMatrixIndexes = grownInts(storage.sourceMatrixIndexes, nextCount);
+		const target = storage.colorMatrixCount;
+		const targetAt = target * COLOR_MATRIX_FLOATS$1;
+		for (let offset = 0; offset < COLOR_MATRIX_FLOATS$1; offset += 1) storage.colorMatrices[targetAt + offset] = source.colorMatrices[sourceAt + offset];
+		storage.sourceMatrixIndexes[target] = sourceIndex;
+		storage.colorMatrixCount = nextCount;
+		return target;
+	}
+	function capture(source, start, end = source.count) {
+		if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start || end > source.count) throw new RangeError(`draw-list fragment range [${start}, ${end}) is outside count ${source.count}`);
+		const lengths = {
+			floats: 0,
+			ints: 0
+		};
+		let depth = 0;
+		let maxDepth = 0;
+		for (let index = start; index < end; index += 1) {
+			fillFragmentPayloadLengths(source, index, lengths);
+			const floatAt = source.floatOffsetAt(index);
+			const intAt = source.intOffsetAt(index);
+			if (floatAt < 0 || intAt < 0 || floatAt + lengths.floats > source.floats.length || intAt + lengths.ints > source.ints.length) throw new RangeError(`draw-list command ${index} has an invalid arena range`);
+			const kind = source.kindAt(index);
+			if (kind === 0 || kind === 1) {
+				const matrix = source.ints[intAt + 2];
+				if (!Number.isInteger(matrix) || matrix < -1 || matrix >= 0 && (matrix + 1) * COLOR_MATRIX_FLOATS$1 > source.colorMatrices.length) throw new RangeError(`draw-list color matrix ${matrix} at command ${index} is malformed`);
+			}
+			if (kind === 3) {
+				depth += 1;
+				maxDepth = Math.max(maxDepth, depth);
+			} else if (kind === 4) {
+				depth -= 1;
+				if (depth < 0) throw new RangeError(`draw-list fragment range [${start}, ${end}) pops a clip it did not push`);
+			}
+		}
+		if (depth !== 0) throw new RangeError(`draw-list fragment range [${start}, ${end}) leaves ${depth} clip(s) open`);
+		reset();
+		for (let sourceIndex = start; sourceIndex < end; sourceIndex += 1) {
+			fillFragmentPayloadLengths(source, sourceIndex, lengths);
+			const index = storage.count;
+			ensureCommand(index + 1);
+			if (storage.floatLength + lengths.floats > storage.floats.length) storage.floats = grownFloats(storage.floats, storage.floatLength + lengths.floats);
+			if (storage.intLength + lengths.ints > storage.ints.length) storage.ints = grownInts(storage.ints, storage.intLength + lengths.ints);
+			storage.kinds[index] = source.kindAt(sourceIndex);
+			storage.floatOffsets[index] = storage.floatLength;
+			storage.intOffsets[index] = storage.intLength;
+			storage.textures[index] = source.textureAt(sourceIndex);
+			storage.screenEffects[index] = source.screenEffectAt(sourceIndex);
+			storage.externalEffects[index] = source.externalEffectAt(sourceIndex);
+			const sourceFloatAt = source.floatOffsetAt(sourceIndex);
+			const sourceIntAt = source.intOffsetAt(sourceIndex);
+			for (let offset = 0; offset < lengths.floats; offset += 1) storage.floats[storage.floatLength + offset] = source.floats[sourceFloatAt + offset];
+			for (let offset = 0; offset < lengths.ints; offset += 1) storage.ints[storage.intLength + offset] = source.ints[sourceIntAt + offset];
+			const kind = storage.kinds[index];
+			if (kind === 0 || kind === 1) {
+				const matrix = storage.ints[storage.intLength + 2];
+				if (matrix >= 0) storage.ints[storage.intLength + 2] = matrixIndexFor(source, matrix);
+			}
+			storage.count += 1;
+			storage.floatLength += lengths.floats;
+			storage.intLength += lengths.ints;
+		}
+		storage.maxClipDepth = maxDepth;
+	}
+	const fragment = {
+		get count() {
+			return storage.count;
+		},
+		get clipDepth() {
+			return 0;
+		},
+		get maxClipDepth() {
+			return storage.maxClipDepth;
+		},
+		reset,
+		capture
+	};
+	fragmentStorage.set(fragment, storage);
+	return Object.freeze(fragment);
+}
+/**
+* Create an empty draw list. Capacities are only a starting point; every arena
+* grows on demand, so a list settles at the high-water mark of the frames it
+* has recorded and then allocates nothing.
+*/
+function createDrawList(options = {}) {
+	let kinds = new Int32Array(Math.max(1, options.commandCapacity ?? DEFAULT_COMMAND_CAPACITY));
+	let floatOffsets = new Int32Array(kinds.length);
+	let intOffsets = new Int32Array(kinds.length);
+	let textures = new Array(kinds.length).fill(null);
+	let screenEffects = new Array(kinds.length).fill(null);
+	let externalEffects = new Array(kinds.length).fill(null);
+	let floats = new Float32Array(Math.max(1, options.floatCapacity ?? DEFAULT_FLOAT_CAPACITY));
+	let ints = new Int32Array(Math.max(1, options.intCapacity ?? DEFAULT_INT_CAPACITY));
+	let colorMatrices = new Float32Array(Math.max(1, options.colorMatrixCapacity ?? DEFAULT_COLOR_MATRIX_CAPACITY) * COLOR_MATRIX_FLOATS$1);
+	let count = 0;
+	let floatLength = 0;
+	let intLength = 0;
+	let colorMatrixCount = 0;
+	let clipDepth = 0;
+	let maxClipDepth = 0;
+	let structuralRevision = 0;
+	let contentRevision = 0;
+	let commandRevisions = new Int32Array(kinds.length);
+	const patchJournalCapacity = Math.max(1, options.patchJournalCapacity ?? 256);
+	const patchJournalRevisions = new Int32Array(patchJournalCapacity);
+	const patchJournalIndexes = new Int32Array(patchJournalCapacity);
+	let patchJournalStart = 0;
+	let patchJournalCount = 0;
+	const fragmentAppendLengths = {
+		floats: 0,
+		ints: 0
+	};
+	const fragmentPatchDestinationView = {
+		kindAt(index) {
+			return kinds[index];
+		},
+		intOffsetAt(index) {
+			return intOffsets[index];
+		},
+		get ints() {
+			return ints;
+		}
+	};
+	function ensureCommandSlot() {
+		if (count < kinds.length) return;
+		const capacity = kinds.length * 2;
+		const nextKinds = new Int32Array(capacity);
+		nextKinds.set(kinds);
+		kinds = nextKinds;
+		const nextFloatOffsets = new Int32Array(capacity);
+		nextFloatOffsets.set(floatOffsets);
+		floatOffsets = nextFloatOffsets;
+		const nextIntOffsets = new Int32Array(capacity);
+		nextIntOffsets.set(intOffsets);
+		intOffsets = nextIntOffsets;
+		const nextRevisions = new Int32Array(capacity);
+		nextRevisions.set(commandRevisions);
+		commandRevisions = nextRevisions;
+		const nextTextures = new Array(capacity).fill(null);
+		for (let i = 0; i < textures.length; i += 1) nextTextures[i] = textures[i];
+		textures = nextTextures;
+		const nextEffects = new Array(capacity).fill(null);
+		for (let i = 0; i < screenEffects.length; i += 1) nextEffects[i] = screenEffects[i];
+		screenEffects = nextEffects;
+		const nextExternalEffects = new Array(capacity).fill(null);
+		for (let i = 0; i < externalEffects.length; i += 1) nextExternalEffects[i] = externalEffects[i];
+		externalEffects = nextExternalEffects;
+	}
+	function beginCommand(kind, floatCount, intCount, texture) {
+		ensureCommandSlot();
+		if (floatLength + floatCount > floats.length) floats = grownFloats(floats, floatLength + floatCount);
+		if (intLength + intCount > ints.length) ints = grownInts(ints, intLength + intCount);
+		const index = count;
+		kinds[index] = kind;
+		floatOffsets[index] = floatLength;
+		intOffsets[index] = intLength;
+		textures[index] = texture;
+		count += 1;
+		contentRevision += 1;
+		structuralRevision += 1;
+		commandRevisions[index] = contentRevision;
+		floatLength += floatCount;
+		intLength += intCount;
+		return index;
+	}
+	function storeColorMatrix(view) {
+		if (!view.hasColorMatrix) return -1;
+		const needed = (colorMatrixCount + 1) * COLOR_MATRIX_FLOATS$1;
+		if (needed > colorMatrices.length) colorMatrices = grownFloats(colorMatrices, needed);
+		const at = colorMatrixCount * COLOR_MATRIX_FLOATS$1;
+		colorMatrices.set(view.colorMatrix.subarray(0, COLOR_MATRIX_FLOATS$1), at);
+		colorMatrixCount += 1;
+		return colorMatrixCount - 1;
+	}
+	function storeFragmentColorMatrix(matrices, matrixIndex) {
+		const from = matrixIndex * COLOR_MATRIX_FLOATS$1;
+		if (matrixIndex < 0 || from + COLOR_MATRIX_FLOATS$1 > matrices.length) throw new RangeError(`draw-list fragment color matrix ${matrixIndex} is malformed`);
+		const needed = (colorMatrixCount + 1) * COLOR_MATRIX_FLOATS$1;
+		if (needed > colorMatrices.length) colorMatrices = grownFloats(colorMatrices, needed);
+		const target = colorMatrixCount * COLOR_MATRIX_FLOATS$1;
+		for (let offset = 0; offset < COLOR_MATRIX_FLOATS$1; offset += 1) colorMatrices[target + offset] = matrices[from + offset];
+		colorMatrixCount += 1;
+		return colorMatrixCount - 1;
+	}
+	function requireIndex(index) {
+		if (!Number.isInteger(index) || index < 0 || index >= count) throw new RangeError(`draw-list index ${index} out of range (count ${count})`);
+	}
+	function requireKind(index, kind) {
+		requireIndex(index);
+		if (kinds[index] !== kind) throw new TypeError(`draw-list command ${index} is "${DRAW_COMMAND_NAMES[kinds[index]]}", not "${DRAW_COMMAND_NAMES[kind]}"`);
+		return index;
+	}
+	/**
+	* The guard for the patch methods: both quad kinds are accepted because a
+	* nine-patch stores a quad payload first and its margins after, so the
+	* transform and colour slots are at the same offsets in both. Refusing
+	* nine-patches would drop the feature exactly where a consumer needs it most
+	* (a dialog fading out is nine-patch frames plus quads).
+	*/
+	function requireQuadLike(index) {
+		requireIndex(index);
+		const kind = kinds[index];
+		if (kind !== 0 && kind !== 1) throw new TypeError(`draw-list command ${index} is "${DRAW_COMMAND_NAMES[kind]}", not a quad-like command ("quad" or "ninePatch")`);
+		return index;
+	}
+	function requireTexturedMesh(index) {
+		return requireKind(index, 6);
+	}
+	function markPatched(index) {
+		contentRevision += 1;
+		commandRevisions[index] = contentRevision;
+		const slot = (patchJournalStart + patchJournalCount) % patchJournalCapacity;
+		patchJournalRevisions[slot] = contentRevision;
+		patchJournalIndexes[slot] = index;
+		if (patchJournalCount < patchJournalCapacity) patchJournalCount += 1;
+		else patchJournalStart = (patchJournalStart + 1) % patchJournalCapacity;
+	}
+	function hasExpectedObjectPayload(kind, texture, screenEffect, externalEffect) {
+		switch (kind) {
+			case 0:
+			case 1:
+			case 6: return screenEffect === null && externalEffect === null;
+			case 7: return texture === null && externalEffect === null && screenEffect !== null && screenEffect.screenDependent === true && typeof screenEffect.execute === "function";
+			case 8: return texture === null && screenEffect === null && externalEffect !== null && typeof externalEffect.execute === "function";
+			default: return texture === null && screenEffect === null && externalEffect === null;
+		}
+	}
+	/**
+	* Validate whether a captured range can overwrite the existing slots without
+	* changing any command layout. This runs to completion before a byte or
+	* reference is touched, which is the atomicity boundary for patchFragment.
+	*/
+	function canPatchFragment(start, captured) {
+		if (!Number.isInteger(start) || start < 0 || start > count || captured.count > count - start) return false;
+		if (captured.count === 0) return true;
+		const destinationMatrices = /* @__PURE__ */ new Map();
+		let sourceClipDepth = 0;
+		let destinationClipDepth = 0;
+		try {
+			for (let sourceIndex = 0; sourceIndex < captured.count; sourceIndex += 1) {
+				const destinationIndex = start + sourceIndex;
+				const sourceKind = captured.kinds[sourceIndex];
+				if (kinds[destinationIndex] !== sourceKind) return false;
+				const sourceFloatAt = captured.floatOffsets[sourceIndex];
+				const sourceIntAt = captured.intOffsets[sourceIndex];
+				const destinationFloatAt = floatOffsets[destinationIndex];
+				const destinationIntAt = intOffsets[destinationIndex];
+				fillFragmentStoragePayloadLengths(captured, sourceIndex, fragmentAppendLengths);
+				const sourceFloats = fragmentAppendLengths.floats;
+				const sourceInts = fragmentAppendLengths.ints;
+				if (sourceFloatAt < 0 || sourceIntAt < 0 || sourceFloatAt + sourceFloats > captured.floatLength || sourceIntAt + sourceInts > captured.intLength || destinationFloatAt < 0 || destinationIntAt < 0 || destinationFloatAt + sourceFloats > floatLength || destinationIntAt + sourceInts > intLength) return false;
+				fillFragmentPayloadLengths(fragmentPatchDestinationView, destinationIndex, fragmentAppendLengths);
+				if (fragmentAppendLengths.floats !== sourceFloats || fragmentAppendLengths.ints !== sourceInts) return false;
+				if (!hasExpectedObjectPayload(sourceKind, captured.textures[sourceIndex], captured.screenEffects[sourceIndex], captured.externalEffects[sourceIndex]) || !hasExpectedObjectPayload(sourceKind, textures[destinationIndex], screenEffects[destinationIndex], externalEffects[destinationIndex])) return false;
+				if (sourceKind === 0 || sourceKind === 1) {
+					const sourceMatrix = captured.ints[sourceIntAt + 2];
+					const destinationMatrix = ints[destinationIntAt + 2];
+					const sourceHasMatrix = sourceMatrix >= 0;
+					if (sourceHasMatrix !== destinationMatrix >= 0) return false;
+					if (sourceHasMatrix) {
+						if (!Number.isInteger(sourceMatrix) || !Number.isInteger(destinationMatrix) || sourceMatrix >= captured.colorMatrixCount || destinationMatrix >= colorMatrixCount || (sourceMatrix + 1) * COLOR_MATRIX_FLOATS$1 > captured.colorMatrices.length || (destinationMatrix + 1) * COLOR_MATRIX_FLOATS$1 > colorMatrices.length) return false;
+						const previousSource = destinationMatrices.get(destinationMatrix);
+						if (previousSource !== void 0 && previousSource !== sourceMatrix) return false;
+						destinationMatrices.set(destinationMatrix, sourceMatrix);
+					} else if (sourceMatrix !== -1 || destinationMatrix !== -1) return false;
+				}
+				if (sourceKind === 3) {
+					sourceClipDepth += 1;
+					destinationClipDepth += 1;
+				} else if (sourceKind === 4) {
+					sourceClipDepth -= 1;
+					destinationClipDepth -= 1;
+					if (sourceClipDepth < 0 || destinationClipDepth < 0) return false;
+				}
+			}
+		} catch {
+			return false;
+		}
+		if (sourceClipDepth !== 0 || destinationClipDepth !== 0) return false;
+		if (destinationMatrices.size > 0) for (let index = 0; index < count; index += 1) {
+			if (index >= start && index < start + captured.count) continue;
+			const kind = kinds[index];
+			if (kind !== 0 && kind !== 1) continue;
+			if (destinationMatrices.has(ints[intOffsets[index] + 2])) return false;
+		}
+		return true;
+	}
+	function applyFragmentPatch(start, captured) {
+		for (let sourceIndex = 0; sourceIndex < captured.count; sourceIndex += 1) {
+			const destinationIndex = start + sourceIndex;
+			const kind = captured.kinds[sourceIndex];
+			const sourceFloatAt = captured.floatOffsets[sourceIndex];
+			const sourceIntAt = captured.intOffsets[sourceIndex];
+			const destinationFloatAt = floatOffsets[destinationIndex];
+			const destinationIntAt = intOffsets[destinationIndex];
+			const destinationMatrix = kind === 0 || kind === 1 ? ints[destinationIntAt + 2] : -1;
+			fillFragmentStoragePayloadLengths(captured, sourceIndex, fragmentAppendLengths);
+			floats.set(captured.floats.subarray(sourceFloatAt, sourceFloatAt + fragmentAppendLengths.floats), destinationFloatAt);
+			ints.set(captured.ints.subarray(sourceIntAt, sourceIntAt + fragmentAppendLengths.ints), destinationIntAt);
+			textures[destinationIndex] = captured.textures[sourceIndex];
+			screenEffects[destinationIndex] = captured.screenEffects[sourceIndex];
+			externalEffects[destinationIndex] = captured.externalEffects[sourceIndex];
+			if (kind === 0 || kind === 1) {
+				const sourceMatrix = captured.ints[sourceIntAt + 2];
+				if (sourceMatrix >= 0) {
+					const sourceMatrixAt = sourceMatrix * COLOR_MATRIX_FLOATS$1;
+					const destinationMatrixAt = destinationMatrix * COLOR_MATRIX_FLOATS$1;
+					colorMatrices.set(captured.colorMatrices.subarray(sourceMatrixAt, sourceMatrixAt + COLOR_MATRIX_FLOATS$1), destinationMatrixAt);
+					ints[destinationIntAt + 2] = destinationMatrix;
+				}
+			}
+		}
+		for (let index = start; index < start + captured.count; index += 1) markPatched(index);
+	}
+	function applyFragmentPatches(patches) {
+		if (!Array.isArray(patches)) return false;
+		const validated = [];
+		let previousStart = -1;
+		let previousEnd = 0;
+		for (const patch of patches) {
+			if (!patch || !Number.isInteger(patch.start)) return false;
+			const start = patch.start;
+			if (start < previousStart) return false;
+			let captured;
+			try {
+				captured = requireFragmentStorage(patch.fragment);
+			} catch {
+				return false;
+			}
+			if (start < previousEnd || !canPatchFragment(start, captured)) return false;
+			validated.push({
+				start,
+				captured
+			});
+			previousStart = start;
+			previousEnd = Math.max(previousEnd, start + captured.count);
+		}
+		for (const patch of validated) applyFragmentPatch(patch.start, patch.captured);
+		return true;
+	}
+	function writeQuadPayload(view, at) {
+		floats[at] = view.m[0];
+		floats[at + 1] = view.m[1];
+		floats[at + 2] = view.m[2];
+		floats[at + 3] = view.m[3];
+		floats[at + 4] = view.m[4];
+		floats[at + 5] = view.m[5];
+		floats[at + 6] = view.w;
+		floats[at + 7] = view.h;
+		floats[at + 8] = view.srcX;
+		floats[at + 9] = view.srcY;
+		floats[at + 10] = view.srcW;
+		floats[at + 11] = view.srcH;
+		floats[at + 12] = view.r;
+		floats[at + 13] = view.g;
+		floats[at + 14] = view.b;
+		floats[at + 15] = view.a;
+	}
+	function readQuadPayload(view, at) {
+		view.m[0] = floats[at];
+		view.m[1] = floats[at + 1];
+		view.m[2] = floats[at + 2];
+		view.m[3] = floats[at + 3];
+		view.m[4] = floats[at + 4];
+		view.m[5] = floats[at + 5];
+		view.w = floats[at + 6];
+		view.h = floats[at + 7];
+		view.srcX = floats[at + 8];
+		view.srcY = floats[at + 9];
+		view.srcW = floats[at + 10];
+		view.srcH = floats[at + 11];
+		view.r = floats[at + 12];
+		view.g = floats[at + 13];
+		view.b = floats[at + 14];
+		view.a = floats[at + 15];
+	}
+	function writeQuadInts(view, at, matrixIndex) {
+		ints[at] = view.blend;
+		ints[at + 1] = (view.flipH ? 1 : 0) | (view.flipV ? 2 : 0);
+		ints[at + 2] = matrixIndex;
+	}
+	function readQuadInts(view, at) {
+		view.blend = ints[at];
+		const flags = ints[at + 1];
+		view.flipH = (flags & 1) !== 0;
+		view.flipV = (flags & 2) !== 0;
+		const matrixIndex = ints[at + 2];
+		view.hasColorMatrix = matrixIndex >= 0;
+		if (matrixIndex >= 0) {
+			const from = matrixIndex * COLOR_MATRIX_FLOATS$1;
+			for (let i = 0; i < COLOR_MATRIX_FLOATS$1; i += 1) view.colorMatrix[i] = colorMatrices[from + i];
+		}
+	}
+	return {
+		get count() {
+			return count;
+		},
+		get clipDepth() {
+			return clipDepth;
+		},
+		get maxClipDepth() {
+			return maxClipDepth;
+		},
+		get structuralRevision() {
+			return structuralRevision;
+		},
+		get contentRevision() {
+			return contentRevision;
+		},
+		get floats() {
+			return floats;
+		},
+		get ints() {
+			return ints;
+		},
+		get colorMatrices() {
+			return colorMatrices;
+		},
+		reset() {
+			for (let i = 0; i < count; i += 1) {
+				textures[i] = null;
+				screenEffects[i] = null;
+				externalEffects[i] = null;
+			}
+			count = 0;
+			floatLength = 0;
+			intLength = 0;
+			colorMatrixCount = 0;
+			clipDepth = 0;
+			maxClipDepth = 0;
+			contentRevision += 1;
+			structuralRevision += 1;
+		},
+		appendFragment(fragment) {
+			const captured = requireFragmentStorage(fragment);
+			const start = count;
+			for (let sourceIndex = 0; sourceIndex < captured.count; sourceIndex += 1) {
+				const kind = captured.kinds[sourceIndex];
+				const floatAt = captured.floatOffsets[sourceIndex];
+				const intAt = captured.intOffsets[sourceIndex];
+				fillFragmentStoragePayloadLengths(captured, sourceIndex, fragmentAppendLengths);
+				if (floatAt < 0 || intAt < 0 || floatAt + fragmentAppendLengths.floats > captured.floatLength || intAt + fragmentAppendLengths.ints > captured.intLength) throw new RangeError(`draw-list fragment command ${sourceIndex} has an invalid arena range`);
+				const index = beginCommand(kind, fragmentAppendLengths.floats, fragmentAppendLengths.ints, captured.textures[sourceIndex]);
+				const targetFloatAt = floatOffsets[index];
+				const targetIntAt = intOffsets[index];
+				for (let offset = 0; offset < fragmentAppendLengths.floats; offset += 1) floats[targetFloatAt + offset] = captured.floats[floatAt + offset];
+				for (let offset = 0; offset < fragmentAppendLengths.ints; offset += 1) ints[targetIntAt + offset] = captured.ints[intAt + offset];
+				screenEffects[index] = captured.screenEffects[sourceIndex];
+				externalEffects[index] = captured.externalEffects[sourceIndex];
+				if (kind === 0 || kind === 1) {
+					const matrix = captured.ints[intAt + 2];
+					if (matrix >= 0) ints[targetIntAt + 2] = storeFragmentColorMatrix(captured.colorMatrices, matrix);
+				}
+				if (kind === 3) {
+					clipDepth += 1;
+					maxClipDepth = Math.max(maxClipDepth, clipDepth);
+				} else if (kind === 4) {
+					if (clipDepth <= 0) throw new RangeError("draw-list fragment popClip() with no clip rect pushed");
+					clipDepth -= 1;
+				}
+			}
+			return start;
+		},
+		patchFragment(start, fragment) {
+			return applyFragmentPatches([{
+				start,
+				fragment
+			}]);
+		},
+		patchFragments(patches) {
+			return applyFragmentPatches(patches);
+		},
+		kindAt(index) {
+			requireIndex(index);
+			return kinds[index];
+		},
+		commandRevisionAt(index) {
+			requireIndex(index);
+			return commandRevisions[index];
+		},
+		readPatchesSince(revision, out) {
+			const mutable = out;
+			mutable.begin(contentRevision);
+			if (revision === contentRevision) return out;
+			if (patchJournalCount === 0) {
+				mutable.overflow();
+				return out;
+			}
+			if (revision < patchJournalRevisions[patchJournalStart] - 1) {
+				mutable.overflow();
+				return out;
+			}
+			for (let offset = 0; offset < patchJournalCount; offset += 1) {
+				const slot = (patchJournalStart + offset) % patchJournalCapacity;
+				if (patchJournalRevisions[slot] > revision) mutable.add(patchJournalIndexes[slot]);
+			}
+			return out;
+		},
+		kindNameAt(index) {
+			requireIndex(index);
+			return DRAW_COMMAND_NAMES[kinds[index]];
+		},
+		textureAt(index) {
+			requireIndex(index);
+			return textures[index];
+		},
+		screenEffectAt(index) {
+			requireIndex(index);
+			return screenEffects[index];
+		},
+		externalEffectAt(index) {
+			requireIndex(index);
+			return externalEffects[index];
+		},
+		floatOffsetAt(index) {
+			requireIndex(index);
+			return floatOffsets[index];
+		},
+		intOffsetAt(index) {
+			requireIndex(index);
+			return intOffsets[index];
+		},
+		colorMatrixIndexAt(index) {
+			requireIndex(index);
+			const kind = kinds[index];
+			if (kind !== 0 && kind !== 1) return -1;
+			return ints[intOffsets[index] + 2];
+		},
+		pushQuad(quad, texture = null) {
+			const matrixIndex = storeColorMatrix(quad);
+			const index = beginCommand(0, QUAD_FLOATS, QUAD_INTS, texture);
+			writeQuadPayload(quad, floatOffsets[index]);
+			writeQuadInts(quad, intOffsets[index], matrixIndex);
+			return index;
+		},
+		pushNinePatch(patch, texture = null) {
+			const matrixIndex = storeColorMatrix(patch);
+			const index = beginCommand(1, NINE_PATCH_FLOATS, NINE_PATCH_INTS, texture);
+			const at = floatOffsets[index];
+			writeQuadPayload(patch, at);
+			floats[at + QUAD_FLOATS] = patch.marginLeft;
+			floats[at + QUAD_FLOATS + 1] = patch.marginTop;
+			floats[at + QUAD_FLOATS + 2] = patch.marginRight;
+			floats[at + QUAD_FLOATS + 3] = patch.marginBottom;
+			writeQuadInts(patch, intOffsets[index], matrixIndex);
+			return index;
+		},
+		pushPolyline(line) {
+			const pointCount = Math.max(0, Math.floor(line.pointCount));
+			if (pointCount * 2 > line.points.length) throw new RangeError(`polyline claims ${pointCount} points but its buffer holds ${Math.floor(line.points.length / 2)}`);
+			const index = beginCommand(2, POLYLINE_HEADER_FLOATS + pointCount * 2, POLYLINE_INTS, null);
+			const at = floatOffsets[index];
+			floats[at] = line.width;
+			floats[at + 1] = line.r;
+			floats[at + 2] = line.g;
+			floats[at + 3] = line.b;
+			floats[at + 4] = line.a;
+			floats.set(line.points.subarray(0, pointCount * 2), at + POLYLINE_HEADER_FLOATS);
+			ints[intOffsets[index]] = pointCount;
+			return index;
+		},
+		pushTexturedMesh(mesh, texture = null) {
+			const vertexCount = Math.max(0, Math.floor(mesh.vertexCount));
+			const indexCount = Math.max(0, Math.floor(mesh.indexCount));
+			if (mesh.m.length < 6) throw new RangeError(`textured mesh transform needs 6 entries, got ${mesh.m.length}`);
+			if (vertexCount * 2 > mesh.positions.length) throw new RangeError(`textured mesh claims ${vertexCount} vertices but its position buffer holds ${Math.floor(mesh.positions.length / 2)}`);
+			if (vertexCount * 2 > mesh.uvs.length) throw new RangeError(`textured mesh claims ${vertexCount} vertices but its UV buffer holds ${Math.floor(mesh.uvs.length / 2)}`);
+			if (indexCount > mesh.indices.length) throw new RangeError(`textured mesh claims ${indexCount} indices but its index buffer holds ${mesh.indices.length}`);
+			if (indexCount % 3 !== 0) throw new RangeError(`textured mesh index count ${indexCount} is not a triangle list`);
+			for (let i = 0; i < indexCount; i += 1) if (mesh.indices[i] >= vertexCount) throw new RangeError(`textured mesh index ${mesh.indices[i]} at ${i} is outside ${vertexCount} vertices`);
+			const index = beginCommand(6, TEXTURED_MESH_HEADER_FLOATS + vertexCount * 4, TEXTURED_MESH_HEADER_INTS + indexCount, texture);
+			const at = floatOffsets[index];
+			for (let i = 0; i < 6; i += 1) floats[at + i] = mesh.m[i];
+			floats[at + 6] = mesh.r;
+			floats[at + 7] = mesh.g;
+			floats[at + 8] = mesh.b;
+			floats[at + 9] = mesh.a;
+			const positionsAt = at + TEXTURED_MESH_HEADER_FLOATS;
+			for (let i = 0; i < vertexCount * 2; i += 1) {
+				floats[positionsAt + i] = mesh.positions[i];
+				floats[positionsAt + vertexCount * 2 + i] = mesh.uvs[i];
+			}
+			const intAt = intOffsets[index];
+			ints[intAt] = vertexCount;
+			ints[intAt + 1] = indexCount;
+			ints[intAt + 2] = mesh.blend;
+			for (let i = 0; i < indexCount; i += 1) ints[intAt + TEXTURED_MESH_HEADER_INTS + i] = mesh.indices[i];
+			return index;
+		},
+		pushGlyphs(run) {
+			const glyphCount = Math.max(0, Math.floor(run.glyphCount));
+			if (glyphCount * 2 > run.positions.length) throw new RangeError(`glyph run claims ${glyphCount} glyphs but its position buffer holds ${Math.floor(run.positions.length / 2)}`);
+			if (glyphCount > run.slots.length) throw new RangeError(`glyph run claims ${glyphCount} glyphs but its slot buffer holds ${run.slots.length}`);
+			const index = beginCommand(5, GLYPHS_HEADER_FLOATS + glyphCount * 2, GLYPHS_HEADER_INTS + glyphCount, null);
+			const at = floatOffsets[index];
+			floats[at] = run.m[0];
+			floats[at + 1] = run.m[1];
+			floats[at + 2] = run.m[2];
+			floats[at + 3] = run.m[3];
+			floats[at + 4] = run.m[4];
+			floats[at + 5] = run.m[5];
+			floats[at + 6] = run.pixelsPerEm;
+			floats[at + 7] = run.r;
+			floats[at + 8] = run.g;
+			floats[at + 9] = run.b;
+			floats[at + 10] = run.a;
+			floats[at + GLYPHS_SPREAD_OFFSET] = Number.isFinite(run.spreadPx) ? run.spreadPx : 0;
+			floats[at + GLYPHS_INK_X_OFFSET] = finiteOrNaN(run.localInkX);
+			floats[at + GLYPHS_INK_Y_OFFSET] = finiteOrNaN(run.localInkY);
+			floats[at + GLYPHS_INK_WIDTH_OFFSET] = finiteOrNaN(run.localInkWidth);
+			floats[at + GLYPHS_INK_HEIGHT_OFFSET] = finiteOrNaN(run.localInkHeight);
+			floats[at + GLYPHS_INK_OUTSET_OFFSET] = finiteOrNaN(run.localInkOutset);
+			floats.set(run.positions.subarray(0, glyphCount * 2), at + GLYPHS_HEADER_FLOATS);
+			const intAt = intOffsets[index];
+			ints[intAt] = glyphCount;
+			ints.set(run.slots.subarray(0, glyphCount), intAt + GLYPHS_HEADER_INTS);
+			return index;
+		},
+		pushScreenEffect(command) {
+			const index = beginCommand(7, 0, 0, null);
+			screenEffects[index] = command;
+			return index;
+		},
+		pushExternalEffect(command) {
+			const index = beginCommand(8, 0, 0, null);
+			externalEffects[index] = command;
+			return index;
+		},
+		pushClipRect(clip) {
+			const index = beginCommand(3, CLIP_FLOATS, 0, null);
+			const at = floatOffsets[index];
+			floats[at] = clip.x;
+			floats[at + 1] = clip.y;
+			floats[at + 2] = clip.w;
+			floats[at + 3] = clip.h;
+			floats[at + 4] = clip.cornerRadius;
+			floats[at + 5] = clip.outsetX;
+			clipDepth += 1;
+			if (clipDepth > maxClipDepth) maxClipDepth = clipDepth;
+			return index;
+		},
+		popClip() {
+			if (clipDepth === 0) throw new RangeError("draw-list popClip() with no clip rect pushed");
+			const index = beginCommand(4, 0, 0, null);
+			clipDepth -= 1;
+			return index;
+		},
+		readQuad(index, out) {
+			requireKind(index, 0);
+			readQuadPayload(out, floatOffsets[index]);
+			readQuadInts(out, intOffsets[index]);
+			return out;
+		},
+		readNinePatch(index, out) {
+			requireKind(index, 1);
+			const at = floatOffsets[index];
+			readQuadPayload(out, at);
+			out.marginLeft = floats[at + QUAD_FLOATS];
+			out.marginTop = floats[at + QUAD_FLOATS + 1];
+			out.marginRight = floats[at + QUAD_FLOATS + 2];
+			out.marginBottom = floats[at + QUAD_FLOATS + 3];
+			readQuadInts(out, intOffsets[index]);
+			return out;
+		},
+		readPolyline(index, out) {
+			requireKind(index, 2);
+			const at = floatOffsets[index];
+			out.width = floats[at];
+			out.r = floats[at + 1];
+			out.g = floats[at + 2];
+			out.b = floats[at + 3];
+			out.a = floats[at + 4];
+			const pointCount = ints[intOffsets[index]];
+			out.pointCount = pointCount;
+			if (out.points.length < pointCount * 2) out.points = new Float32Array(pointCount * 2);
+			const from = at + POLYLINE_HEADER_FLOATS;
+			out.points.set(floats.subarray(from, from + pointCount * 2));
+			return out;
+		},
+		readTexturedMesh(index, out) {
+			requireTexturedMesh(index);
+			const at = floatOffsets[index];
+			const intAt = intOffsets[index];
+			const vertexCount = ints[intAt];
+			const indexCount = ints[intAt + 1];
+			for (let i = 0; i < 6; i += 1) out.m[i] = floats[at + i];
+			out.r = floats[at + 6];
+			out.g = floats[at + 7];
+			out.b = floats[at + 8];
+			out.a = floats[at + 9];
+			out.vertexCount = vertexCount;
+			out.indexCount = indexCount;
+			out.blend = ints[intAt + 2];
+			if (out.positions.length < vertexCount * 2) out.positions = new Float32Array(vertexCount * 2);
+			if (out.uvs.length < vertexCount * 2) out.uvs = new Float32Array(vertexCount * 2);
+			if (out.indices.length < indexCount) out.indices = new Uint32Array(indexCount);
+			const positionsAt = at + TEXTURED_MESH_HEADER_FLOATS;
+			for (let i = 0; i < vertexCount * 2; i += 1) {
+				out.positions[i] = floats[positionsAt + i];
+				out.uvs[i] = floats[positionsAt + vertexCount * 2 + i];
+			}
+			for (let i = 0; i < indexCount; i += 1) out.indices[i] = ints[intAt + TEXTURED_MESH_HEADER_INTS + i];
+			return out;
+		},
+		readGlyphs(index, out) {
+			requireKind(index, 5);
+			const at = floatOffsets[index];
+			out.m[0] = floats[at];
+			out.m[1] = floats[at + 1];
+			out.m[2] = floats[at + 2];
+			out.m[3] = floats[at + 3];
+			out.m[4] = floats[at + 4];
+			out.m[5] = floats[at + 5];
+			out.pixelsPerEm = floats[at + 6];
+			out.r = floats[at + 7];
+			out.g = floats[at + 8];
+			out.b = floats[at + 9];
+			out.a = floats[at + 10];
+			out.spreadPx = floats[at + GLYPHS_SPREAD_OFFSET];
+			out.localInkX = floats[at + GLYPHS_INK_X_OFFSET];
+			out.localInkY = floats[at + GLYPHS_INK_Y_OFFSET];
+			out.localInkWidth = floats[at + GLYPHS_INK_WIDTH_OFFSET];
+			out.localInkHeight = floats[at + GLYPHS_INK_HEIGHT_OFFSET];
+			out.localInkOutset = floats[at + GLYPHS_INK_OUTSET_OFFSET];
+			const intAt = intOffsets[index];
+			const glyphCount = ints[intAt];
+			out.glyphCount = glyphCount;
+			if (out.slots.length < glyphCount) out.slots = new Int32Array(glyphCount);
+			if (out.positions.length < glyphCount * 2) out.positions = new Float32Array(glyphCount * 2);
+			out.slots.set(ints.subarray(intAt + GLYPHS_HEADER_INTS, intAt + 1 + glyphCount));
+			const from = at + GLYPHS_HEADER_FLOATS;
+			out.positions.set(floats.subarray(from, from + glyphCount * 2));
+			return out;
+		},
+		readClipRect(index, out) {
+			requireKind(index, 3);
+			const at = floatOffsets[index];
+			out.x = floats[at];
+			out.y = floats[at + 1];
+			out.w = floats[at + 2];
+			out.h = floats[at + 3];
+			out.cornerRadius = floats[at + 4];
+			out.outsetX = floats[at + 5];
+			return out;
+		},
+		patchQuadTransform(index, m) {
+			requireQuadLike(index);
+			if (m.length < 6) throw new RangeError(`draw-list patchQuadTransform needs 6 transform entries, got ${m.length}`);
+			const at = floatOffsets[index];
+			floats[at] = m[0];
+			floats[at + 1] = m[1];
+			floats[at + 2] = m[2];
+			floats[at + 3] = m[3];
+			floats[at + 4] = m[4];
+			floats[at + 5] = m[5];
+			markPatched(index);
+		},
+		patchQuadColor(index, r, g, b, a) {
+			requireQuadLike(index);
+			const at = floatOffsets[index];
+			floats[at + 12] = r;
+			floats[at + 13] = g;
+			floats[at + 14] = b;
+			floats[at + 15] = a;
+			markPatched(index);
+		},
+		patchQuadSource(index, texture, srcX, srcY, srcW, srcH) {
+			requireQuadLike(index);
+			const at = floatOffsets[index];
+			textures[index] = texture;
+			floats[at + 8] = srcX;
+			floats[at + 9] = srcY;
+			floats[at + 10] = srcW;
+			floats[at + 11] = srcH;
+			markPatched(index);
+		},
+		patchTexturedMeshPositions(index, positions) {
+			requireTexturedMesh(index);
+			const intAt = intOffsets[index];
+			const vertexCount = ints[intAt];
+			if (positions.length < vertexCount * 2) throw new RangeError(`textured mesh position patch needs ${vertexCount * 2} entries, got ${positions.length}`);
+			const at = floatOffsets[index] + TEXTURED_MESH_HEADER_FLOATS;
+			for (let i = 0; i < vertexCount * 2; i += 1) floats[at + i] = positions[i];
+			markPatched(index);
+		},
+		patchTexturedMeshUvs(index, uvs) {
+			requireTexturedMesh(index);
+			const intAt = intOffsets[index];
+			const vertexCount = ints[intAt];
+			if (uvs.length < vertexCount * 2) throw new RangeError(`textured mesh UV patch needs ${vertexCount * 2} entries, got ${uvs.length}`);
+			const at = floatOffsets[index] + TEXTURED_MESH_HEADER_FLOATS + vertexCount * 2;
+			for (let i = 0; i < vertexCount * 2; i += 1) floats[at + i] = uvs[i];
+			markPatched(index);
+		},
+		patchTexturedMeshSource(index, texture) {
+			requireTexturedMesh(index);
+			textures[index] = texture;
+			markPatched(index);
+		},
+		patchTexturedMeshTransform(index, m) {
+			requireTexturedMesh(index);
+			if (m.length < 6) throw new RangeError(`draw-list patchTexturedMeshTransform needs 6 transform entries, got ${m.length}`);
+			const at = floatOffsets[index];
+			for (let i = 0; i < 6; i += 1) floats[at + i] = m[i];
+			markPatched(index);
+		},
+		patchTexturedMeshColor(index, r, g, b, a) {
+			requireTexturedMesh(index);
+			const at = floatOffsets[index];
+			floats[at + 6] = r;
+			floats[at + 7] = g;
+			floats[at + 8] = b;
+			floats[at + 9] = a;
+			markPatched(index);
+		},
+		patchGlyphsTransform(index, m) {
+			requireKind(index, 5);
+			if (m.length < 6) throw new RangeError(`draw-list patchGlyphsTransform needs 6 transform entries, got ${m.length}`);
+			const at = floatOffsets[index];
+			floats[at] = m[0];
+			floats[at + 1] = m[1];
+			floats[at + 2] = m[2];
+			floats[at + 3] = m[3];
+			floats[at + 4] = m[4];
+			floats[at + 5] = m[5];
+			markPatched(index);
+		},
+		patchGlyphsColor(index, r, g, b, a) {
+			requireKind(index, 5);
+			const at = floatOffsets[index];
+			floats[at + 7] = r;
+			floats[at + 8] = g;
+			floats[at + 9] = b;
+			floats[at + 10] = a;
+			markPatched(index);
+		}
+	};
+}
+//#endregion
+//#region src/batcher.ts
+/**
+* The quad batcher: everything the executor knows about MERGING draws, with no
+* GL in it, so the flush decisions — the thing that decides whether a frame is 20
+* draw calls or 200 — are unit-testable rather than inferred from a profiler.
+*
+* WHY MULTI-TEXTURE BATCHING IS THE WHOLE POINT. Probing recorded scenes for
+* batch runs (a run = a maximal span of consecutive painting nodes sharing
+* texture + blend + clip + colour-matrix state) found combat at 152 runs over 183
+* painting nodes — 1.2 nodes per batch, i.e. essentially no batching — and 151 of
+* those 152 breaks were the TEXTURE alone. The map is the same story: 174 runs
+* over 825 nodes, 173 texture breaks. But the number of DISTINCT textures per
+* screen is only 24-65. So a batch that can hold many textures at once collapses
+* the run count towards the number of times the state that a batch CANNOT hold
+* changes — blend (0-16 per screen) and clip (0-26) — plus one flush per
+* texture-table refill. That is the difference between "tens of draws" and "one
+* draw per node", and it is why the slot table below is not an optimization to
+* add later.
+*
+* HOW A TEXTURE STOPS BREAKING A BATCH. Each batch binds up to
+* `maxTextureSlots` textures to consecutive texture units and each quad carries
+* the INDEX of the one it samples. The fragment shader turns that index back into
+* a sampler with a compiled `if` ladder (GLSL ES 3.00 forbids indexing a sampler
+* array with anything but a constant). A quad whose texture is not in the table
+* takes the next free slot; when the table is full the batch flushes and starts a
+* new table.
+*
+* COLOUR MATRICES GET THE SAME TREATMENT, for the same reason at a smaller scale:
+* the card screens carry 30-48 HSV-transformed quads, and one draw call each
+* would undo the texture win. A batch holds up to `maxColorMatrices` matrices in
+* a uniform array with the IDENTITY pinned at slot 0, so "no matrix" costs
+* nothing and needs no separate program. Identical matrices share a slot (the
+* table is deduped by value), which matters because those 30-48 quads are usually
+* a handful of distinct tints applied to many cards.
+*
+* ORDER IS NEVER REORDERED. Instances are drawn in the order they were pushed —
+* `drawArraysInstanced` rasterizes instance N before instance N+1, which is the
+* property a painter's-algorithm 2D renderer with no depth buffer depends on. So
+* this batcher only ever MERGES CONSECUTIVE commands; it never sorts, and it can
+* therefore be dropped in front of any draw list without changing what the frame
+* looks like. Bucketing non-adjacent commands by texture is a separate,
+* order-unsafe transformation that belongs to whoever BUILDS the list and knows
+* which spans are safe to permute.
+*
+* FOUR EXPLICIT CORNERS, NOT AN AFFINE BASIS. An instance carries `p0..p3`
+* outright (8 floats) rather than a 2x3 transform (6). The two extra floats buy
+* arbitrary quadrilaterals, which is what lets `./polyline`'s stroke segments AND
+* its join wedges (a triangle spelled as a quad with two coincident corners) ride
+* in the same buffer, the same shader and the same batch as every sprite. The
+* alternative — a second program and a mid-frame break for every polyline — costs
+* far more than 8 bytes per quad. The consequence to know about: UV interpolates
+* affinely per triangle, so a NON-parallelogram textured quad would show a seam
+* along the split diagonal. Nothing produces one (sprites and nine-patch bands
+* are affine images of a rect; the non-affine quads are untextured stroke
+* geometry), and if something ever does, the fix is to split it rather than to
+* make every quad pay for projective interpolation.
+*/
+/** Floats per instance. See the field offsets below for the layout. */
+const INSTANCE_FLOATS = 18;
+/** Offset of `p0.x` — four `(x, y)` corners, in the unit-square order
+*  `(0,0)`, `(1,0)`, `(1,1)`, `(0,1)`. Design space. */
+const INSTANCE_CORNERS_OFFSET = 0;
+/** Offset of the normalized source rect `(u0, v0, uSpan, vSpan)`. A span is
+*  NEGATIVE for a flipped axis, which is how `FLIP_H`/`FLIP_V` are carried. */
+const INSTANCE_UV_OFFSET = 8;
+/** Offset of the PREMULTIPLIED tint, `(r, g, b, a)`. */
+const INSTANCE_COLOR_OFFSET = 12;
+/** Offset of `(textureSlot, colorMatrixSlot)`. Matrix slot 0 is the identity. */
+const INSTANCE_SLOTS_OFFSET = 16;
+/** Floats per colour-matrix slot. */
+const COLOR_MATRIX_FLOATS = 9;
+/** The most texture units this batcher will ever ask for, whatever the GPU
+*  reports. Sixteen is the WebGL2 (GLES 3.0) guaranteed minimum for
+*  `MAX_TEXTURE_IMAGE_UNITS`, so asking for more buys a shader that some
+*  conformant device cannot link, in exchange for a batch boundary the measured
+*  key counts (24-65 distinct textures per screen) would still hit. */
+const MAX_TEXTURE_SLOTS = 16;
+/** Default colour-matrix table size, including the identity at slot 0. */
+const DEFAULT_COLOR_MATRIX_SLOTS = 16;
+function createQuadInstance() {
+	return {
+		x0: 0,
+		y0: 0,
+		x1: 0,
+		y1: 0,
+		x2: 0,
+		y2: 0,
+		x3: 0,
+		y3: 0,
+		u0: 0,
+		v0: 0,
+		uSpan: 1,
+		vSpan: 1,
+		r: 1,
+		g: 1,
+		b: 1,
+		a: 1
+	};
+}
+function emptyFlushCounts() {
+	return {
+		textureSlots: 0,
+		colorMatrices: 0,
+		blend: 0,
+		clip: 0,
+		glyphs: 0,
+		effects: 0,
+		meshes: 0,
+		compiled: 0,
+		end: 0
+	};
+}
+function zeroFlushCounts(counts) {
+	counts.textureSlots = 0;
+	counts.colorMatrices = 0;
+	counts.blend = 0;
+	counts.clip = 0;
+	counts.glyphs = 0;
+	counts.effects = 0;
+	counts.meshes = 0;
+	counts.compiled = 0;
+	counts.end = 0;
+}
+function createQuadBatcher(options) {
+	const maxTextureSlots = Math.max(1, Math.min(16, Math.floor(options.maxTextureSlots ?? 16)));
+	const maxColorMatrices = Math.max(1, Math.floor(options.maxColorMatrices ?? 16));
+	const draw = options.draw;
+	let instances = new Float32Array(Math.max(1, Math.floor(options.quadCapacity ?? 512)) * 18);
+	let quadCount = 0;
+	const textures = new Array(maxTextureSlots).fill(null);
+	let textureCount = 0;
+	const colorMatrices = new Float32Array(maxColorMatrices * 9);
+	colorMatrices.set(IDENTITY_COLOR_MATRIX, 0);
+	let colorMatrixCount = 1;
+	let blend = 0;
+	let clipEpoch = 0;
+	const quad = createQuadInstance();
+	const stats = {
+		batches: 0,
+		quads: 0,
+		textureBinds: 0,
+		maxBatchQuads: 0,
+		arenaGrowths: 0,
+		flushes: emptyFlushCounts()
+	};
+	const batch = {
+		instances,
+		quadCount: 0,
+		textures,
+		textureCount: 0,
+		colorMatrices,
+		colorMatrixCount: 1,
+		blend,
+		clipEpoch: 0,
+		reason: "end"
+	};
+	function flush(reason = "end") {
+		if (quadCount === 0) return;
+		batch.instances = instances;
+		batch.quadCount = quadCount;
+		batch.textureCount = textureCount;
+		batch.colorMatrixCount = colorMatrixCount;
+		batch.blend = blend;
+		batch.clipEpoch = clipEpoch;
+		batch.reason = reason;
+		stats.batches += 1;
+		stats.textureBinds += textureCount;
+		if (quadCount > stats.maxBatchQuads) stats.maxBatchQuads = quadCount;
+		stats.flushes[reason] += 1;
+		draw(batch);
+		quadCount = 0;
+		for (let i = 0; i < textureCount; i += 1) textures[i] = null;
+		textureCount = 0;
+		colorMatrixCount = 1;
+	}
+	/** The texture's slot in the open batch, or -1 when the table is full. */
+	function slotFor(texture) {
+		for (let i = 0; i < textureCount; i += 1) if (textures[i] === texture) return i;
+		if (textureCount >= maxTextureSlots) return -1;
+		textures[textureCount] = texture;
+		textureCount += 1;
+		return textureCount - 1;
+	}
+	/** The matrix's slot, deduped by value, or -1 when the table is full. */
+	function matrixSlotFor(matrix, offset) {
+		for (let i = 0; i < colorMatrixCount; i += 1) if (colorMatricesEqual(colorMatrices, i * 9, matrix, offset)) return i;
+		if (colorMatrixCount >= maxColorMatrices) return -1;
+		const at = colorMatrixCount * 9;
+		for (let i = 0; i < 9; i += 1) colorMatrices[at + i] = matrix[offset + i];
+		colorMatrixCount += 1;
+		return colorMatrixCount - 1;
+	}
+	function ensureCapacity() {
+		const needed = (quadCount + 1) * 18;
+		if (needed <= instances.length) return;
+		let capacity = Math.max(18, instances.length);
+		while (capacity < needed) capacity *= 2;
+		const grown = new Float32Array(capacity);
+		grown.set(instances);
+		instances = grown;
+		stats.arenaGrowths += 1;
+	}
+	return {
+		maxTextureSlots,
+		maxColorMatrices,
+		get quadCount() {
+			return quadCount;
+		},
+		get textureCount() {
+			return textureCount;
+		},
+		get colorMatrixCount() {
+			return colorMatrixCount;
+		},
+		get blend() {
+			return blend;
+		},
+		stats,
+		quad,
+		reset() {
+			quadCount = 0;
+			for (let i = 0; i < textureCount; i += 1) textures[i] = null;
+			textureCount = 0;
+			colorMatrixCount = 1;
+			blend = 0;
+			clipEpoch = 0;
+			stats.batches = 0;
+			stats.quads = 0;
+			stats.textureBinds = 0;
+			stats.maxBatchQuads = 0;
+			stats.arenaGrowths = 0;
+			zeroFlushCounts(stats.flushes);
+		},
+		setBlend(next) {
+			if (next === blend) return;
+			flush("blend");
+			blend = next;
+		},
+		setClipEpoch(epoch) {
+			if (epoch === clipEpoch) return;
+			flush("clip");
+			clipEpoch = epoch;
+		},
+		push(texture, colorMatrix = null, colorMatrixOffset = 0) {
+			let slot = slotFor(texture);
+			if (slot < 0) {
+				flush("textureSlots");
+				slot = slotFor(texture);
+			}
+			let matrixSlot = 0;
+			if (colorMatrix) {
+				matrixSlot = matrixSlotFor(colorMatrix, colorMatrixOffset);
+				if (matrixSlot < 0) {
+					flush("colorMatrices");
+					slot = slotFor(texture);
+					matrixSlot = matrixSlotFor(colorMatrix, colorMatrixOffset);
+					if (matrixSlot < 0) matrixSlot = 0;
+				}
+			}
+			ensureCapacity();
+			const at = quadCount * 18;
+			instances[at] = quad.x0;
+			instances[at + 1] = quad.y0;
+			instances[at + 2] = quad.x1;
+			instances[at + 3] = quad.y1;
+			instances[at + 4] = quad.x2;
+			instances[at + 5] = quad.y2;
+			instances[at + 6] = quad.x3;
+			instances[at + 7] = quad.y3;
+			instances[at + 8] = quad.u0;
+			instances[at + 9] = quad.v0;
+			instances[at + 10] = quad.uSpan;
+			instances[at + 11] = quad.vSpan;
+			instances[at + 12] = quad.r;
+			instances[at + 13] = quad.g;
+			instances[at + 14] = quad.b;
+			instances[at + 15] = quad.a;
+			instances[at + 16] = slot;
+			instances[at + 17] = matrixSlot;
+			quadCount += 1;
+			stats.quads += 1;
+		},
+		flush
+	};
+}
+//#endregion
+//#region src/clip-stack.ts
+function createEntry() {
+	return {
+		minX: 0,
+		minY: 0,
+		maxX: 0,
+		maxY: 0,
+		roundedCenterX: 0,
+		roundedCenterY: 0,
+		roundedHalfWidth: 0,
+		roundedHalfHeight: 0,
+		roundedRadius: 0
+	};
+}
+function createScissorBox() {
+	return {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	};
+}
+/** True when `transform` is a pure scale + translate, i.e. a scissor can be exact. */
+function isAxisAligned(transform) {
+	return transform[1] === 0 && transform[2] === 0;
+}
+function createClipStack() {
+	const entries = [];
+	let depth = 0;
+	let epoch = 0;
+	let rotatedFallbacks = 0;
+	const boundsOut = {
+		minX: 0,
+		minY: 0,
+		maxX: 0,
+		maxY: 0
+	};
+	const roundedOut = {
+		centerX: 0,
+		centerY: 0,
+		halfWidth: 0,
+		halfHeight: 0,
+		radius: 0
+	};
+	return {
+		get depth() {
+			return depth;
+		},
+		get epoch() {
+			return epoch;
+		},
+		get rotatedFallbacks() {
+			return rotatedFallbacks;
+		},
+		bounds() {
+			if (depth === 0) return null;
+			const top = entries[depth - 1];
+			boundsOut.minX = top.minX;
+			boundsOut.minY = top.minY;
+			boundsOut.maxX = top.maxX;
+			boundsOut.maxY = top.maxY;
+			return boundsOut;
+		},
+		rounded() {
+			if (depth === 0) return null;
+			const top = entries[depth - 1];
+			if (!(top.roundedRadius > 0)) return null;
+			roundedOut.centerX = top.roundedCenterX;
+			roundedOut.centerY = top.roundedCenterY;
+			roundedOut.halfWidth = top.roundedHalfWidth;
+			roundedOut.halfHeight = top.roundedHalfHeight;
+			roundedOut.radius = top.roundedRadius;
+			return roundedOut;
+		},
+		push(clip) {
+			while (entries.length <= depth) entries.push(createEntry());
+			const entry = entries[depth];
+			const outset = Math.max(0, clip.outsetX);
+			let minX = clip.x - outset;
+			let minY = clip.y;
+			let maxX = clip.x + clip.w + outset;
+			let maxY = clip.y + clip.h;
+			const parent = depth > 0 ? entries[depth - 1] : null;
+			if (parent) {
+				if (parent.minX > minX) minX = parent.minX;
+				if (parent.minY > minY) minY = parent.minY;
+				if (parent.maxX < maxX) maxX = parent.maxX;
+				if (parent.maxY < maxY) maxY = parent.maxY;
+			}
+			entry.minX = minX;
+			entry.minY = minY;
+			entry.maxX = Math.max(minX, maxX);
+			entry.maxY = Math.max(minY, maxY);
+			if (clip.cornerRadius > 0) {
+				const halfWidth = (clip.w + outset * 2) / 2;
+				const halfHeight = clip.h / 2;
+				entry.roundedCenterX = clip.x - outset + halfWidth;
+				entry.roundedCenterY = clip.y + halfHeight;
+				entry.roundedHalfWidth = Math.max(0, halfWidth);
+				entry.roundedHalfHeight = Math.max(0, halfHeight);
+				entry.roundedRadius = Math.min(clip.cornerRadius, entry.roundedHalfWidth, entry.roundedHalfHeight);
+			} else if (parent) {
+				entry.roundedCenterX = parent.roundedCenterX;
+				entry.roundedCenterY = parent.roundedCenterY;
+				entry.roundedHalfWidth = parent.roundedHalfWidth;
+				entry.roundedHalfHeight = parent.roundedHalfHeight;
+				entry.roundedRadius = parent.roundedRadius;
+			} else entry.roundedRadius = 0;
+			depth += 1;
+			epoch += 1;
+		},
+		pop() {
+			if (depth === 0) throw new RangeError("clip stack pop with no clip pushed");
+			depth -= 1;
+			epoch += 1;
+		},
+		reset() {
+			if (depth !== 0) epoch += 1;
+			depth = 0;
+			rotatedFallbacks = 0;
+		},
+		scissor(transform, width, height, out) {
+			if (depth === 0) {
+				out.x = 0;
+				out.y = 0;
+				out.width = Math.max(0, width);
+				out.height = Math.max(0, height);
+				return out;
+			}
+			const top = entries[depth - 1];
+			const xx = transform[0];
+			const xy = transform[1];
+			const yx = transform[2];
+			const yy = transform[3];
+			const ox = transform[4];
+			const oy = transform[5];
+			if (xy !== 0 || yx !== 0) rotatedFallbacks += 1;
+			let minPx = Number.POSITIVE_INFINITY;
+			let minPy = Number.POSITIVE_INFINITY;
+			let maxPx = Number.NEGATIVE_INFINITY;
+			let maxPy = Number.NEGATIVE_INFINITY;
+			for (let corner = 0; corner < 4; corner += 1) {
+				const x = corner === 0 || corner === 3 ? top.minX : top.maxX;
+				const y = corner < 2 ? top.minY : top.maxY;
+				const px = xx * x + yx * y + ox;
+				const py = xy * x + yy * y + oy;
+				if (px < minPx) minPx = px;
+				if (px > maxPx) maxPx = px;
+				if (py < minPy) minPy = py;
+				if (py > maxPy) maxPy = py;
+			}
+			const left = clampInt(Math.floor(minPx), 0, width);
+			const right = clampInt(Math.ceil(maxPx), 0, width);
+			const top_ = clampInt(Math.floor(minPy), 0, height);
+			const bottom = clampInt(Math.ceil(maxPy), 0, height);
+			out.x = left;
+			out.width = Math.max(0, right - left);
+			out.y = Math.max(0, height - bottom);
+			out.height = Math.max(0, bottom - top_);
+			return out;
+		}
+	};
+}
+function clampInt(value, low, high) {
+	if (!Number.isFinite(value)) return value < 0 ? low : high;
+	return value < low ? low : value > high ? high : value;
+}
+//#endregion
+//#region src/damage.ts
+/** Retained replay uses fixed physical-pixel tiles, never CSS pixels. */
+const RETAINED_DAMAGE_TILE_SIZE = 64;
+/** The largest tile coverage that is worth planning for retained replay. */
+const RETAINED_MAX_DAMAGE_COVERAGE = .2;
+function createDamageRect() {
+	return {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	};
+}
+function isDamageEmpty(rect) {
+	return !(rect.width > 0 && rect.height > 0);
+}
+/** Expand in the rectangle's own coordinate space without mutating inputs. */
+function outsetDamageRect(rect, outset, out = createDamageRect()) {
+	if (!isFiniteDamageRect(rect) || !Number.isFinite(outset) || outset < 0) return null;
+	out.x = rect.x - outset;
+	out.y = rect.y - outset;
+	out.width = rect.width + outset * 2;
+	out.height = rect.height + outset * 2;
+	return isFiniteDamageRect(out) ? out : null;
+}
+/** True when two half-open rectangles overlap. Touching edges do not repaint. */
+function damageIntersects(a, b) {
+	return a.width > 0 && a.height > 0 && b.width > 0 && b.height > 0 && a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+/** Expand `out` to cover both input rectangles. */
+function unionDamageRect(a, b, out = createDamageRect()) {
+	if (isDamageEmpty(a)) {
+		out.x = b.x;
+		out.y = b.y;
+		out.width = Math.max(0, b.width);
+		out.height = Math.max(0, b.height);
+		return out;
+	}
+	if (isDamageEmpty(b)) {
+		out.x = a.x;
+		out.y = a.y;
+		out.width = Math.max(0, a.width);
+		out.height = Math.max(0, a.height);
+		return out;
+	}
+	const minX = Math.min(a.x, b.x);
+	const minY = Math.min(a.y, b.y);
+	const maxX = Math.max(a.x + a.width, b.x + b.width);
+	const maxY = Math.max(a.y + a.height, b.y + b.height);
+	out.x = minX;
+	out.y = minY;
+	out.width = Math.max(0, maxX - minX);
+	out.height = Math.max(0, maxY - minY);
+	return out;
+}
+/** Transform all four corners, returning the enclosing axis-aligned rectangle. */
+function transformDamageRect(rect, transform, out = createDamageRect()) {
+	return transformDamageValues(rect.x, rect.y, rect.width, rect.height, transform, out);
+}
+/** Allocation-free coordinate form used by command bounds in retained loops. */
+function transformDamageValues(x0, y0, width, height, transform, out, transformOffset = 0) {
+	let minX = Number.POSITIVE_INFINITY;
+	let minY = Number.POSITIVE_INFINITY;
+	let maxX = Number.NEGATIVE_INFINITY;
+	let maxY = Number.NEGATIVE_INFINITY;
+	for (let corner = 0; corner < 4; corner += 1) {
+		const x = corner === 0 || corner === 3 ? x0 : x0 + width;
+		const y = corner < 2 ? y0 : y0 + height;
+		const px = transform[transformOffset] * x + transform[transformOffset + 2] * y + transform[transformOffset + 4];
+		const py = transform[transformOffset + 1] * x + transform[transformOffset + 3] * y + transform[transformOffset + 5];
+		minX = Math.min(minX, px);
+		minY = Math.min(minY, py);
+		maxX = Math.max(maxX, px);
+		maxY = Math.max(maxY, py);
+	}
+	out.x = minX;
+	out.y = minY;
+	out.width = Math.max(0, maxX - minX);
+	out.height = Math.max(0, maxY - minY);
+	return out;
+}
+function hasFiniteTransform(transform, transformOffset) {
+	for (let index = 0; index < 6; index += 1) if (!Number.isFinite(transform[transformOffset + index])) return false;
+	return true;
+}
+function isFiniteDamageRect(rect) {
+	return Number.isFinite(rect.x) && Number.isFinite(rect.y) && Number.isFinite(rect.width) && Number.isFinite(rect.height) && rect.width >= 0 && rect.height >= 0;
+}
+/**
+* Compute a conservative visual bound for one command. `null` means unknown,
+* which callers must treat as intersecting every damage region. Glyphs are
+* known only when their producer supplied explicit local ink bounds; guessing
+* from pen positions or em size could leave stale ink on a retained surface.
+*/
+function commandDamageBounds(list, index, out = createDamageRect()) {
+	const kind = list.kindAt(index);
+	if (kind === 7 || kind === 8) return null;
+	if (kind === 0 || kind === 1) {
+		const at = list.floatOffsetAt(index);
+		const floats = list.floats;
+		const w = floats[at + 6];
+		const h = floats[at + 7];
+		if (!hasFiniteTransform(floats, at) || !Number.isFinite(w) || !Number.isFinite(h) || w < 0 || h < 0) return null;
+		transformDamageValues(0, 0, w, h, floats, out, at);
+		return isFiniteDamageRect(out) ? out : null;
+	}
+	if (kind === 2) {
+		const at = list.floatOffsetAt(index);
+		const ints = list.ints;
+		const floats = list.floats;
+		const count = ints[list.intOffsetAt(index)];
+		if (count <= 0) {
+			out.x = 0;
+			out.y = 0;
+			out.width = 0;
+			out.height = 0;
+			return out;
+		}
+		const width = floats[at];
+		if (!Number.isFinite(width)) return null;
+		const half = Math.abs(width) / 2;
+		let minX = Number.POSITIVE_INFINITY;
+		let minY = Number.POSITIVE_INFINITY;
+		let maxX = Number.NEGATIVE_INFINITY;
+		let maxY = Number.NEGATIVE_INFINITY;
+		for (let point = 0; point < count; point += 1) {
+			const x = floats[at + 5 + point * 2];
+			const y = floats[at + 6 + point * 2];
+			if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+			minX = Math.min(minX, x - half);
+			minY = Math.min(minY, y - half);
+			maxX = Math.max(maxX, x + half);
+			maxY = Math.max(maxY, y + half);
+		}
+		out.x = minX;
+		out.y = minY;
+		out.width = maxX - minX;
+		out.height = maxY - minY;
+		return isFiniteDamageRect(out) ? out : null;
+	}
+	if (kind === 6) {
+		const at = list.floatOffsetAt(index);
+		const intAt = list.intOffsetAt(index);
+		const floats = list.floats;
+		const vertexCount = list.ints[intAt];
+		if (vertexCount <= 0) {
+			out.x = 0;
+			out.y = 0;
+			out.width = 0;
+			out.height = 0;
+			return out;
+		}
+		const xx = floats[at];
+		const xy = floats[at + 1];
+		const yx = floats[at + 2];
+		const yy = floats[at + 3];
+		const ox = floats[at + 4];
+		const oy = floats[at + 5];
+		const positionsAt = at + 10;
+		if (!hasFiniteTransform(floats, at)) return null;
+		let minX = Number.POSITIVE_INFINITY;
+		let minY = Number.POSITIVE_INFINITY;
+		let maxX = Number.NEGATIVE_INFINITY;
+		let maxY = Number.NEGATIVE_INFINITY;
+		for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+			const x = floats[positionsAt + vertex * 2];
+			const y = floats[positionsAt + vertex * 2 + 1];
+			if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+			const transformedX = xx * x + yx * y + ox;
+			const transformedY = xy * x + yy * y + oy;
+			minX = Math.min(minX, transformedX);
+			minY = Math.min(minY, transformedY);
+			maxX = Math.max(maxX, transformedX);
+			maxY = Math.max(maxY, transformedY);
+		}
+		out.x = minX;
+		out.y = minY;
+		out.width = Math.max(0, maxX - minX);
+		out.height = Math.max(0, maxY - minY);
+		return isFiniteDamageRect(out) ? out : null;
+	}
+	if (kind === 5) {
+		const at = list.floatOffsetAt(index);
+		const floats = list.floats;
+		const x = floats[at + 12];
+		const y = floats[at + 13];
+		const width = floats[at + 14];
+		const height = floats[at + 15];
+		const effectOutset = floats[at + 16];
+		if (!hasFiniteTransform(floats, at) || !Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(width) || !Number.isFinite(height) || !Number.isFinite(effectOutset) || width < 0 || height < 0 || effectOutset < 0) return null;
+		const spread = Math.abs(floats[at + 11]);
+		const outset = effectOutset + (Number.isFinite(spread) ? spread : 0);
+		transformDamageValues(x - outset, y - outset, width + outset * 2, height + outset * 2, floats, out, at);
+		return isFiniteDamageRect(out) ? out : null;
+	}
+	if (kind === 3 || kind === 4) {
+		out.x = 0;
+		out.y = 0;
+		out.width = 0;
+		out.height = 0;
+		return out;
+	}
+	return null;
+}
+function createDamageTiles(width, height, tileWidth = 64, tileHeight = tileWidth) {
+	const tileW = Number.isFinite(tileWidth) ? Math.max(1, Math.floor(tileWidth)) : 64;
+	const tileH = Number.isFinite(tileHeight) ? Math.max(1, Math.floor(tileHeight)) : tileW;
+	let surfaceWidth = 0;
+	let surfaceHeight = 0;
+	let columns = 0;
+	let rows = 0;
+	let marked = new Uint8Array(0);
+	let dirty = false;
+	let dirtyCount = 0;
+	let regionsStale = true;
+	let regionCount = 0;
+	const regionPool = [];
+	let previousEnds = new Int32Array(0);
+	let previousRegions = new Int32Array(0);
+	let currentEnds = new Int32Array(0);
+	let currentRegions = new Int32Array(0);
+	const iterationTile = {
+		column: 0,
+		row: 0,
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	};
+	function resize(nextWidth, nextHeight) {
+		surfaceWidth = Number.isFinite(nextWidth) ? Math.max(0, Math.round(nextWidth)) : 0;
+		surfaceHeight = Number.isFinite(nextHeight) ? Math.max(0, Math.round(nextHeight)) : 0;
+		columns = Math.ceil(surfaceWidth / tileW);
+		rows = Math.ceil(surfaceHeight / tileH);
+		marked = new Uint8Array(columns * rows);
+		dirty = false;
+		dirtyCount = 0;
+		regionsStale = true;
+		previousEnds = new Int32Array(columns);
+		previousRegions = new Int32Array(columns);
+		currentEnds = new Int32Array(columns);
+		currentRegions = new Int32Array(columns);
+	}
+	function mark(rect) {
+		if (surfaceWidth === 0 || surfaceHeight === 0) return;
+		if (!rect || !isFiniteDamageRect(rect)) {
+			marked.fill(1);
+			dirty = marked.length > 0;
+			dirtyCount = marked.length;
+			regionsStale = true;
+			return;
+		}
+		if (isDamageEmpty(rect)) return;
+		const left = Math.max(0, Math.floor(rect.x / tileW));
+		const top = Math.max(0, Math.floor(rect.y / tileH));
+		const right = Math.min(columns, Math.ceil((rect.x + rect.width) / tileW));
+		const bottom = Math.min(rows, Math.ceil((rect.y + rect.height) / tileH));
+		for (let row = top; row < bottom; row += 1) for (let column = left; column < right; column += 1) {
+			const index = row * columns + column;
+			if (marked[index] === 0) {
+				marked[index] = 1;
+				dirtyCount += 1;
+				dirty = true;
+				regionsStale = true;
+			}
+		}
+	}
+	function tiles() {
+		const result = [];
+		for (let row = 0; row < rows; row += 1) for (let column = 0; column < columns; column += 1) {
+			if (marked[row * columns + column] === 0) continue;
+			const x = column * tileW;
+			const y = row * tileH;
+			result.push({
+				column,
+				row,
+				x,
+				y,
+				width: Math.min(tileW, surfaceWidth - x),
+				height: Math.min(tileH, surfaceHeight - y)
+			});
+		}
+		return result;
+	}
+	function forEach(callback) {
+		for (let row = 0; row < rows; row += 1) for (let column = 0; column < columns; column += 1) {
+			if (marked[row * columns + column] === 0) continue;
+			const x = column * tileW;
+			const y = row * tileH;
+			iterationTile.column = column;
+			iterationTile.row = row;
+			iterationTile.x = x;
+			iterationTile.y = y;
+			iterationTile.width = Math.min(tileW, surfaceWidth - x);
+			iterationTile.height = Math.min(tileH, surfaceHeight - y);
+			callback(iterationTile);
+		}
+	}
+	/**
+	* Build a maximal exact rectangular cover from the tile bitset. A row is
+	* first reduced to horizontal runs; only a run with the same column span in
+	* the immediately preceding row extends its existing rectangle. That rule
+	* is what prevents a T/L-shaped set of tiles from filling its clean corner.
+	*/
+	function rebuildRegions() {
+		if (!regionsStale) return;
+		regionsStale = false;
+		regionCount = 0;
+		previousEnds.fill(-1);
+		previousRegions.fill(-1);
+		for (let row = 0; row < rows; row += 1) {
+			currentEnds.fill(-1);
+			currentRegions.fill(-1);
+			const y = row * tileH;
+			const height = Math.min(tileH, surfaceHeight - y);
+			for (let column = 0; column < columns;) {
+				if (marked[row * columns + column] === 0) {
+					column += 1;
+					continue;
+				}
+				const start = column;
+				column += 1;
+				while (column < columns && marked[row * columns + column] !== 0) column += 1;
+				const end = column;
+				let regionIndex = -1;
+				if (previousEnds[start] === end) regionIndex = previousRegions[start];
+				if (regionIndex >= 0) regionPool[regionIndex].height += height;
+				else {
+					regionIndex = regionCount;
+					regionCount += 1;
+					const region = regionPool[regionIndex] ?? createDamageRect();
+					region.x = start * tileW;
+					region.y = y;
+					region.width = Math.min(surfaceWidth, end * tileW) - region.x;
+					region.height = height;
+					regionPool[regionIndex] = region;
+				}
+				currentEnds[start] = end;
+				currentRegions[start] = regionIndex;
+			}
+			[previousEnds, currentEnds] = [currentEnds, previousEnds];
+			[previousRegions, currentRegions] = [currentRegions, previousRegions];
+		}
+	}
+	function forEachRegion(callback) {
+		rebuildRegions();
+		for (let index = 0; index < regionCount; index += 1) callback(regionPool[index]);
+	}
+	resize(width, height);
+	return {
+		get width() {
+			return surfaceWidth;
+		},
+		get height() {
+			return surfaceHeight;
+		},
+		get tileWidth() {
+			return tileW;
+		},
+		get tileHeight() {
+			return tileH;
+		},
+		get columns() {
+			return columns;
+		},
+		get rows() {
+			return rows;
+		},
+		get tileCount() {
+			return marked.length;
+		},
+		get dirtyCount() {
+			return dirtyCount;
+		},
+		get coverage() {
+			return marked.length === 0 ? 0 : dirtyCount / marked.length;
+		},
+		get dirty() {
+			return dirty;
+		},
+		resize,
+		mark,
+		clear() {
+			marked.fill(0);
+			dirty = false;
+			dirtyCount = 0;
+			regionsStale = true;
+		},
+		tiles,
+		forEach,
+		forEachRegion,
+		consume() {
+			const result = tiles();
+			marked.fill(0);
+			dirty = false;
+			dirtyCount = 0;
+			regionsStale = true;
+			return result;
+		}
+	};
+}
+//#endregion
+//#region src/replay.ts
+/** Retained replay must stay below this fraction of the complete painter list. */
+const RETAINED_MAX_REPLAY_FRACTION = .4;
+/**
+* Largest command count that is strictly below the retained replay threshold.
+* Clip pushes/pops are commands too: omitting them would not restore the
+* original painter state, so they count against the same budget.
+*/
+function maxPartialReplayCommands(commandCount) {
+	if (!Number.isFinite(commandCount) || commandCount <= 0) return 0;
+	return Math.max(0, Math.ceil(commandCount * RETAINED_MAX_REPLAY_FRACTION) - 1);
+}
+const REPLAY_MASK_SCRATCH = Symbol("ReplayMaskScratch");
+const replayMaskFrames = /* @__PURE__ */ new WeakMap();
+/** True only for masks created by this module and safe for a partial FBO replay. */
+function isPartialReplayMask(mask, list) {
+	const frame = replayMaskFrames.get(mask);
+	return mask[REPLAY_MASK_SCRATCH] === true && mask.selected && !mask.requiresFullReplay && (list === void 0 || frame?.list === list && frame.structuralRevision === list.structuralRevision && frame.contentRevision === list.contentRevision);
+}
+function isFiniteBounds(bounds) {
+	return Number.isFinite(bounds.x) && Number.isFinite(bounds.y) && Number.isFinite(bounds.width) && Number.isFinite(bounds.height) && bounds.width >= 0 && bounds.height >= 0;
+}
+/** Intersect `bounds` after applying final-coordinate reach without mutating a
+* provider-owned cached rectangle. */
+function boundsIntersectsDamage(bounds, damage, outset) {
+	const x = bounds.x - outset;
+	const y = bounds.y - outset;
+	const width = bounds.width + outset * 2;
+	const height = bounds.height + outset * 2;
+	return width > 0 && height > 0 && damage.width > 0 && damage.height > 0 && x < damage.x + damage.width && x + width > damage.x && y < damage.y + damage.height && y + height > damage.y;
+}
+function createReplayMaskScratch(capacity = 0) {
+	let selected = new Uint8Array(Math.max(1, capacity));
+	let open = new Int32Array(Math.max(1, capacity));
+	let openCount = 0;
+	const output = [];
+	const bounds = {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	};
+	const transformed = {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	};
+	let requiresFullReplay = false;
+	let thresholdExceeded = false;
+	let selectedForFrame = false;
+	let selectionLimit;
+	function ensure(count) {
+		if (selected.length >= count) return;
+		let size = selected.length;
+		while (size < count) size *= 2;
+		selected = new Uint8Array(size);
+		open = new Int32Array(size);
+	}
+	function selectIndex(index, count) {
+		if (selected[index] !== 0) return true;
+		selected[index] = 1;
+		output.push(index);
+		if (selectionLimit !== void 0 && output.length > selectionLimit) {
+			thresholdExceeded = true;
+			requiresFullReplay = true;
+			output.length = 0;
+			selected.fill(0, 0, count);
+			return false;
+		}
+		return true;
+	}
+	function finish(list) {
+		selectedForFrame = true;
+		replayMaskFrames.set(scratch, {
+			list,
+			structuralRevision: list.structuralRevision,
+			contentRevision: list.contentRevision
+		});
+		return scratch;
+	}
+	const scratch = {
+		get count() {
+			return output.length;
+		},
+		get requiresFullReplay() {
+			return requiresFullReplay;
+		},
+		get thresholdExceeded() {
+			return thresholdExceeded;
+		},
+		get selected() {
+			return selectedForFrame;
+		},
+		[REPLAY_MASK_SCRATCH]: true,
+		includes(index) {
+			return index >= 0 && index < selected.length && selected[index] !== 0;
+		},
+		indices() {
+			return output;
+		},
+		select(list, damage, options) {
+			ensure(list.count);
+			selected.fill(0, 0, list.count);
+			output.length = 0;
+			openCount = 0;
+			requiresFullReplay = false;
+			thresholdExceeded = false;
+			selectedForFrame = false;
+			selectionLimit = options?.maxCommands;
+			if (selectionLimit !== void 0 && (!Number.isFinite(selectionLimit) || selectionLimit < 0)) {
+				requiresFullReplay = true;
+				return finish(list);
+			}
+			if (selectionLimit !== void 0) selectionLimit = Math.floor(selectionLimit);
+			const rasterOutset = options?.rasterOutset ?? 1;
+			if (!Number.isFinite(rasterOutset) || rasterOutset < 0) {
+				requiresFullReplay = true;
+				return finish(list);
+			}
+			selection: for (let index = 0; index < list.count; index += 1) {
+				const kind = list.kindAt(index);
+				if (kind === 7 || kind === 8) {
+					requiresFullReplay = true;
+					output.length = 0;
+					selected.fill(0, 0, list.count);
+					break;
+				}
+				if (kind === 3) {
+					open[openCount] = index;
+					openCount += 1;
+					continue;
+				}
+				if (kind === 4) {
+					if (openCount === 0) {
+						requiresFullReplay = true;
+						output.length = 0;
+						selected.fill(0, 0, list.count);
+						break;
+					}
+					openCount -= 1;
+					const push = open[openCount];
+					if (selected[push] !== 0 && !selectIndex(index, list.count)) break;
+					continue;
+				}
+				const commandBounds = options?.boundsAt ? options.boundsAt(index, bounds) : commandDamageBounds(list, index, bounds);
+				const mapped = commandBounds && options?.transform ? transformDamageRect(commandBounds, options.transform, transformed) : commandBounds;
+				if (mapped === null && options?.unknownBounds !== "select") {
+					requiresFullReplay = true;
+					output.length = 0;
+					selected.fill(0, 0, list.count);
+					break;
+				}
+				if (mapped !== null && !isFiniteBounds(mapped)) {
+					requiresFullReplay = true;
+					output.length = 0;
+					selected.fill(0, 0, list.count);
+					break;
+				}
+				if (mapped !== null && !boundsIntersectsDamage(mapped, damage, rasterOutset)) continue;
+				for (let depth = 0; depth < openCount; depth += 1) if (!selectIndex(open[depth], list.count)) break selection;
+				if (!selectIndex(index, list.count)) break;
+			}
+			if (openCount !== 0 && !requiresFullReplay) {
+				requiresFullReplay = true;
+				output.length = 0;
+				selected.fill(0, 0, list.count);
+			}
+			return finish(list);
+		}
+	};
+	return scratch;
+}
+/**
+* Select just the commands that can change `damage`, preserving all clip pushes
+* and pops needed to replay them from an empty clip stack. Unknown bounds are
+* selected conservatively. This is deliberately a mask rather than a copied
+* command list: all reads stay in the original retained arenas.
+*/
+function createReplayMask(list, damage, options) {
+	return createReplayMaskScratch(list.count).select(list, damage, options);
+}
+//#endregion
+//#region src/compiled-draw-list.ts
+const TEMPLATE_FLOATS = 16;
+const NO_TEMPLATE = -1;
+function compileDrawList(list) {
+	let seenStructural = -1;
+	let seenContent = -1;
+	let templateOffsets = new Int32Array(0);
+	let templates = new Float32Array(0);
+	let bounds = new Float32Array(0);
+	let knownBounds = new Uint8Array(0);
+	let batchDescriptors = [];
+	let invalidated = false;
+	let planGeneration = 0;
+	let deltaBaseRevision = 0;
+	const patchView = createDrawListPatchView();
+	const diagnostics = {
+		planBuilds: 0,
+		structuralInvalidations: 0,
+		planReuses: 0,
+		templateRangeUpdates: 0,
+		reusedSelections: 0,
+		reusedBatches: 0
+	};
+	const selectionOptions = { boundsAt(index, out) {
+		return plan.commandBounds(index, out);
+	} };
+	const boundsScratch = createDamageRect();
+	const changedCommands = [];
+	const refreshResult = {
+		rebuilt: false,
+		rangeUpdates: 0,
+		changedCommands,
+		planGeneration: 0,
+		contentRevision: 0,
+		deltaBaseRevision: 0
+	};
+	function updateBounds(index) {
+		const value = commandDamageBounds(list, index, boundsScratch);
+		const at = index * 4;
+		if (!value) {
+			knownBounds[index] = 0;
+			return;
+		}
+		knownBounds[index] = 1;
+		bounds[at] = value.x;
+		bounds[at + 1] = value.y;
+		bounds[at + 2] = value.width;
+		bounds[at + 3] = value.height;
+	}
+	function updateQuadTemplate(index) {
+		const target = templateOffsets[index];
+		if (target === NO_TEMPLATE) return;
+		const source = list.floatOffsetAt(index);
+		const floats = list.floats;
+		const m0 = floats[source];
+		const m1 = floats[source + 1];
+		const m2 = floats[source + 2];
+		const m3 = floats[source + 3];
+		const m4 = floats[source + 4];
+		const m5 = floats[source + 5];
+		const w = floats[source + 6];
+		const h = floats[source + 7];
+		templates[target] = m4;
+		templates[target + 1] = m5;
+		templates[target + 2] = m0 * w + m4;
+		templates[target + 3] = m1 * w + m5;
+		templates[target + 4] = m0 * w + m2 * h + m4;
+		templates[target + 5] = m1 * w + m3 * h + m5;
+		templates[target + 6] = m2 * h + m4;
+		templates[target + 7] = m3 * h + m5;
+		templates[target + 8] = floats[source + 8];
+		templates[target + 9] = floats[source + 9];
+		templates[target + 10] = floats[source + 10];
+		templates[target + 11] = floats[source + 11];
+		templates[target + 12] = floats[source + 12];
+		templates[target + 13] = floats[source + 13];
+		templates[target + 14] = floats[source + 14];
+		templates[target + 15] = floats[source + 15];
+	}
+	function rebuild() {
+		const count = list.count;
+		templateOffsets = new Int32Array(count);
+		templateOffsets.fill(NO_TEMPLATE);
+		templates = new Float32Array(count * TEMPLATE_FLOATS);
+		bounds = new Float32Array(count * 4);
+		knownBounds = new Uint8Array(count);
+		batchDescriptors = [];
+		let templateCount = 0;
+		let clipDepth = 0;
+		let runStart = -1;
+		let runBlend = 0;
+		let runClipDepth = 0;
+		const closeRun = (end) => {
+			if (runStart < 0) return;
+			batchDescriptors.push({
+				start: runStart,
+				end,
+				blend: runBlend,
+				clipDepth: runClipDepth
+			});
+			runStart = -1;
+		};
+		for (let index = 0; index < count; index += 1) {
+			const kind = list.kindAt(index);
+			updateBounds(index);
+			if (kind === 0) {
+				const blend = list.ints[list.intOffsetAt(index)];
+				if (runStart < 0 || runBlend !== blend || runClipDepth !== clipDepth) {
+					closeRun(index);
+					runStart = index;
+					runBlend = blend;
+					runClipDepth = clipDepth;
+				}
+				templateOffsets[index] = templateCount * TEMPLATE_FLOATS;
+				templateCount += 1;
+				updateQuadTemplate(index);
+			} else {
+				closeRun(index);
+				if (kind === 3) clipDepth += 1;
+				else if (kind === 4) clipDepth = Math.max(0, clipDepth - 1);
+			}
+		}
+		closeRun(count);
+		templates = templates.subarray(0, templateCount * TEMPLATE_FLOATS);
+		seenStructural = list.structuralRevision;
+		seenContent = list.contentRevision;
+		deltaBaseRevision = seenContent;
+		planGeneration += 1;
+		invalidated = false;
+		diagnostics.planBuilds += 1;
+	}
+	const plan = {
+		list,
+		get batches() {
+			return batchDescriptors;
+		},
+		diagnostics,
+		refresh() {
+			if (invalidated || seenStructural !== list.structuralRevision) {
+				rebuild();
+				changedCommands.length = 0;
+				refreshResult.rebuilt = true;
+				refreshResult.rangeUpdates = 0;
+				refreshResult.planGeneration = planGeneration;
+				refreshResult.contentRevision = seenContent;
+				refreshResult.deltaBaseRevision = deltaBaseRevision;
+				return refreshResult;
+			}
+			if (seenContent === list.contentRevision) {
+				diagnostics.planReuses += 1;
+				diagnostics.reusedBatches += batchDescriptors.length;
+				refreshResult.rebuilt = false;
+				refreshResult.rangeUpdates = 0;
+				refreshResult.planGeneration = planGeneration;
+				refreshResult.contentRevision = seenContent;
+				refreshResult.deltaBaseRevision = deltaBaseRevision;
+				return refreshResult;
+			}
+			const patches = list.readPatchesSince(seenContent, patchView);
+			if (patches.overflowed) {
+				rebuild();
+				changedCommands.length = 0;
+				refreshResult.rebuilt = true;
+				refreshResult.rangeUpdates = 0;
+				refreshResult.planGeneration = planGeneration;
+				refreshResult.contentRevision = seenContent;
+				refreshResult.deltaBaseRevision = deltaBaseRevision;
+				return refreshResult;
+			}
+			let updates = 0;
+			changedCommands.length = 0;
+			for (let patch = 0; patch < patches.indices.length; patch += 1) {
+				const index = patches.indices[patch];
+				updateBounds(index);
+				updateQuadTemplate(index);
+				updates += 1;
+				changedCommands.push(index);
+			}
+			deltaBaseRevision = seenContent;
+			seenContent = list.contentRevision;
+			diagnostics.planReuses += 1;
+			diagnostics.reusedBatches += batchDescriptors.length;
+			diagnostics.templateRangeUpdates += updates;
+			refreshResult.rebuilt = false;
+			refreshResult.rangeUpdates = updates;
+			refreshResult.planGeneration = planGeneration;
+			refreshResult.contentRevision = seenContent;
+			refreshResult.deltaBaseRevision = deltaBaseRevision;
+			return refreshResult;
+		},
+		invalidate() {
+			invalidated = true;
+			diagnostics.structuralInvalidations += 1;
+		},
+		fillQuad(index, textureWidth, textureHeight, out) {
+			const at = templateOffsets[index];
+			if (at === NO_TEMPLATE) return false;
+			out.x0 = templates[at];
+			out.y0 = templates[at + 1];
+			out.x1 = templates[at + 2];
+			out.y1 = templates[at + 3];
+			out.x2 = templates[at + 4];
+			out.y2 = templates[at + 5];
+			out.x3 = templates[at + 6];
+			out.y3 = templates[at + 7];
+			const invWidth = 1 / Math.max(1, textureWidth);
+			const invHeight = 1 / Math.max(1, textureHeight);
+			out.u0 = templates[at + 8] * invWidth;
+			out.v0 = templates[at + 9] * invHeight;
+			out.uSpan = templates[at + 10] * invWidth;
+			out.vSpan = templates[at + 11] * invHeight;
+			out.r = templates[at + 12];
+			out.g = templates[at + 13];
+			out.b = templates[at + 14];
+			out.a = templates[at + 15];
+			const flags = list.ints[list.intOffsetAt(index) + 1];
+			if ((flags & 1) !== 0) {
+				out.u0 += out.uSpan;
+				out.uSpan = -out.uSpan;
+			}
+			if ((flags & 2) !== 0) {
+				out.v0 += out.vSpan;
+				out.vSpan = -out.vSpan;
+			}
+			return true;
+		},
+		commandBounds(index, out) {
+			if (index < 0 || index >= list.count || knownBounds[index] === 0) return null;
+			const at = index * 4;
+			out.x = bounds[at];
+			out.y = bounds[at + 1];
+			out.width = bounds[at + 2];
+			out.height = bounds[at + 3];
+			return out;
+		},
+		select(damage, scratch, options) {
+			plan.refresh();
+			diagnostics.reusedSelections += 1;
+			selectionOptions.transform = options?.transform;
+			selectionOptions.rasterOutset = options?.rasterOutset;
+			selectionOptions.maxCommands = options?.maxCommands;
+			selectionOptions.unknownBounds = options?.unknownBounds;
+			return scratch.select(list, damage, selectionOptions);
+		}
+	};
+	rebuild();
+	return plan;
+}
+/** Convenience for consumers with no existing scratch. Retained loops should
+* create one scratch once and call `plan.select` instead. */
+function createCompiledReplayMask(plan, damage, options) {
+	return plan.select(damage, createReplayMaskScratch(plan.list.count), options);
+}
+//#endregion
+//#region src/nine-patch.ts
+function createNinePatchBand() {
+	return {
+		dstX: 0,
+		dstY: 0,
+		dstW: 0,
+		dstH: 0,
+		srcX: 0,
+		srcY: 0,
+		srcW: 0,
+		srcH: 0
+	};
+}
+/** A reusable output buffer: nine bands is the hard maximum, so it never grows. */
+function createNinePatchBands() {
+	return Array.from({ length: 9 }, createNinePatchBand);
+}
+function createAxisBands() {
+	return {
+		dst: [
+			[0, 0],
+			[0, 0],
+			[0, 0]
+		],
+		src: [
+			[0, 0],
+			[0, 0],
+			[0, 0]
+		]
+	};
+}
+const H_BANDS = createAxisBands();
+const V_BANDS = createAxisBands();
+/**
+* Split ONE axis into its leading / centre / trailing spans, in the shader's
+* branch order. `size` is the destination extent, `texSize` the source extent,
+* `begin`/`end` the two margins. Writes into `out` and returns the number of
+* non-empty spans.
+*/
+function splitAxis(size, texSize, begin, end, out) {
+	const marginBegin = Math.max(0, begin);
+	const marginEnd = Math.max(0, end);
+	const leadEnd = Math.min(marginBegin, Math.max(0, size));
+	const trailStart = Math.max(leadEnd, size - marginEnd);
+	let count = 0;
+	if (leadEnd > 0) {
+		out.dst[count][0] = 0;
+		out.dst[count][1] = leadEnd;
+		out.src[count][0] = 0;
+		out.src[count][1] = Math.min(leadEnd, texSize);
+		count += 1;
+	}
+	const centreSrcBegin = marginBegin;
+	const centreSrcEnd = texSize - marginEnd;
+	if (trailStart > leadEnd && centreSrcEnd > centreSrcBegin) {
+		out.dst[count][0] = leadEnd;
+		out.dst[count][1] = trailStart;
+		out.src[count][0] = centreSrcBegin;
+		out.src[count][1] = centreSrcEnd;
+		count += 1;
+	}
+	if (size > trailStart) {
+		const span = size - trailStart;
+		out.dst[count][0] = trailStart;
+		out.dst[count][1] = size;
+		out.src[count][0] = Math.max(0, texSize - span);
+		out.src[count][1] = texSize;
+		count += 1;
+	}
+	return count;
+}
+/**
+* Expand a nine-patch into its bands, filling `out` (use
+* {@link createNinePatchBands}, which is always big enough) and returning how
+* many are live. `out` entries past the return value are stale and must not be
+* read.
+*
+* Returns 0 for a patch with no area — a zero-size destination or a zero-size
+* region draws nothing at all, which is not the same as drawing one empty band.
+*/
+function expandNinePatch(patch, out) {
+	const { w, h, srcW, srcH } = patch;
+	if (!(w > 0) || !(h > 0) || !(srcW > 0) || !(srcH > 0)) return 0;
+	const columns = splitAxis(w, srcW, patch.marginLeft, patch.marginRight, H_BANDS);
+	const rows = splitAxis(h, srcH, patch.marginTop, patch.marginBottom, V_BANDS);
+	let count = 0;
+	for (let row = 0; row < rows; row += 1) {
+		const [dstTop, dstBottom] = V_BANDS.dst[row];
+		const [srcTop, srcBottom] = V_BANDS.src[row];
+		for (let column = 0; column < columns; column += 1) {
+			const [dstLeft, dstRight] = H_BANDS.dst[column];
+			const [srcLeft, srcRight] = H_BANDS.src[column];
+			const band = out[count];
+			band.dstX = dstLeft;
+			band.dstY = dstTop;
+			band.dstW = dstRight - dstLeft;
+			band.dstH = dstBottom - dstTop;
+			band.srcX = patch.srcX + srcLeft;
+			band.srcY = patch.srcY + srcTop;
+			band.srcW = srcRight - srcLeft;
+			band.srcH = srcBottom - srcTop;
+			count += 1;
+		}
+	}
+	return count;
+}
+//#endregion
+//#region src/polyline.ts
+/**
+* Constant-width polyline -> quads, so a `DRAW_POLYLINE` goes through the SAME
+* instance buffer, the same shader and the same batch as everything else instead
+* of forcing a second program and a mid-frame draw break.
+*
+* That is possible because the batcher's instance carries four EXPLICIT corners
+* rather than an affine basis (see `./batcher`): a quad instance is any
+* quadrilateral, and a quadrilateral with its last two corners coincident is a
+* triangle. So a stroke is emitted as
+*
+* - one parallelogram per segment (the segment offset by ±width/2 along its
+*   normal), and
+* - one triangle per interior vertex, filling the notch on the OUTSIDE of the
+*   turn.
+*
+* JOINS ARE BEVEL, CAPS ARE BUTT — the first pass the wave-1 brief allows, and a
+* deliberate choice rather than an oversight:
+*
+* - a MITER join needs the two segment edges extended to their intersection,
+*   which runs away to infinity as the turn approaches a reversal and therefore
+*   needs a miter limit that itself falls back to... a bevel. Two code paths for
+*   a shape that differs from the bevel only inside a `width/2` disc.
+* - a ROUND join needs an arc, i.e. a fan of triangles whose count depends on the
+*   turn angle and the on-screen width — the one thing in this file that would
+*   make its output size unpredictable.
+*
+* The bevel differs from both only within half a stroke width of a vertex, and
+* the measured population of polylines in the recorded scenes this executor was
+* sized against is ZERO (the paint-source mix is texture/text/particles/spine/
+* solid). Upgrading to round joins is local to this file: emit a fan instead of
+* the single wedge triangle in the interior-vertex loop.
+*
+* Self-overlap: at a sharp turn the two segment parallelograms overlap near the
+* vertex, so a translucent stroke double-composites there. Godot's own
+* `draw_polyline` has the same artefact; fixing it needs a stencil or a
+* single-pass SDF, neither of which belongs in wave 1.
+*/
+/** Floats per emitted quad: four `(x, y)` corners in draw-list local space. */
+const POLYLINE_QUAD_FLOATS = 8;
+/**
+* The most quads a `pointCount`-point stroke can produce: one per segment plus
+* one per interior vertex. Sizes a caller's output buffer exactly.
+*/
+function polylineQuadCapacity(pointCount) {
+	if (pointCount < 2) return 0;
+	return pointCount - 1 + Math.max(0, pointCount - 2);
+}
+/**
+* Tessellate `points` (flattened `x, y, x, y, …`, the draw-list's own layout)
+* into quads, writing `POLYLINE_QUAD_FLOATS` floats per quad into `out` from
+* `outOffset`. Returns the number of quads written.
+*
+* Corners are written in the batcher's unit-square order — `(0,0)`, `(1,0)`,
+* `(1,1)`, `(0,1)` — so a triangle is spelled by repeating the last corner.
+*
+* Zero-length segments are skipped (they have no direction to offset along, and
+* a duplicated point is a common artefact of a resampled path); a vertex whose
+* incoming or outgoing segment was skipped gets no join wedge, because there is
+* no notch to fill.
+*/
+function expandPolyline(points, pointCount, width, out, outOffset = 0) {
+	const half = width / 2;
+	if (pointCount < 2 || !(half > 0)) return 0;
+	let at = outOffset;
+	let quads = 0;
+	let previousNormalX = 0;
+	let previousNormalY = 0;
+	let hasPrevious = false;
+	let previousDirX = 0;
+	let previousDirY = 0;
+	for (let i = 0; i + 1 < pointCount; i += 1) {
+		const ax = points[i * 2];
+		const ay = points[i * 2 + 1];
+		const bx = points[i * 2 + 2];
+		const by = points[i * 2 + 3];
+		const dx = bx - ax;
+		const dy = by - ay;
+		const length = Math.hypot(dx, dy);
+		if (!(length > 0)) {
+			hasPrevious = false;
+			continue;
+		}
+		const dirX = dx / length;
+		const dirY = dy / length;
+		const normalX = -dirY * half;
+		const normalY = dirX * half;
+		if (hasPrevious) {
+			const cross = previousDirX * dirY - previousDirY * dirX;
+			if (cross !== 0) {
+				const side = cross > 0 ? -1 : 1;
+				out[at] = ax;
+				out[at + 1] = ay;
+				out[at + 2] = ax + previousNormalX * side;
+				out[at + 3] = ay + previousNormalY * side;
+				out[at + 4] = ax + normalX * side;
+				out[at + 5] = ay + normalY * side;
+				out[at + 6] = ax + normalX * side;
+				out[at + 7] = ay + normalY * side;
+				at += 8;
+				quads += 1;
+			}
+		}
+		out[at] = ax + normalX;
+		out[at + 1] = ay + normalY;
+		out[at + 2] = bx + normalX;
+		out[at + 3] = by + normalY;
+		out[at + 4] = bx - normalX;
+		out[at + 5] = by - normalY;
+		out[at + 6] = ax - normalX;
+		out[at + 7] = ay - normalY;
+		at += 8;
+		quads += 1;
+		previousNormalX = normalX;
+		previousNormalY = normalY;
+		previousDirX = dirX;
+		previousDirY = dirY;
+		hasPrevious = true;
+	}
+	return quads;
+}
+//#endregion
+//#region src/executor-webgl.ts
+const BLEND_STATES = {
+	[0]: {
+		equationRgb: "FUNC_ADD",
+		equationAlpha: "FUNC_ADD",
+		srcRgb: "ONE",
+		dstRgb: "ONE_MINUS_SRC_ALPHA",
+		srcAlpha: "ONE",
+		dstAlpha: "ONE_MINUS_SRC_ALPHA"
+	},
+	[1]: {
+		equationRgb: "FUNC_ADD",
+		equationAlpha: "FUNC_ADD",
+		srcRgb: "ONE",
+		dstRgb: "ONE",
+		srcAlpha: "ONE",
+		dstAlpha: "ONE"
+	},
+	[2]: {
+		equationRgb: "FUNC_REVERSE_SUBTRACT",
+		equationAlpha: "FUNC_ADD",
+		srcRgb: "ONE",
+		dstRgb: "ONE",
+		srcAlpha: "ONE",
+		dstAlpha: "ONE"
+	},
+	[3]: {
+		equationRgb: "FUNC_ADD",
+		equationAlpha: "FUNC_ADD",
+		srcRgb: "DST_COLOR",
+		dstRgb: "ZERO",
+		srcAlpha: "DST_ALPHA",
+		dstAlpha: "ZERO"
+	}
+};
+/** The GL blend state a Godot `CanvasItemMaterial.BlendMode` maps to. */
+function blendStateFor(blend) {
+	return BLEND_STATES[blend] ?? BLEND_STATES[0];
+}
+const VERTEX_SRC = `#version 300 es
+layout(location = 0) in vec2 a_corner;   // unit-square corner, see INSTANCE_CORNERS_OFFSET
+layout(location = 1) in vec4 a_p01;      // p0 (0,0), p1 (1,0)
+layout(location = 2) in vec4 a_p23;      // p2 (1,1), p3 (0,1)
+layout(location = 3) in vec4 a_uv;       // u0, v0, uSpan, vSpan
+layout(location = 4) in vec4 a_color;    // PREMULTIPLIED tint
+layout(location = 5) in vec2 a_slots;    // texture slot, colour-matrix slot
+uniform vec4 u_projection;               // design -> clip: scale.xy, translate.xy
+out vec2 v_uv;
+out vec4 v_color;
+out vec2 v_design;
+flat out int v_texture;
+flat out int v_matrix;
+void main() {
+  // BILINEAR across four explicit corners rather than an affine basis: see the
+  // note in ./batcher. For the affine case (every sprite) this is exactly the
+  // affine map; for a stroke segment it is the quadrilateral itself.
+  vec2 top = mix(a_p01.xy, a_p01.zw, a_corner.x);
+  vec2 bottom = mix(a_p23.zw, a_p23.xy, a_corner.x);
+  vec2 design = mix(top, bottom, a_corner.y);
+  gl_Position = vec4(design * u_projection.xy + u_projection.zw, 0.0, 1.0);
+  v_uv = a_uv.xy + a_uv.zw * a_corner;
+  v_color = a_color;
+  v_design = design;
+  v_texture = int(a_slots.x);
+  v_matrix = int(a_slots.y);
+}`;
+const TEXTURED_MESH_VERTEX_SRC = `#version 300 es
+layout(location = 0) in vec2 a_position;
+layout(location = 1) in vec2 a_uv;
+uniform vec4 u_projection;
+out vec2 v_uv;
+void main() {
+  gl_Position = vec4(a_position * u_projection.xy + u_projection.zw, 0.0, 1.0);
+  v_uv = a_uv;
+}`;
+const TEXTURED_MESH_FRAGMENT_SRC = `#version 300 es
+precision highp float;
+uniform sampler2D u_texture;
+uniform vec4 u_tint;
+in vec2 v_uv;
+out vec4 fragColor;
+void main() {
+  // Both the uploaded texel and tint are premultiplied, so ordinary component
+  // multiplication remains premultiplied for the shared blend contract.
+  fragColor = texture(u_texture, v_uv) * u_tint;
+}`;
+/**
+* The fragment shader, generated for the slot counts THIS context supports.
+*
+* The `if` ladder is not laziness: GLSL ES 3.00 allows a sampler array to be
+* indexed only by a constant expression, so a dynamic slot has to be resolved by
+* comparison. (The colour-matrix array next to it is a plain uniform array, which
+* dynamic indexing IS allowed on.)
+*
+* `precision highp int` is load-bearing. The default integer precision is `highp`
+* in the vertex stage and `mediump` in the fragment stage, and a cross-stage
+* variable whose precision disagrees fails to LINK — silently, in the sense that
+* the only symptom is a program that does not exist and therefore a canvas that
+* draws nothing. `highp float` matters for a different reason: `mediump` carries
+* ~10 bits of mantissa, which cannot address a texel on a 4096-wide atlas page.
+*/
+function fragmentSource(textureSlots, colorMatrices) {
+	const ladder = [];
+	for (let i = 0; i < textureSlots; i += 1) ladder.push(`  ${i === 0 ? "if" : "} else if"} (slot == ${i}) {\n    return texture(u_textures[${i}], uv);`);
+	ladder.push("  }");
+	return `#version 300 es
+precision highp float;
+precision highp int;
+precision highp sampler2D;
+uniform sampler2D u_textures[${textureSlots}];
+uniform mat3 u_colorMatrices[${colorMatrices}];
+uniform vec4 u_roundedRect;    // centre.xy, half-extent.xy, DESIGN units
+uniform float u_roundedRadius; // <= 0 disables the rounded test entirely
+in vec2 v_uv;
+in vec4 v_color;
+in vec2 v_design;
+flat in int v_texture;
+flat in int v_matrix;
+out vec4 fragColor;
+
+vec4 sampleSlot(int slot, vec2 uv) {
+${ladder.join("\n")}
+  return vec4(0.0);
+}
+
+void main() {
+  if (u_roundedRadius > 0.0) {
+    // Standard rounded-rect distance: shrink the box by the radius, take the
+    // distance to that box, subtract the radius back.
+    vec2 d = abs(v_design - u_roundedRect.xy) - (u_roundedRect.zw - vec2(u_roundedRadius));
+    if (length(max(d, vec2(0.0))) - u_roundedRadius > 0.0) {
+      discard;
+    }
+  }
+  vec4 texel = sampleSlot(v_texture, v_uv);
+  if (v_matrix != 0) {
+    // The matrix is defined on the texture's OWN colour, so it has to see
+    // straight (un-premultiplied) sRGB — apply it to premultiplied channels and a
+    // half-transparent pixel is transformed as if it were half as bright. No
+    // linearization: the same sRGB-domain transform html's applyColorMatrixToPixels
+    // performs on the CPU, clamped for the same reason (it writes clamped bytes).
+    float alpha = texel.a;
+    vec3 straight = alpha > 0.0 ? texel.rgb / alpha : vec3(0.0);
+    straight = clamp(u_colorMatrices[v_matrix] * straight, 0.0, 1.0);
+    texel = vec4(straight * alpha, alpha);
+  }
+  // Two PREMULTIPLIED colours compose with a plain multiply, and the result is
+  // premultiplied — which is what the blend factors and the canvas expect.
+  fragColor = texel * v_color;
+}`;
+}
+function compileShader(gl, type, source) {
+	const shader = gl.createShader(type);
+	if (!shader) return null;
+	gl.shaderSource(shader, source);
+	gl.compileShader(shader);
+	return shader;
+}
+function linkProgram(gl, vertexSrc, fragmentSrc) {
+	const vs = compileShader(gl, gl.VERTEX_SHADER, vertexSrc);
+	const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSrc);
+	if (!vs || !fs) {
+		if (vs) gl.deleteShader(vs);
+		if (fs) gl.deleteShader(fs);
+		return null;
+	}
+	const program = gl.createProgram();
+	if (!program) {
+		gl.deleteShader(vs);
+		gl.deleteShader(fs);
+		return null;
+	}
+	gl.attachShader(program, vs);
+	gl.attachShader(program, fs);
+	gl.linkProgram(program);
+	const linked = gl.getProgramParameter(program, gl.LINK_STATUS);
+	if (!linked) {
+		let compileFailed = false;
+		for (const shader of [vs, fs]) {
+			if (gl.getShaderParameter(shader, gl.COMPILE_STATUS)) continue;
+			compileFailed = true;
+			console.warn("[gsw canvas] shader compile failed:", gl.getShaderInfoLog(shader));
+		}
+		if (!compileFailed) console.warn("[gsw canvas] program link failed:", gl.getProgramInfoLog(program));
+		gl.deleteProgram(program);
+	}
+	gl.deleteShader(vs);
+	gl.deleteShader(fs);
+	return linked ? program : null;
+}
+/** `[x, y]` per corner, in TRIANGLE_STRIP order: `(0,0) (1,0) (0,1) (1,1)`, whose
+*  two triangles are `p0 p1 p3` and `p1 p3 p2`. A quad with `p2 === p3` therefore
+*  degenerates to exactly the triangle `p0 p1 p3` — how `./polyline` spells a join
+*  wedge without a second draw path. */
+const CORNERS = new Float32Array([
+	0,
+	0,
+	1,
+	0,
+	0,
+	1,
+	1,
+	1
+]);
+const NO_CHANGED_COMMANDS = [];
+const INSTANCE_ATTRIBUTES = [
+	{
+		location: 1,
+		size: 4,
+		offset: 0
+	},
+	{
+		location: 2,
+		size: 4,
+		offset: 4
+	},
+	{
+		location: 3,
+		size: 4,
+		offset: 8
+	},
+	{
+		location: 4,
+		size: 4,
+		offset: 12
+	},
+	{
+		location: 5,
+		size: 2,
+		offset: 16
+	}
+];
+function createCanvasExecutor(options) {
+	const gl = options.gl;
+	const contextUnits = Number(gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS)) || 8;
+	const maxTextureSlots = Math.max(1, Math.min(16, contextUnits, Math.floor(options.maxTextureSlots ?? 16)));
+	const maxColorMatrices = Math.max(2, Math.floor(options.maxColorMatrices ?? 16));
+	let program = null;
+	let meshProgram = null;
+	let ownedWhite = null;
+	const suppliedWhite = options.white ?? null;
+	const glyphPass = options.glyphs ?? null;
+	const stats = {
+		commands: 0,
+		quads: 0,
+		batches: 0,
+		textureBinds: 0,
+		scissorChanges: 0,
+		blendChanges: 0,
+		ninePatches: 0,
+		ninePatchQuads: 0,
+		polylines: 0,
+		polylineQuads: 0,
+		texturedMeshes: 0,
+		texturedMeshTriangles: 0,
+		texturedMeshDrawCalls: 0,
+		glyphRuns: 0,
+		glyphs: 0,
+		glyphDrawCalls: 0,
+		glyphRunBatches: 0,
+		glyphRunBatchFallbacks: 0,
+		glyphRunsDropped: 0,
+		screenEffects: 0,
+		screenEffectFailures: 0,
+		externalEffects: 0,
+		externalEffectFailures: 0,
+		rotatedClipFallbacks: 0,
+		unbalancedClipPops: 0,
+		unknownCommands: 0,
+		maxBatchQuads: 0,
+		flushes: {
+			textureSlots: 0,
+			colorMatrices: 0,
+			blend: 0,
+			clip: 0,
+			glyphs: 0,
+			effects: 0,
+			meshes: 0,
+			compiled: 0,
+			end: 0
+		},
+		compiledPlanBuilds: 0,
+		compiledPlanReuses: 0,
+		compiledTemplateRangeUpdates: 0,
+		reusedSelections: 0,
+		reusedBatches: 0,
+		compiledGpuFullUploads: 0,
+		compiledGpuRangeUploads: 0,
+		compiledCachedDrawCalls: 0
+	};
+	const clipStack = createClipStack();
+	const scissor = createScissorBox();
+	const damageScissor = createScissorBox();
+	const appliedScissor = createScissorBox();
+	let appliedRoundedRadius = -1;
+	/** The rounded-clip rect last uploaded: centre.xy, half-extent.xy. */
+	const appliedRounded = new Float32Array(4);
+	let appliedBlend = null;
+	const quadView = createQuadView();
+	const patchView = createNinePatchView();
+	const lineView = createPolylineView(64);
+	const clipView = createClipRectView();
+	const glyphsView = createGlyphsView(64);
+	const glyphRunViewPool = [];
+	const glyphRunViews = [];
+	const texturedMeshView = createTexturedMeshView(64, 96);
+	const bands = createNinePatchBands();
+	let strokeQuads = new Float32Array(256 * 8);
+	let meshVertices = new Float32Array(256);
+	const batcher = createQuadBatcher({
+		maxTextureSlots,
+		maxColorMatrices,
+		quadCapacity: options.quadCapacity,
+		draw: drawBatch
+	});
+	const compiledGpuPlans = /* @__PURE__ */ new WeakMap();
+	const liveCompiledGpuPlans = /* @__PURE__ */ new Set();
+	const cachedQuad = createQuadInstance();
+	function whiteTexture() {
+		if (suppliedWhite) return suppliedWhite;
+		if (ownedWhite) return ownedWhite;
+		const texture = gl.createTexture();
+		gl.bindTexture(gl.TEXTURE_2D, texture);
+		gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+		gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+		gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+		gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array([
+			255,
+			255,
+			255,
+			255
+		]));
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+		ownedWhite = {
+			texture,
+			width: 1,
+			height: 1
+		};
+		return ownedWhite;
+	}
+	function ensureProgram() {
+		if (program) return program;
+		const linked = linkProgram(gl, VERTEX_SRC, fragmentSource(maxTextureSlots, maxColorMatrices));
+		if (!linked) return null;
+		const vao = gl.createVertexArray();
+		const cornerBuffer = gl.createBuffer();
+		const instanceBuffer = gl.createBuffer();
+		gl.bindVertexArray(vao);
+		gl.bindBuffer(gl.ARRAY_BUFFER, cornerBuffer);
+		gl.bufferData(gl.ARRAY_BUFFER, CORNERS, gl.STATIC_DRAW);
+		gl.enableVertexAttribArray(0);
+		gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+		gl.vertexAttribDivisor(0, 0);
+		gl.bindBuffer(gl.ARRAY_BUFFER, instanceBuffer);
+		const strideBytes = 72;
+		for (const attribute of INSTANCE_ATTRIBUTES) {
+			gl.enableVertexAttribArray(attribute.location);
+			gl.vertexAttribPointer(attribute.location, attribute.size, gl.FLOAT, false, strideBytes, attribute.offset * 4);
+			gl.vertexAttribDivisor(attribute.location, 1);
+		}
+		gl.bindVertexArray(null);
+		gl.useProgram(linked);
+		const units = new Int32Array(maxTextureSlots);
+		for (let i = 0; i < maxTextureSlots; i += 1) units[i] = i;
+		const uTextures = gl.getUniformLocation(linked, "u_textures[0]");
+		if (uTextures) gl.uniform1iv(uTextures, units);
+		program = {
+			program: linked,
+			vao,
+			cornerBuffer,
+			instanceBuffer,
+			instanceBytes: 0,
+			uProjection: gl.getUniformLocation(linked, "u_projection"),
+			uColorMatrices: gl.getUniformLocation(linked, "u_colorMatrices[0]"),
+			uRoundedRect: gl.getUniformLocation(linked, "u_roundedRect"),
+			uRoundedRadius: gl.getUniformLocation(linked, "u_roundedRadius")
+		};
+		return program;
+	}
+	function ensureMeshProgram() {
+		if (meshProgram) return meshProgram;
+		const linked = linkProgram(gl, TEXTURED_MESH_VERTEX_SRC, TEXTURED_MESH_FRAGMENT_SRC);
+		if (!linked) return null;
+		const vao = gl.createVertexArray();
+		const vertexBuffer = gl.createBuffer();
+		const indexBuffer = gl.createBuffer();
+		gl.bindVertexArray(vao);
+		gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
+		gl.enableVertexAttribArray(0);
+		gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 16, 0);
+		gl.enableVertexAttribArray(1);
+		gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 16, 8);
+		gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+		gl.bindVertexArray(null);
+		gl.useProgram(linked);
+		const uTexture = gl.getUniformLocation(linked, "u_texture");
+		if (uTexture) gl.uniform1i(uTexture, 0);
+		meshProgram = {
+			program: linked,
+			vao,
+			vertexBuffer,
+			indexBuffer,
+			vertexBytes: 0,
+			indexBytes: 0,
+			uProjection: gl.getUniformLocation(linked, "u_projection"),
+			uTint: gl.getUniformLocation(linked, "u_tint"),
+			uTexture
+		};
+		return meshProgram;
+	}
+	function drawBatch(batch) {
+		const current = program;
+		if (!current) return;
+		const floats = batch.quadCount * 18;
+		const bytes = floats * 4;
+		gl.bindBuffer(gl.ARRAY_BUFFER, current.instanceBuffer);
+		if (current.instanceBytes < bytes) {
+			gl.bufferData(gl.ARRAY_BUFFER, bytes, gl.DYNAMIC_DRAW);
+			current.instanceBytes = bytes;
+		}
+		gl.bufferSubData(gl.ARRAY_BUFFER, 0, batch.instances, 0, floats);
+		for (let slot = 0; slot < batch.textureCount; slot += 1) {
+			const entry = batch.textures[slot];
+			gl.activeTexture(gl.TEXTURE0 + slot);
+			gl.bindTexture(gl.TEXTURE_2D, entry ? entry.texture : null);
+		}
+		if (batch.colorMatrixCount > 1 && current.uColorMatrices) gl.uniformMatrix3fv(current.uColorMatrices, true, batch.colorMatrices, 0, batch.colorMatrixCount * 9);
+		gl.drawArraysInstanced(gl.TRIANGLE_STRIP, 0, 4, batch.quadCount);
+		stats.batches += 1;
+		stats.textureBinds += batch.textureCount;
+		if (batch.quadCount > stats.maxBatchQuads) stats.maxBatchQuads = batch.quadCount;
+		stats.flushes[batch.reason] += 1;
+	}
+	function releaseGpuPlan(cache, deleteGl) {
+		if (deleteGl) for (const run of cache.runs) {
+			gl.deleteBuffer(run.buffer);
+			gl.deleteVertexArray(run.vao);
+		}
+		compiledGpuPlans.delete(cache.plan);
+		liveCompiledGpuPlans.delete(cache);
+	}
+	function makeCachedVao(current, buffer) {
+		const vao = gl.createVertexArray();
+		if (!vao) return null;
+		gl.bindVertexArray(vao);
+		gl.bindBuffer(gl.ARRAY_BUFFER, current.cornerBuffer);
+		gl.enableVertexAttribArray(0);
+		gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+		gl.vertexAttribDivisor(0, 0);
+		gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+		const strideBytes = 72;
+		for (const attribute of INSTANCE_ATTRIBUTES) {
+			gl.enableVertexAttribArray(attribute.location);
+			gl.vertexAttribPointer(attribute.location, attribute.size, gl.FLOAT, false, strideBytes, attribute.offset * 4);
+			gl.vertexAttribDivisor(attribute.location, 1);
+		}
+		gl.bindVertexArray(current.vao);
+		return vao;
+	}
+	function matrixSlot(matrices, count, source, sourceOffset) {
+		for (let slot = 0; slot < count; slot += 1) if (colorMatricesEqual(matrices, slot * 9, source, sourceOffset)) return slot;
+		return -1;
+	}
+	function writeCachedQuad(run, item, index, plan, textureSlot, matrixSlotIndex) {
+		const texture = run.textures[textureSlot];
+		plan.fillQuad(index, texture.width, texture.height, cachedQuad);
+		const at = item * 18;
+		run.instances[at] = cachedQuad.x0;
+		run.instances[at + 1] = cachedQuad.y0;
+		run.instances[at + 2] = cachedQuad.x1;
+		run.instances[at + 3] = cachedQuad.y1;
+		run.instances[at + 4] = cachedQuad.x2;
+		run.instances[at + 5] = cachedQuad.y2;
+		run.instances[at + 6] = cachedQuad.x3;
+		run.instances[at + 7] = cachedQuad.y3;
+		run.instances[at + 8] = cachedQuad.u0;
+		run.instances[at + 9] = cachedQuad.v0;
+		run.instances[at + 10] = cachedQuad.uSpan;
+		run.instances[at + 11] = cachedQuad.vSpan;
+		run.instances[at + 12] = cachedQuad.r;
+		run.instances[at + 13] = cachedQuad.g;
+		run.instances[at + 14] = cachedQuad.b;
+		run.instances[at + 15] = cachedQuad.a;
+		run.instances[at + 16] = textureSlot;
+		run.instances[at + 17] = matrixSlotIndex;
+	}
+	function buildGpuPlan(plan, current, generation, contentRevision) {
+		const list = plan.list;
+		const runs = [];
+		const runsAt = new Array(list.count).fill(null);
+		const runsForCommand = new Array(list.count).fill(null);
+		const itemsForCommand = new Int32Array(list.count);
+		const discardPartial = () => {
+			for (const run of runs) {
+				gl.deleteBuffer(run.buffer);
+				gl.deleteVertexArray(run.vao);
+			}
+		};
+		for (const descriptor of plan.batches) {
+			let cursor = descriptor.start;
+			while (cursor < descriptor.end) {
+				const commandIndexes = [];
+				const textures = [];
+				const matrices = new Float32Array(maxColorMatrices * 9);
+				matrices.set(IDENTITY_COLOR_MATRIX);
+				let matrixCount = 1;
+				while (cursor < descriptor.end) {
+					const texture = list.textureAt(cursor) ?? whiteTexture();
+					let textureSlot = textures.indexOf(texture);
+					if (textureSlot < 0 && textures.length >= maxTextureSlots) break;
+					const matrixIndex = list.colorMatrixIndexAt(cursor);
+					let slot = 0;
+					if (matrixIndex >= 0) {
+						slot = matrixSlot(matrices, matrixCount, list.colorMatrices, matrixIndex * 9);
+						if (slot < 0 && matrixCount >= maxColorMatrices) break;
+					}
+					if (textureSlot < 0) {
+						textureSlot = textures.length;
+						textures.push(texture);
+					}
+					if (matrixIndex >= 0 && slot < 0) {
+						slot = matrixCount;
+						matrices.set(list.colorMatrices.subarray(matrixIndex * 9, (matrixIndex + 1) * 9), slot * 9);
+						matrixCount += 1;
+					}
+					commandIndexes.push(cursor);
+					cursor += 1;
+				}
+				const buffer = gl.createBuffer();
+				if (!buffer) {
+					discardPartial();
+					return null;
+				}
+				const vao = makeCachedVao(current, buffer);
+				if (!vao) {
+					gl.deleteBuffer(buffer);
+					discardPartial();
+					return null;
+				}
+				const commands = Int32Array.from(commandIndexes);
+				const run = {
+					start: commands[0],
+					end: commands[commands.length - 1] + 1,
+					blend: descriptor.blend,
+					commands,
+					textures,
+					dimensions: new Int32Array(textures.length * 2),
+					itemsByTexture: textures.map(() => []),
+					colorMatrices: matrices.subarray(0, matrixCount * 9),
+					colorMatrixCount: matrixCount,
+					instances: new Float32Array(commands.length * 18),
+					buffer,
+					vao
+				};
+				for (let item = 0; item < commands.length; item += 1) {
+					const index = commands[item];
+					const textureSlot = textures.indexOf(list.textureAt(index) ?? whiteTexture());
+					const matrixIndex = list.colorMatrixIndexAt(index);
+					const slot = matrixIndex < 0 ? 0 : matrixSlot(run.colorMatrices, matrixCount, list.colorMatrices, matrixIndex * 9);
+					writeCachedQuad(run, item, index, plan, textureSlot, slot);
+					run.itemsByTexture[textureSlot].push(item);
+				}
+				for (let slot = 0; slot < textures.length; slot += 1) {
+					run.dimensions[slot * 2] = textures[slot].width;
+					run.dimensions[slot * 2 + 1] = textures[slot].height;
+				}
+				gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+				gl.bufferData(gl.ARRAY_BUFFER, run.instances, gl.DYNAMIC_DRAW);
+				stats.compiledGpuFullUploads += 1;
+				runs.push(run);
+				runsAt[run.start] = run;
+				for (let item = 0; item < run.commands.length; item += 1) {
+					const index = run.commands[item];
+					runsForCommand[index] = run;
+					itemsForCommand[index] = item;
+				}
+			}
+		}
+		gl.bindVertexArray(current.vao);
+		const cache = {
+			plan,
+			generation,
+			contentRevision,
+			runs,
+			runsAt,
+			runsForCommand,
+			itemsForCommand
+		};
+		compiledGpuPlans.set(plan, cache);
+		liveCompiledGpuPlans.add(cache);
+		return cache;
+	}
+	function updateGpuPlan(cache, current, changedCommands, contentRevision) {
+		const list = cache.plan.list;
+		const updateItem = (run, item) => {
+			const index = run.commands[item];
+			const texture = list.textureAt(index) ?? whiteTexture();
+			const textureSlot = run.textures.indexOf(texture);
+			if (textureSlot < 0) return false;
+			if (run.instances[item * 18 + 16] !== textureSlot) return false;
+			const matrixIndex = list.colorMatrixIndexAt(index);
+			const matrixSlotIndex = matrixIndex < 0 ? 0 : matrixSlot(run.colorMatrices, run.colorMatrixCount, list.colorMatrices, matrixIndex * 9);
+			if (matrixSlotIndex < 0) return false;
+			writeCachedQuad(run, item, index, cache.plan, textureSlot, matrixSlotIndex);
+			gl.bindBuffer(gl.ARRAY_BUFFER, run.buffer);
+			gl.bufferSubData(gl.ARRAY_BUFFER, item * 18 * 4, run.instances, item * 18, 18);
+			stats.compiledGpuRangeUploads += 1;
+			return true;
+		};
+		for (const index of changedCommands) {
+			const run = cache.runsForCommand[index];
+			if (!run) continue;
+			if (!updateItem(run, cache.itemsForCommand[index])) {
+				releaseGpuPlan(cache, true);
+				return buildGpuPlan(cache.plan, current, cache.generation, contentRevision);
+			}
+		}
+		for (const run of cache.runs) for (let slot = 0; slot < run.textures.length; slot += 1) {
+			const texture = run.textures[slot];
+			if (run.dimensions[slot * 2] === texture.width && run.dimensions[slot * 2 + 1] === texture.height) continue;
+			run.dimensions[slot * 2] = texture.width;
+			run.dimensions[slot * 2 + 1] = texture.height;
+			for (const item of run.itemsByTexture[slot]) if (!updateItem(run, item)) {
+				releaseGpuPlan(cache, true);
+				return buildGpuPlan(cache.plan, current, cache.generation, contentRevision);
+			}
+		}
+		gl.bindVertexArray(current.vao);
+		cache.contentRevision = contentRevision;
+		return cache;
+	}
+	function drawCachedRange(run, first, count, current) {
+		applyBlend(run.blend);
+		gl.bindVertexArray(run.vao);
+		gl.bindBuffer(gl.ARRAY_BUFFER, run.buffer);
+		const strideBytes = 72;
+		for (const attribute of INSTANCE_ATTRIBUTES) gl.vertexAttribPointer(attribute.location, attribute.size, gl.FLOAT, false, strideBytes, first * strideBytes + attribute.offset * 4);
+		for (let slot = 0; slot < run.textures.length; slot += 1) {
+			gl.activeTexture(gl.TEXTURE0 + slot);
+			gl.bindTexture(gl.TEXTURE_2D, run.textures[slot].texture);
+		}
+		if (run.colorMatrixCount > 1 && current.uColorMatrices) gl.uniformMatrix3fv(current.uColorMatrices, true, run.colorMatrices, 0, run.colorMatrixCount * 9);
+		gl.drawArraysInstanced(gl.TRIANGLE_STRIP, 0, 4, count);
+		stats.batches += 1;
+		stats.textureBinds += run.textures.length;
+		stats.quads += count;
+		stats.maxBatchQuads = Math.max(stats.maxBatchQuads, count);
+		stats.compiledCachedDrawCalls += 1;
+		gl.bindVertexArray(current.vao);
+	}
+	/**
+	* Forget everything this executor believes about the GL state it set.
+	*
+	* TWO CALLERS, ONE RULE: it does not own the context. `execute` calls it on entry because
+	* something else may have drawn into the context since the last frame, and the glyph pass path
+	* calls it on the way back because something else just did, in the middle of this one. Every
+	* cached value here guards a GL call that would otherwise be skipped, so a stale cache is not a
+	* redundant call — it is a call that never happens and state that is silently somebody else's.
+	*
+	* `appliedBlend` is the one that bites hardest today: `@godot-scene-web/hb-gpu` sets the
+	* NON-separate `blendEquation`/`blendFunc`, which write both the RGB and the alpha halves, so
+	* without this the next quad keeps the glyph pass's blend and nothing errors.
+	*/
+	function invalidateAppliedState() {
+		appliedBlend = null;
+		appliedRoundedRadius = -1;
+		appliedScissor.x = -1;
+		appliedScissor.y = -1;
+		appliedScissor.width = -1;
+		appliedScissor.height = -1;
+	}
+	function applyBlend(blend) {
+		if (blend === appliedBlend) return;
+		batcher.setBlend(blend);
+		const state = blendStateFor(blend);
+		gl.blendEquationSeparate(gl[state.equationRgb], gl[state.equationAlpha]);
+		gl.blendFuncSeparate(gl[state.srcRgb], gl[state.dstRgb], gl[state.srcAlpha], gl[state.dstAlpha]);
+		appliedBlend = blend;
+		stats.blendChanges += 1;
+	}
+	function applyClip(transform, width, height, damage) {
+		clipStack.scissor(transform, width, height, scissor);
+		if (damage) {
+			const left = Math.max(0, Math.min(width, Math.floor(damage.x)));
+			const right = Math.max(left, Math.min(width, Math.ceil(damage.x + damage.width)));
+			const top = Math.max(0, Math.min(height, Math.floor(damage.y)));
+			const bottom = Math.max(top, Math.min(height, Math.ceil(damage.y + damage.height)));
+			damageScissor.x = left;
+			damageScissor.y = height - bottom;
+			damageScissor.width = right - left;
+			damageScissor.height = bottom - top;
+			const clippedRight = Math.min(scissor.x + scissor.width, right);
+			const clippedTop = Math.max(scissor.y, damageScissor.y);
+			const clippedBottom = Math.min(scissor.y + scissor.height, damageScissor.y + damageScissor.height);
+			scissor.x = Math.max(scissor.x, left);
+			scissor.y = clippedTop;
+			scissor.width = Math.max(0, clippedRight - scissor.x);
+			scissor.height = Math.max(0, clippedBottom - clippedTop);
+		}
+		if (scissor.x !== appliedScissor.x || scissor.y !== appliedScissor.y || scissor.width !== appliedScissor.width || scissor.height !== appliedScissor.height) {
+			gl.scissor(scissor.x, scissor.y, scissor.width, scissor.height);
+			appliedScissor.x = scissor.x;
+			appliedScissor.y = scissor.y;
+			appliedScissor.width = scissor.width;
+			appliedScissor.height = scissor.height;
+			stats.scissorChanges += 1;
+		}
+		const current = program;
+		if (!current) return;
+		const rounded = clipStack.rounded();
+		const radius = rounded ? rounded.radius : 0;
+		const centerX = rounded ? rounded.centerX : 0;
+		const centerY = rounded ? rounded.centerY : 0;
+		const halfWidth = rounded ? rounded.halfWidth : 0;
+		const halfHeight = rounded ? rounded.halfHeight : 0;
+		if (radius === appliedRoundedRadius && centerX === appliedRounded[0] && centerY === appliedRounded[1] && halfWidth === appliedRounded[2] && halfHeight === appliedRounded[3]) return;
+		if (current.uRoundedRadius) gl.uniform1f(current.uRoundedRadius, radius);
+		if (current.uRoundedRect) gl.uniform4f(current.uRoundedRect, centerX, centerY, halfWidth, halfHeight);
+		appliedRoundedRadius = radius;
+		appliedRounded[0] = centerX;
+		appliedRounded[1] = centerY;
+		appliedRounded[2] = halfWidth;
+		appliedRounded[3] = halfHeight;
+	}
+	/**
+	* Emit one rect of a command: `localX..localH` is the destination in the
+	* command's own local space (`0..w` by `0..h`), which `m` maps into design
+	* space; `srcX..srcH` is the source in page pixels.
+	*/
+	function emitRect(m, localX, localY, localW, localH, srcX, srcY, srcW, srcH, texture, flipH, flipV, r, g, b, a, colorMatrix, colorMatrixOffset) {
+		const quad = batcher.quad;
+		const x1 = localX + localW;
+		const y1 = localY + localH;
+		const xx = m[0];
+		const xy = m[1];
+		const yx = m[2];
+		const yy = m[3];
+		const ox = m[4];
+		const oy = m[5];
+		quad.x0 = xx * localX + yx * localY + ox;
+		quad.y0 = xy * localX + yy * localY + oy;
+		quad.x1 = xx * x1 + yx * localY + ox;
+		quad.y1 = xy * x1 + yy * localY + oy;
+		quad.x2 = xx * x1 + yx * y1 + ox;
+		quad.y2 = xy * x1 + yy * y1 + oy;
+		quad.x3 = xx * localX + yx * y1 + ox;
+		quad.y3 = xy * localX + yy * y1 + oy;
+		const invW = 1 / Math.max(1, texture.width);
+		const invH = 1 / Math.max(1, texture.height);
+		let u0 = srcX * invW;
+		let v0 = srcY * invH;
+		let uSpan = srcW * invW;
+		let vSpan = srcH * invH;
+		if (flipH) {
+			u0 += uSpan;
+			uSpan = -uSpan;
+		}
+		if (flipV) {
+			v0 += vSpan;
+			vSpan = -vSpan;
+		}
+		quad.u0 = u0;
+		quad.v0 = v0;
+		quad.uSpan = uSpan;
+		quad.vSpan = vSpan;
+		quad.r = r;
+		quad.g = g;
+		quad.b = b;
+		quad.a = a;
+		batcher.push(texture, colorMatrix, colorMatrixOffset);
+		stats.quads += 1;
+	}
+	function emitQuadCommand(list, index, compiled) {
+		const texture = list.textureAt(index) ?? whiteTexture();
+		if (compiled?.fillQuad(index, texture.width, texture.height, batcher.quad)) {
+			applyBlend(list.ints[list.intOffsetAt(index)]);
+			const matrixIndex = list.colorMatrixIndexAt(index);
+			batcher.push(texture, matrixIndex >= 0 ? list.colorMatrices : null, matrixIndex >= 0 ? matrixIndex * 9 : 0);
+			stats.quads += 1;
+			return;
+		}
+		list.readQuad(index, quadView);
+		applyBlend(quadView.blend);
+		emitRect(quadView.m, 0, 0, quadView.w, quadView.h, quadView.srcX, quadView.srcY, quadView.srcW, quadView.srcH, texture, quadView.flipH, quadView.flipV, quadView.r, quadView.g, quadView.b, quadView.a, quadView.hasColorMatrix ? quadView.colorMatrix : null, 0);
+	}
+	function emitNinePatchCommand(list, index) {
+		list.readNinePatch(index, patchView);
+		applyBlend(patchView.blend);
+		const texture = list.textureAt(index) ?? whiteTexture();
+		const count = expandNinePatch(patchView, bands);
+		stats.ninePatches += 1;
+		stats.ninePatchQuads += count;
+		for (let i = 0; i < count; i += 1) {
+			const band = bands[i];
+			const localX = patchView.flipH ? patchView.w - band.dstX - band.dstW : band.dstX;
+			const localY = patchView.flipV ? patchView.h - band.dstY - band.dstH : band.dstY;
+			emitRect(patchView.m, localX, localY, band.dstW, band.dstH, band.srcX, band.srcY, band.srcW, band.srcH, texture, patchView.flipH, patchView.flipV, patchView.r, patchView.g, patchView.b, patchView.a, patchView.hasColorMatrix ? patchView.colorMatrix : null, 0);
+		}
+	}
+	function emitPolylineCommand(list, index) {
+		list.readPolyline(index, lineView);
+		applyBlend(0);
+		const white = whiteTexture();
+		const needed = Math.max(0, 2 * lineView.pointCount - 3) * 8;
+		if (strokeQuads.length < needed) strokeQuads = new Float32Array(Math.max(needed, strokeQuads.length * 2));
+		const count = expandPolyline(lineView.points, lineView.pointCount, lineView.width, strokeQuads, 0);
+		stats.polylines += 1;
+		stats.polylineQuads += count;
+		const quad = batcher.quad;
+		for (let i = 0; i < count; i += 1) {
+			const at = i * 8;
+			quad.x0 = strokeQuads[at];
+			quad.y0 = strokeQuads[at + 1];
+			quad.x1 = strokeQuads[at + 2];
+			quad.y1 = strokeQuads[at + 3];
+			quad.x2 = strokeQuads[at + 4];
+			quad.y2 = strokeQuads[at + 5];
+			quad.x3 = strokeQuads[at + 6];
+			quad.y3 = strokeQuads[at + 7];
+			quad.u0 = 0;
+			quad.v0 = 0;
+			quad.uSpan = 0;
+			quad.vSpan = 0;
+			quad.r = lineView.r;
+			quad.g = lineView.g;
+			quad.b = lineView.b;
+			quad.a = lineView.a;
+			batcher.push(white, null, 0);
+			stats.quads += 1;
+		}
+	}
+	/**
+	* Execute one true indexed mesh between quad batches. The flush is before any
+	* state mutation, preserving painter order. The mesh then borrows the context
+	* only long enough to upload its pooled data and draw; program and VAO are
+	* rebound to the quad executor before returning, while blend/scissor remain
+	* the executor's own known state for the next command.
+	*/
+	function emitTexturedMeshCommand(list, index, projection, current) {
+		batcher.flush("meshes");
+		list.readTexturedMesh(index, texturedMeshView);
+		applyBlend(texturedMeshView.blend);
+		stats.texturedMeshes += 1;
+		if (texturedMeshView.indexCount === 0) return;
+		const mesh = ensureMeshProgram();
+		if (!mesh) return;
+		const vertexFloats = texturedMeshView.vertexCount * 4;
+		if (meshVertices.length < vertexFloats) meshVertices = new Float32Array(Math.max(vertexFloats, meshVertices.length * 2));
+		const m = texturedMeshView.m;
+		for (let vertex = 0; vertex < texturedMeshView.vertexCount; vertex += 1) {
+			const source = vertex * 2;
+			const target = vertex * 4;
+			const x = texturedMeshView.positions[source];
+			const y = texturedMeshView.positions[source + 1];
+			meshVertices[target] = m[0] * x + m[2] * y + m[4];
+			meshVertices[target + 1] = m[1] * x + m[3] * y + m[5];
+			meshVertices[target + 2] = texturedMeshView.uvs[source];
+			meshVertices[target + 3] = texturedMeshView.uvs[source + 1];
+		}
+		gl.bindVertexArray(mesh.vao);
+		gl.useProgram(mesh.program);
+		if (mesh.uProjection) gl.uniform4f(mesh.uProjection, projection.toClip[0], projection.toClip[1], projection.toClip[2], projection.toClip[3]);
+		if (mesh.uTint) gl.uniform4f(mesh.uTint, texturedMeshView.r, texturedMeshView.g, texturedMeshView.b, texturedMeshView.a);
+		const vertexBytes = vertexFloats * 4;
+		gl.bindBuffer(gl.ARRAY_BUFFER, mesh.vertexBuffer);
+		if (mesh.vertexBytes < vertexBytes) {
+			gl.bufferData(gl.ARRAY_BUFFER, vertexBytes, gl.DYNAMIC_DRAW);
+			mesh.vertexBytes = vertexBytes;
+		}
+		gl.bufferSubData(gl.ARRAY_BUFFER, 0, meshVertices, 0, vertexFloats);
+		const indexBytes = texturedMeshView.indexCount * 4;
+		gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, mesh.indexBuffer);
+		if (mesh.indexBytes < indexBytes) {
+			gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indexBytes, gl.DYNAMIC_DRAW);
+			mesh.indexBytes = indexBytes;
+		}
+		gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, texturedMeshView.indices, 0, texturedMeshView.indexCount);
+		const texture = list.textureAt(index) ?? whiteTexture();
+		gl.activeTexture(gl.TEXTURE0);
+		gl.bindTexture(gl.TEXTURE_2D, texture.texture);
+		gl.drawElements(gl.TRIANGLES, texturedMeshView.indexCount, gl.UNSIGNED_INT, 0);
+		stats.texturedMeshTriangles += texturedMeshView.indexCount / 3;
+		stats.texturedMeshDrawCalls += 1;
+		gl.bindVertexArray(current.vao);
+		gl.useProgram(current.program);
+	}
+	/**
+	* Hand one glyph run to the installed pass, then put the context back the way it was.
+	*
+	* THE ORDER IS THE MODULE'S OWN RULE (see the note at the top of this file): a flush DRAWS with
+	* whatever GL state is live, so the pending batch has to go out BEFORE the pass replaces the
+	* program and the vertex array — never after. Doing it the other way round draws this frame's
+	* quads through a glyph shader, which is a blank rectangle rather than anything that reads as an
+	* ordering bug.
+	*
+	* WHAT IS RESTORED, AND WHY EACH ONE IS NEEDED. `drawBatch` re-binds `ARRAY_BUFFER` and its
+	* textures per batch, so those look after themselves; the VAO and the program are bound ONCE per
+	* frame, and a pass that leaves the VAO unbound (hb-gpu's `end` does exactly that, deliberately,
+	* because WebGL2 has no cheap read-back of the binding) would make the next `drawArraysInstanced`
+	* read attributes from nothing. The cached state goes through
+	* {@link invalidateAppliedState} rather than being re-applied eagerly, so a run followed by
+	* nothing costs no GL calls at all.
+	*
+	* NOT restored, because the pass is forbidden to touch it: `SCISSOR_TEST`, the scissor box and
+	* the viewport. That is what makes a clip rect clip a glyph run.
+	*/
+	function emitGlyphsCommand(list, index, projection, current) {
+		if (!glyphPass) {
+			stats.glyphRunsDropped += 1;
+			return;
+		}
+		batcher.flush("glyphs");
+		list.readGlyphs(index, glyphsView);
+		const drawn = glyphPass.drawRun(glyphsView, projection);
+		stats.glyphRuns += 1;
+		stats.glyphs += drawn.glyphs;
+		stats.glyphDrawCalls += drawn.drawCalls;
+		gl.bindVertexArray(current.vao);
+		gl.useProgram(current.program);
+		appliedBlend = null;
+	}
+	function emitAdjacentGlyphCommands(list, firstIndex, projection, current, commandMask) {
+		if (!glyphPass || !options.batchAdjacentGlyphRuns || !glyphPass.drawRuns) {
+			emitGlyphsCommand(list, firstIndex, projection, current);
+			return firstIndex;
+		}
+		let count = 0;
+		for (let index = firstIndex; index < list.count; index += 1) {
+			if (list.kindAt(index) !== 5 || commandMask && !commandMask.includes(index)) break;
+			let view = glyphRunViewPool[count];
+			if (!view) {
+				view = createGlyphsView(64);
+				glyphRunViewPool.push(view);
+			}
+			list.readGlyphs(index, view);
+			count += 1;
+		}
+		if (count < 2) {
+			emitGlyphsCommand(list, firstIndex, projection, current);
+			return firstIndex;
+		}
+		glyphRunViews.length = count;
+		for (let i = 0; i < count; i += 1) glyphRunViews[i] = glyphRunViewPool[i];
+		if (glyphPass.canBatchRuns && !glyphPass.canBatchRuns(glyphRunViews)) {
+			stats.glyphRunBatchFallbacks += 1;
+			emitGlyphsCommand(list, firstIndex, projection, current);
+			return firstIndex;
+		}
+		batcher.flush("glyphs");
+		const drawn = glyphPass.drawRuns(glyphRunViews, projection);
+		stats.glyphRuns += count;
+		stats.glyphs += drawn.glyphs;
+		stats.glyphDrawCalls += drawn.drawCalls;
+		stats.glyphRunBatches += 1;
+		gl.bindVertexArray(current.vao);
+		gl.useProgram(current.program);
+		appliedBlend = null;
+		return firstIndex + count - 1;
+	}
+	function emitScreenEffectCommand(list, index, projection, damage, current) {
+		const effect = list.screenEffectAt(index);
+		if (!effect) {
+			stats.unknownCommands += 1;
+			return false;
+		}
+		batcher.flush("effects");
+		const framebuffer = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+		const succeeded = effect.execute({
+			gl,
+			framebuffer,
+			width: projection.framebufferWidth,
+			height: projection.framebufferHeight,
+			damage,
+			scissor: appliedScissor
+		});
+		if (succeeded) stats.screenEffects += 1;
+		else stats.screenEffectFailures += 1;
+		gl.bindVertexArray(current.vao);
+		gl.useProgram(current.program);
+		gl.viewport(0, 0, projection.framebufferWidth, projection.framebufferHeight);
+		gl.enable(gl.SCISSOR_TEST);
+		invalidateAppliedState();
+		applyClip(projection.toFramebuffer, projection.framebufferWidth, projection.framebufferHeight, damage);
+		applyBlend(0);
+		return succeeded;
+	}
+	function emitExternalEffectCommand(list, index, projection, damage, current) {
+		const effect = list.externalEffectAt(index);
+		if (!effect) {
+			stats.unknownCommands += 1;
+			return false;
+		}
+		batcher.flush("effects");
+		const framebuffer = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+		const succeeded = effect.execute({
+			gl,
+			framebuffer,
+			width: projection.framebufferWidth,
+			height: projection.framebufferHeight,
+			damage,
+			scissor: appliedScissor
+		});
+		if (succeeded) stats.externalEffects += 1;
+		else stats.externalEffectFailures += 1;
+		gl.bindVertexArray(current.vao);
+		gl.useProgram(current.program);
+		gl.viewport(0, 0, projection.framebufferWidth, projection.framebufferHeight);
+		gl.enable(gl.SCISSOR_TEST);
+		invalidateAppliedState();
+		applyClip(projection.toFramebuffer, projection.framebufferWidth, projection.framebufferHeight, damage);
+		applyBlend(0);
+		return succeeded;
+	}
+	return {
+		gl,
+		stats,
+		maxTextureSlots,
+		warmUp() {
+			return ensureProgram() !== null && ensureMeshProgram() !== null;
+		},
+		releaseCompiled(plan) {
+			const cache = compiledGpuPlans.get(plan);
+			if (cache) releaseGpuPlan(cache, true);
+		},
+		execute(list, projection, executeOptions) {
+			const current = ensureProgram();
+			if (!current) return false;
+			stats.commands = 0;
+			stats.quads = 0;
+			stats.batches = 0;
+			stats.textureBinds = 0;
+			stats.scissorChanges = 0;
+			stats.blendChanges = 0;
+			stats.ninePatches = 0;
+			stats.ninePatchQuads = 0;
+			stats.polylines = 0;
+			stats.polylineQuads = 0;
+			stats.texturedMeshes = 0;
+			stats.texturedMeshTriangles = 0;
+			stats.texturedMeshDrawCalls = 0;
+			stats.glyphRuns = 0;
+			stats.glyphs = 0;
+			stats.glyphDrawCalls = 0;
+			stats.glyphRunBatches = 0;
+			stats.glyphRunBatchFallbacks = 0;
+			stats.glyphRunsDropped = 0;
+			stats.screenEffects = 0;
+			stats.screenEffectFailures = 0;
+			stats.externalEffects = 0;
+			stats.externalEffectFailures = 0;
+			stats.rotatedClipFallbacks = 0;
+			stats.unbalancedClipPops = 0;
+			stats.unknownCommands = 0;
+			stats.maxBatchQuads = 0;
+			stats.flushes.textureSlots = 0;
+			stats.flushes.colorMatrices = 0;
+			stats.flushes.blend = 0;
+			stats.flushes.clip = 0;
+			stats.flushes.glyphs = 0;
+			stats.flushes.effects = 0;
+			stats.flushes.meshes = 0;
+			stats.flushes.compiled = 0;
+			stats.flushes.end = 0;
+			stats.compiledPlanBuilds = 0;
+			stats.compiledPlanReuses = 0;
+			stats.compiledTemplateRangeUpdates = 0;
+			stats.reusedSelections = 0;
+			stats.reusedBatches = 0;
+			stats.compiledGpuFullUploads = 0;
+			stats.compiledGpuRangeUploads = 0;
+			stats.compiledCachedDrawCalls = 0;
+			const compiled = executeOptions?.compiled?.list === list ? executeOptions.compiled : void 0;
+			let gpuCache = null;
+			if (compiled) {
+				const refresh = compiled.refresh();
+				stats.compiledPlanBuilds = refresh.rebuilt ? 1 : 0;
+				stats.compiledPlanReuses = refresh.rebuilt ? 0 : 1;
+				stats.compiledTemplateRangeUpdates = refresh.rangeUpdates;
+				stats.reusedSelections = 0;
+				stats.reusedBatches = refresh.rebuilt ? 0 : compiled.batches.length;
+				const existing = compiledGpuPlans.get(compiled);
+				if (existing && (existing.generation !== refresh.planGeneration || existing.contentRevision !== refresh.contentRevision && existing.contentRevision !== refresh.deltaBaseRevision)) releaseGpuPlan(existing, true);
+				const currentCache = compiledGpuPlans.get(compiled);
+				gpuCache = currentCache ? currentCache.contentRevision === refresh.contentRevision ? updateGpuPlan(currentCache, current, NO_CHANGED_COMMANDS, refresh.contentRevision) : updateGpuPlan(currentCache, current, refresh.changedCommands, refresh.contentRevision) : buildGpuPlan(compiled, current, refresh.planGeneration, refresh.contentRevision);
+			}
+			clipStack.reset();
+			batcher.reset();
+			const width = projection.framebufferWidth;
+			const height = projection.framebufferHeight;
+			gl.bindVertexArray(current.vao);
+			gl.useProgram(current.program);
+			gl.viewport(0, 0, width, height);
+			if (current.uProjection) gl.uniform4f(current.uProjection, projection.toClip[0], projection.toClip[1], projection.toClip[2], projection.toClip[3]);
+			gl.disable(gl.DEPTH_TEST);
+			gl.disable(gl.CULL_FACE);
+			gl.enable(gl.BLEND);
+			gl.enable(gl.SCISSOR_TEST);
+			invalidateAppliedState();
+			applyClip(projection.toFramebuffer, width, height, executeOptions?.damage);
+			applyBlend(0);
+			if (executeOptions?.clear !== false) {
+				const clearColor = executeOptions?.clearColor;
+				gl.clearColor(clearColor?.[0] ?? 0, clearColor?.[1] ?? 0, clearColor?.[2] ?? 0, clearColor?.[3] ?? 0);
+				gl.clear(gl.COLOR_BUFFER_BIT);
+			}
+			let clipSerial = 0;
+			let screenEffectFailed = false;
+			const count = list.count;
+			for (let index = 0; index < count; index += 1) {
+				if (screenEffectFailed) break;
+				if (executeOptions?.commandMask && !executeOptions.commandMask.includes(index)) continue;
+				const cached = executeOptions?.commandMask ? gpuCache?.runsForCommand[index] : gpuCache?.runsAt[index];
+				if (cached) {
+					const first = executeOptions?.commandMask ? gpuCache?.itemsForCommand[index] ?? 0 : 0;
+					let cachedCount = 1;
+					if (!executeOptions?.commandMask) cachedCount = cached.commands.length;
+					else while (first + cachedCount < cached.commands.length && executeOptions.commandMask.includes(cached.commands[first + cachedCount])) cachedCount += 1;
+					batcher.flush("compiled");
+					drawCachedRange(cached, first, cachedCount, current);
+					stats.commands += cachedCount;
+					index = cached.commands[first + cachedCount - 1];
+					continue;
+				}
+				stats.commands += 1;
+				switch (list.kindAt(index)) {
+					case 0:
+						emitQuadCommand(list, index, compiled);
+						break;
+					case 1:
+						emitNinePatchCommand(list, index);
+						break;
+					case 2:
+						emitPolylineCommand(list, index);
+						break;
+					case 5:
+						index = emitAdjacentGlyphCommands(list, index, projection, current, executeOptions?.commandMask);
+						break;
+					case 6:
+						emitTexturedMeshCommand(list, index, projection, current);
+						break;
+					case 7:
+						screenEffectFailed = !emitScreenEffectCommand(list, index, projection, executeOptions?.damage, current);
+						break;
+					case 8:
+						screenEffectFailed = !emitExternalEffectCommand(list, index, projection, executeOptions?.damage, current);
+						break;
+					case 3:
+						list.readClipRect(index, clipView);
+						clipSerial += 1;
+						batcher.setClipEpoch(clipSerial);
+						clipStack.push(clipView);
+						applyClip(projection.toFramebuffer, width, height, executeOptions?.damage);
+						break;
+					case 4:
+						if (clipStack.depth === 0) {
+							stats.unbalancedClipPops += 1;
+							break;
+						}
+						clipSerial += 1;
+						batcher.setClipEpoch(clipSerial);
+						clipStack.pop();
+						applyClip(projection.toFramebuffer, width, height, executeOptions?.damage);
+						break;
+					default:
+						stats.unknownCommands += 1;
+						break;
+				}
+			}
+			batcher.flush("end");
+			stats.rotatedClipFallbacks = clipStack.rotatedFallbacks;
+			gl.bindVertexArray(null);
+			gl.disable(gl.SCISSOR_TEST);
+			return !screenEffectFailed;
+		},
+		invalidate() {
+			program = null;
+			meshProgram = null;
+			ownedWhite = null;
+			appliedBlend = null;
+			appliedRoundedRadius = -1;
+			for (const cache of [...liveCompiledGpuPlans]) releaseGpuPlan(cache, false);
+		},
+		dispose() {
+			for (const cache of [...liveCompiledGpuPlans]) releaseGpuPlan(cache, true);
+			if (program) {
+				gl.deleteProgram(program.program);
+				gl.deleteVertexArray(program.vao);
+				gl.deleteBuffer(program.cornerBuffer);
+				gl.deleteBuffer(program.instanceBuffer);
+				program = null;
+			}
+			if (ownedWhite) {
+				gl.deleteTexture(ownedWhite.texture);
+				ownedWhite = null;
+			}
+			if (meshProgram) {
+				gl.deleteProgram(meshProgram.program);
+				gl.deleteVertexArray(meshProgram.vao);
+				gl.deleteBuffer(meshProgram.vertexBuffer);
+				gl.deleteBuffer(meshProgram.indexBuffer);
+				meshProgram = null;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/headless-effects.ts
+/** Bind a GPU screen producer at one DrawList painter position. */
+function createHeadlessScreenEffectCommand(producer, input) {
+	return {
+		screenDependent: true,
+		execute(context) {
+			return producer.renderScreen(input, context).ok;
+		}
+	};
+}
+/** Bind a direct GPU particle pass at one DrawList painter position. */
+function createHeadlessGodotParticleDirectEffect(pass, input) {
+	return { execute(context) {
+		return pass.draw(input, context).ok;
+	} };
+}
+//#endregion
+//#region src/present.ts
+const CONTEXT_ATTRIBUTES = {
+	alpha: true,
+	premultipliedAlpha: true,
+	stencil: false,
+	depth: false,
+	antialias: false,
+	preserveDrawingBuffer: false
+};
+/** The attributes the stage asks for, exported so a test can assert the contract
+*  rather than restate it. */
+const STAGE_CONTEXT_ATTRIBUTES = CONTEXT_ATTRIBUTES;
+/**
+* Create a stage on `canvas`, or `null` when the browser gives no WebGL2 context.
+*
+* Note what is NOT here: no software-renderer refusal. `html`'s shared context
+* declines SwiftShader/llvmpipe because running full-screen procedural fragment
+* shaders on a CPU rasterizer costs more than the CSS fallback it has. The stage
+* has no fallback to fall back TO — it is the renderer — and its fragment shader
+* is a texture fetch and a multiply, which software GL runs perfectly well. The
+* decision of whether this device should use the canvas renderer at all belongs
+* to the consumer, one level up, where the alternative is known.
+*/
+function createCanvasStage(options) {
+	const canvas = options.canvas;
+	const contextAttributes = options.alpha === void 0 ? CONTEXT_ATTRIBUTES : {
+		...CONTEXT_ATTRIBUTES,
+		alpha: options.alpha
+	};
+	let gl = null;
+	try {
+		gl = canvas.getContext("webgl2", contextAttributes);
+	} catch {
+		gl = null;
+	}
+	if (!gl) return null;
+	const context = gl;
+	const alpha = context.getContextAttributes?.()?.alpha ?? contextAttributes.alpha ?? true;
+	let designWidth = Math.max(1, options.designWidth);
+	let designHeight = Math.max(1, options.designHeight);
+	let stageWidth = 0;
+	let stageHeight = 0;
+	let contextLost = false;
+	const projection = {
+		designWidth,
+		designHeight,
+		toClip: new Float32Array(4),
+		toFramebuffer: new Float32Array([
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		]),
+		framebufferWidth: 0,
+		framebufferHeight: 0
+	};
+	function readBackingSize() {
+		const width = context.drawingBufferWidth || canvas.width;
+		const height = context.drawingBufferHeight || canvas.height;
+		stageWidth = Math.max(1, width);
+		stageHeight = Math.max(1, height);
+	}
+	function refreshProjection() {
+		projection.designWidth = designWidth;
+		projection.designHeight = designHeight;
+		projection.toClip[0] = 2 / designWidth;
+		projection.toClip[1] = -2 / designHeight;
+		projection.toClip[2] = -1;
+		projection.toClip[3] = 1;
+		projection.toFramebuffer[0] = stageWidth / designWidth;
+		projection.toFramebuffer[1] = 0;
+		projection.toFramebuffer[2] = 0;
+		projection.toFramebuffer[3] = stageHeight / designHeight;
+		projection.toFramebuffer[4] = 0;
+		projection.toFramebuffer[5] = 0;
+		projection.framebufferWidth = stageWidth;
+		projection.framebufferHeight = stageHeight;
+	}
+	readBackingSize();
+	refreshProjection();
+	const onLost = (event) => {
+		event.preventDefault();
+		contextLost = true;
+		options.onContextLost?.();
+	};
+	const onRestored = () => {
+		contextLost = false;
+		readBackingSize();
+		refreshProjection();
+		options.onContextRestored?.();
+	};
+	canvas.addEventListener("webglcontextlost", onLost);
+	canvas.addEventListener("webglcontextrestored", onRestored);
+	return {
+		canvas,
+		gl: context,
+		get designWidth() {
+			return designWidth;
+		},
+		get designHeight() {
+			return designHeight;
+		},
+		get stageWidth() {
+			return stageWidth;
+		},
+		get stageHeight() {
+			return stageHeight;
+		},
+		get contextLost() {
+			return contextLost;
+		},
+		get alpha() {
+			return alpha;
+		},
+		setStageSize(width, height) {
+			const w = Math.max(1, Math.floor(width));
+			const h = Math.max(1, Math.floor(height));
+			if (canvas.width !== w) canvas.width = w;
+			if (canvas.height !== h) canvas.height = h;
+			readBackingSize();
+			refreshProjection();
+		},
+		setDesignSize(width, height) {
+			designWidth = Math.max(1, width);
+			designHeight = Math.max(1, height);
+			refreshProjection();
+		},
+		projection() {
+			return projection;
+		},
+		applyViewport() {
+			context.viewport(0, 0, stageWidth, stageHeight);
+		},
+		dispose() {
+			canvas.removeEventListener("webglcontextlost", onLost);
+			canvas.removeEventListener("webglcontextrestored", onRestored);
+		}
+	};
+}
+//#endregion
+//#region src/retained-surface.ts
+/** Snap a CSS/device calculation once at the allocation boundary. */
+function snapRetainedSize(value) {
+	return Number.isFinite(value) ? Math.max(1, Math.round(value)) : 1;
+}
+function isValidDamage(damage, width, height) {
+	return Number.isFinite(damage.x) && Number.isFinite(damage.y) && Number.isFinite(damage.width) && Number.isFinite(damage.height) && damage.width > 0 && damage.height > 0 && damage.x >= 0 && damage.y >= 0 && damage.x + damage.width <= width && damage.y + damage.height <= height;
+}
+/**
+* Create a retained RGBA8 texture/FBO. It deliberately does not create a
+* canvas or context — a stage owns that DOM-facing concern — and it does not
+* monkey-patch an executor. Retention is opt-in per replay/present call.
+*/
+function createRetainedSurface(gl) {
+	let texture = null;
+	let framebuffer = null;
+	let width = 0;
+	let height = 0;
+	let contentValid = false;
+	function discard(callGl) {
+		if (callGl) {
+			if (framebuffer) gl.deleteFramebuffer(framebuffer);
+			if (texture) gl.deleteTexture(texture);
+		}
+		framebuffer = null;
+		texture = null;
+		width = 0;
+		height = 0;
+		contentValid = false;
+	}
+	function resize(requestedWidth, requestedHeight) {
+		const nextWidth = snapRetainedSize(requestedWidth);
+		const nextHeight = snapRetainedSize(requestedHeight);
+		if (texture && framebuffer && width === nextWidth && height === nextHeight) return true;
+		const nextTexture = gl.createTexture();
+		const nextFramebuffer = gl.createFramebuffer();
+		if (!nextTexture || !nextFramebuffer) {
+			if (nextTexture) gl.deleteTexture(nextTexture);
+			if (nextFramebuffer) gl.deleteFramebuffer(nextFramebuffer);
+			return false;
+		}
+		gl.bindTexture(gl.TEXTURE_2D, nextTexture);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+		gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, nextWidth, nextHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+		gl.bindFramebuffer(gl.FRAMEBUFFER, nextFramebuffer);
+		gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, nextTexture, 0);
+		const complete = gl.checkFramebufferStatus(gl.FRAMEBUFFER) === gl.FRAMEBUFFER_COMPLETE;
+		gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+		if (!complete) {
+			gl.deleteFramebuffer(nextFramebuffer);
+			gl.deleteTexture(nextTexture);
+			return false;
+		}
+		discard(true);
+		texture = nextTexture;
+		framebuffer = nextFramebuffer;
+		width = nextWidth;
+		height = nextHeight;
+		contentValid = false;
+		return true;
+	}
+	return {
+		gl,
+		get width() {
+			return width;
+		},
+		get height() {
+			return height;
+		},
+		get allocated() {
+			return texture !== null && framebuffer !== null;
+		},
+		get contentValid() {
+			return contentValid;
+		},
+		resize,
+		replay(executor, list, projection, options) {
+			if (!texture || !framebuffer) return false;
+			const partial = options?.damage !== void 0 || options?.mask !== void 0;
+			if (partial && (!options?.damage || !options.mask || !isValidDamage(options.damage, width, height) || !isPartialReplayMask(options.mask, list))) return false;
+			if (partial && !contentValid) return false;
+			if (projection.framebufferWidth !== width || projection.framebufferHeight !== height) return false;
+			gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+			const execute = {
+				...options?.execute,
+				clear: true,
+				damage: options?.damage,
+				commandMask: options?.mask
+			};
+			try {
+				const replayed = executor.execute(list, projection, execute);
+				if (!replayed) {
+					contentValid = false;
+					return false;
+				}
+				if (!partial) contentValid = true;
+				return replayed;
+			} catch (error) {
+				contentValid = false;
+				throw error;
+			} finally {
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+			}
+		},
+		replayRegions(executor, list, projection, regions, options) {
+			if (!texture || !framebuffer || !contentValid || regions.length === 0 || projection.framebufferWidth !== width || projection.framebufferHeight !== height) {
+				contentValid = false;
+				return false;
+			}
+			for (const region of regions) if (!isValidDamage(region.damage, width, height) || !isPartialReplayMask(region.mask, list)) {
+				contentValid = false;
+				return false;
+			}
+			gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+			try {
+				for (const region of regions) if (!executor.execute(list, projection, {
+					...options?.execute,
+					clear: true,
+					damage: region.damage,
+					commandMask: region.mask
+				})) {
+					contentValid = false;
+					return false;
+				}
+				return true;
+			} catch (error) {
+				contentValid = false;
+				throw error;
+			} finally {
+				gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+			}
+		},
+		present() {
+			if (!texture || !framebuffer || !contentValid) return false;
+			gl.disable(gl.SCISSOR_TEST);
+			gl.bindFramebuffer(gl.READ_FRAMEBUFFER, framebuffer);
+			gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
+			gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, gl.COLOR_BUFFER_BIT, gl.NEAREST);
+			gl.bindFramebuffer(gl.READ_FRAMEBUFFER, null);
+			return true;
+		},
+		invalidateContent() {
+			contentValid = false;
+		},
+		invalidate() {
+			discard(false);
+		},
+		dispose() {
+			discard(true);
+		}
+	};
+}
+//#endregion
+//#region src/textures.ts
+function textureBytes(width, height, mipmap) {
+	if (width <= 0 || height <= 0) return 0;
+	let bytes = 0;
+	while (true) {
+		bytes += width * height * 4;
+		if (!mipmap || width === 1 && height === 1) return bytes;
+		width = Math.max(1, width >> 1);
+		height = Math.max(1, height >> 1);
+	}
+}
+/** Exact `round(channel * alpha / 255)` for all byte pairs. */
+function premultiplyByte(channel, alpha) {
+	const t = channel * alpha + 128;
+	return t + (t >> 8) >> 8;
+}
+/** Pixel dimensions of an upload source, as the source itself reports them —
+*  0 included. */
+function rawSourceSize(source) {
+	const any = source;
+	return {
+		width: any.naturalWidth || any.videoWidth || any.width || 0,
+		height: any.naturalHeight || any.videoHeight || any.height || 0
+	};
+}
+/** The same, clamped to at least 1x1 — what an entry records and what UV
+*  normalization divides by, neither of which may be zero. */
+function sourceSize(source) {
+	const raw = rawSourceSize(source);
+	return {
+		width: Math.max(1, raw.width),
+		height: Math.max(1, raw.height)
+	};
+}
+function createTextureCache(gl) {
+	const entries = /* @__PURE__ */ new Map();
+	let whiteEntry = null;
+	let premultiplyScratch = new Uint8Array(0);
+	const stats = {
+		entries: 0,
+		uploads: 0,
+		respecs: 0,
+		evictions: 0,
+		bytes: 0
+	};
+	function resolvedOptions(options = {}) {
+		const mipmap = options.mipmap ?? false;
+		return {
+			premultiplied: options.premultiplied ?? false,
+			mipmap,
+			minFilter: options.minFilter ?? (mipmap ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR),
+			magFilter: options.magFilter ?? gl.LINEAR
+		};
+	}
+	function configure(entry) {
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, entry.minFilter);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, entry.magFilter);
+	}
+	function unpackForSource(premultiplied) {
+		gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4);
+		gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+		gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !premultiplied);
+	}
+	function regenerateMipmap(entry) {
+		if (entry.mipmap && entry.storageW > 0 && entry.storageH > 0) gl.generateMipmap(gl.TEXTURE_2D);
+	}
+	function uploadSource(entry, source) {
+		const raw = rawSourceSize(source);
+		gl.bindTexture(gl.TEXTURE_2D, entry.texture);
+		unpackForSource(entry.premultiplied);
+		gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+		configure(entry);
+		entry.storageW = raw.width;
+		entry.storageH = raw.height;
+		regenerateMipmap(entry);
+		stats.uploads += 1;
+		stats.respecs += 1;
+	}
+	/** Re-upload over storage that is ALREADY the source's size. No `texImage2D`,
+	*  so no reallocation; no `configure()` either, because sampler parameters live
+	*  on the texture object and nothing here touches them. */
+	function reuploadSource(entry, source) {
+		gl.bindTexture(gl.TEXTURE_2D, entry.texture);
+		unpackForSource(entry.premultiplied);
+		gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, gl.RGBA, gl.UNSIGNED_BYTE, source);
+		regenerateMipmap(entry);
+		stats.uploads += 1;
+	}
+	/** Write a source into part of storage that is already there. Like
+	*  {@link reuploadSource} it neither allocates nor re-configures; unlike it, the
+	*  destination offset is the caller's. */
+	function uploadRegion(entry, source, x, y) {
+		gl.bindTexture(gl.TEXTURE_2D, entry.texture);
+		unpackForSource(entry.premultiplied);
+		gl.texSubImage2D(gl.TEXTURE_2D, 0, x, y, gl.RGBA, gl.UNSIGNED_BYTE, source);
+		regenerateMipmap(entry);
+		stats.uploads += 1;
+	}
+	function uploadBytes(entry, pixels, width, height, premultiplied) {
+		let data = pixels instanceof Uint8Array ? pixels : new Uint8Array(pixels.buffer, pixels.byteOffset, pixels.byteLength);
+		if (!premultiplied) {
+			if (premultiplyScratch.length < data.length) premultiplyScratch = new Uint8Array(data.length);
+			const premultipliedData = premultiplyScratch.subarray(0, data.length);
+			for (let i = 0; i < data.length; i += 4) {
+				const a = data[i + 3];
+				premultipliedData[i] = premultiplyByte(data[i], a);
+				premultipliedData[i + 1] = premultiplyByte(data[i + 1], a);
+				premultipliedData[i + 2] = premultiplyByte(data[i + 2], a);
+				premultipliedData[i + 3] = a;
+			}
+			data = premultipliedData;
+		}
+		gl.bindTexture(gl.TEXTURE_2D, entry.texture);
+		gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+		gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+		gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+		gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
+		configure(entry);
+		entry.storageW = width;
+		entry.storageH = height;
+		regenerateMipmap(entry);
+		stats.uploads += 1;
+		stats.respecs += 1;
+	}
+	function track(entry, width, height) {
+		stats.bytes += textureBytes(width, height, entry.mipmap) - textureBytes(entry.width, entry.height, entry.mipmap);
+		entry.width = width;
+		entry.height = height;
+	}
+	function makeEntry(width, height, options = {}) {
+		const resolved = resolvedOptions(options);
+		const entry = {
+			texture: gl.createTexture(),
+			width: 0,
+			height: 0,
+			refs: 0,
+			storageW: -1,
+			storageH: -1,
+			mipmap: resolved.mipmap,
+			minFilter: resolved.minFilter,
+			magFilter: resolved.magFilter,
+			premultiplied: resolved.premultiplied
+		};
+		track(entry, width, height);
+		stats.entries += 1;
+		return entry;
+	}
+	return {
+		stats,
+		white() {
+			if (whiteEntry) return whiteEntry;
+			const entry = makeEntry(1, 1);
+			uploadBytes(entry, new Uint8Array([
+				255,
+				255,
+				255,
+				255
+			]), 1, 1, true);
+			entry.refs = 1;
+			whiteEntry = entry;
+			return entry;
+		},
+		peek(key) {
+			return entries.get(key);
+		},
+		acquire(key, source, options) {
+			const existing = entries.get(key);
+			if (existing) {
+				existing.refs += 1;
+				return existing;
+			}
+			const { width, height } = sourceSize(source);
+			const entry = makeEntry(width, height, options);
+			uploadSource(entry, source);
+			entry.refs = 1;
+			entries.set(key, entry);
+			return entry;
+		},
+		acquireBytes(key, pixels, width, height, options) {
+			const existing = entries.get(key);
+			if (existing) {
+				existing.refs += 1;
+				return existing;
+			}
+			const entry = makeEntry(Math.max(1, width), Math.max(1, height), options);
+			uploadBytes(entry, pixels, entry.width, entry.height, options?.premultiplied ?? false);
+			entry.refs = 1;
+			entries.set(key, entry);
+			return entry;
+		},
+		retain(key) {
+			const entry = entries.get(key);
+			if (!entry) throw new Error(`texture cache: retain of unknown key "${key}"`);
+			entry.refs += 1;
+			return entry;
+		},
+		release(key) {
+			const entry = entries.get(key);
+			if (!entry) return;
+			entry.refs -= 1;
+			if (entry.refs > 0) return;
+			gl.deleteTexture(entry.texture);
+			entries.delete(key);
+			stats.entries -= 1;
+			stats.evictions += 1;
+			stats.bytes -= textureBytes(entry.width, entry.height, entry.mipmap);
+		},
+		update(key, source) {
+			const raw = rawSourceSize(source);
+			const entry = entries.get(key);
+			if (entry && entry.storageW === raw.width && entry.storageH === raw.height) {
+				reuploadSource(entry, source);
+				return entry;
+			}
+			const width = Math.max(1, raw.width);
+			const height = Math.max(1, raw.height);
+			if (!entry) {
+				const created = makeEntry(width, height);
+				created.refs = 1;
+				entries.set(key, created);
+				uploadSource(created, source);
+				return created;
+			}
+			track(entry, width, height);
+			uploadSource(entry, source);
+			return entry;
+		},
+		updateRegion(key, source, x, y) {
+			const entry = entries.get(key);
+			if (!entry || entry.mipmap) return null;
+			const raw = rawSourceSize(source);
+			if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0 || raw.width <= 0 || raw.height <= 0 || x + raw.width > entry.storageW || y + raw.height > entry.storageH) return null;
+			uploadRegion(entry, source, x, y);
+			return entry;
+		},
+		reset() {
+			entries.clear();
+			whiteEntry = null;
+			stats.entries = 0;
+			stats.bytes = 0;
+		},
+		dispose() {
+			for (const entry of entries.values()) gl.deleteTexture(entry.texture);
+			if (whiteEntry) gl.deleteTexture(whiteEntry.texture);
+			entries.clear();
+			whiteEntry = null;
+			stats.entries = 0;
+			stats.bytes = 0;
+		}
+	};
+}
+//#endregion
+export { BLEND_ADD, BLEND_MIX, BLEND_MUL, BLEND_SUB, COLOR_MATRIX_FLOATS, DEFAULT_COLOR_MATRIX_SLOTS, DRAW_CLIP_POP, DRAW_CLIP_PUSH, DRAW_COMMAND_NAMES, DRAW_EXTERNAL_EFFECT, DRAW_GLYPHS, DRAW_NINE_PATCH, DRAW_POLYLINE, DRAW_QUAD, DRAW_SCREEN_EFFECT, DRAW_TEXTURED_MESH, FLIP_H, FLIP_V, IDENTITY_COLOR_MATRIX, INSTANCE_COLOR_OFFSET, INSTANCE_CORNERS_OFFSET, INSTANCE_FLOATS, INSTANCE_SLOTS_OFFSET, INSTANCE_UV_OFFSET, MAX_TEXTURE_SLOTS, POLYLINE_QUAD_FLOATS, RETAINED_DAMAGE_TILE_SIZE, RETAINED_MAX_DAMAGE_COVERAGE, RETAINED_MAX_REPLAY_FRACTION, STAGE_CONTEXT_ATTRIBUTES, applyColorMatrix01, blendStateFor, clamp01, colorMatricesEqual, commandDamageBounds, compileDrawList, createCanvasExecutor, createCanvasStage, createClipRectView, createClipStack, createCompiledReplayMask, createDamageRect, createDamageTiles, createDrawList, createDrawListFragment, createDrawListPatchView, createGlyphsView, createHeadlessGodotParticleDirectEffect, createHeadlessScreenEffectCommand, createNinePatchBand, createNinePatchBands, createNinePatchView, createPolylineView, createQuadBatcher, createQuadInstance, createQuadView, createReplayMask, createReplayMaskScratch, createRetainedSurface, createRgba, createScissorBox, createTextureCache, createTexturedMeshView, damageIntersects, expandNinePatch, expandPolyline, isAxisAligned, isDamageEmpty, isIdentityColorMatrix, isPartialReplayMask, maxPartialReplayCommands, modulatePremultiplied, outsetDamageRect, polylineQuadCapacity, premultiply, setViewColorMatrix, shadeQuadPixel, snapRetainedSize, transformDamageRect, unionDamageRect, unpremultiply };
+
+//# sourceMappingURL=index.js.map