@godot-scene-web/canvas-effects 0.1.0

package/dist/webgl.mjs

@@ -0,0 +1,2298 @@
+import { INSTANCE_STRIDE, InstanceBuffer, createParticleState, normalizeParticleRenderConfig, packParticleInstances, preprocessParticles, simulateParticles } from "@godot-scene-web/effects/particles";
+import { UnsupportedShaderError, transpileGodotShader } from "@godot-scene-web/effects/shaders";
+//#region src/particle-webgl.ts
+function compileProgram$2(gl, vertexSource, fragmentSource) {
+	const vertex = gl.createShader(gl.VERTEX_SHADER);
+	const fragment = gl.createShader(gl.FRAGMENT_SHADER);
+	if (!vertex || !fragment) {
+		if (vertex) gl.deleteShader(vertex);
+		if (fragment) gl.deleteShader(fragment);
+		return null;
+	}
+	gl.shaderSource(vertex, vertexSource);
+	gl.shaderSource(fragment, fragmentSource);
+	gl.compileShader(vertex);
+	gl.compileShader(fragment);
+	if (!gl.getShaderParameter(vertex, gl.COMPILE_STATUS) || !gl.getShaderParameter(fragment, gl.COMPILE_STATUS)) {
+		gl.deleteShader(vertex);
+		gl.deleteShader(fragment);
+		return null;
+	}
+	const program = gl.createProgram();
+	if (!program) {
+		gl.deleteShader(vertex);
+		gl.deleteShader(fragment);
+		return null;
+	}
+	gl.attachShader(program, vertex);
+	gl.attachShader(program, fragment);
+	gl.linkProgram(program);
+	gl.deleteShader(vertex);
+	gl.deleteShader(fragment);
+	if (gl.getProgramParameter(program, gl.LINK_STATUS)) return program;
+	gl.deleteProgram(program);
+	return null;
+}
+/** GPU residency is deliberately external to the portable instance data. */
+const instanceAllocations = /* @__PURE__ */ new WeakMap();
+function allocationsFor(gl) {
+	let allocations = instanceAllocations.get(gl);
+	if (!allocations) {
+		allocations = /* @__PURE__ */ new WeakMap();
+		instanceAllocations.set(gl, allocations);
+	}
+	return allocations;
+}
+function uploadInstances(gl, instances) {
+	const allocations = allocationsFor(gl);
+	let allocation = allocations.get(instances);
+	if (!allocation) {
+		const buffer = gl.createBuffer();
+		if (!buffer) return null;
+		allocation = {
+			buffer,
+			bytes: 0
+		};
+		allocations.set(instances, allocation);
+	}
+	gl.bindBuffer(gl.ARRAY_BUFFER, allocation.buffer);
+	if (instances.data.byteLength > allocation.bytes) {
+		gl.bufferData(gl.ARRAY_BUFFER, instances.data, gl.DYNAMIC_DRAW);
+		allocation.bytes = instances.data.byteLength;
+	} else gl.bufferSubData(gl.ARRAY_BUFFER, 0, instances.data, 0, instances.count * INSTANCE_STRIDE);
+	return allocation.buffer;
+}
+/** Release one portable buffer's WebGL allocation on its owning borrowed context. */
+function disposeParticleInstanceBuffer(gl, instances) {
+	const allocations = instanceAllocations.get(gl);
+	const allocation = allocations?.get(instances);
+	if (!allocation) return;
+	gl.deleteBuffer(allocation.buffer);
+	allocations?.delete(instances);
+}
+/** Context-loss path: forget driver names without issuing GL commands. */
+function invalidateParticleInstanceBuffer(gl, instances) {
+	instanceAllocations.get(gl)?.delete(instances);
+}
+const VERTEX_SRC = `#version 300 es
+layout(location = 0) in vec2 a_corner;   // unit quad corner, [-0.5, 0.5]
+layout(location = 1) in vec2 a_center;   // particle center, device px
+layout(location = 2) in vec2 a_scale;    // sprite size, device px (base * scale)
+layout(location = 3) in float a_rotation;
+layout(location = 4) in vec4 a_color;
+layout(location = 5) in float a_frame;
+uniform vec2 u_viewport;                  // canvas size, device px
+uniform float u_hframes;
+uniform float u_vframes;
+out vec2 v_uv;
+out vec2 v_quad;
+out vec2 v_cell;
+out vec4 v_color;
+void main() {
+  float c = cos(a_rotation);
+  float s = sin(a_rotation);
+  vec2 rotated = vec2(a_corner.x * c - a_corner.y * s, a_corner.x * s + a_corner.y * c);
+  vec2 px = a_center + rotated * a_scale;
+  vec2 clip = (px / u_viewport) * 2.0 - 1.0;
+  clip.y = -clip.y;                       // canvas Y-down -> clip Y-up
+  gl_Position = vec4(clip, 0.0, 1.0);
+  vec2 uv01 = a_corner + 0.5;             // 0..1 across the SPRITE quad
+  vec2 cell = vec2(mod(a_frame, u_hframes), floor(a_frame / u_hframes));
+  v_uv = (cell + uv01) / vec2(u_hframes, u_vframes);
+  // The flipbook cell INDEX, so a fragment that re-derives its own sprite-local UV (the polar remap) can map
+  // it back into the same cell instead of over the whole sheet.
+  v_cell = cell;
+  // Quad-local 0..1, INDEPENDENT of the flipbook grid: the untextured dot is drawn from this.
+  // Deriving it from the atlas-mapped v_uv put the dot's center at the SHEET's center, so any
+  // grid > 1x1 left the fallback dot off-center and clipped to a sliver of one cell.
+  v_quad = uv01;
+  v_color = a_color;
+}`;
+const FRAGMENT_SRC = `#version 300 es
+precision mediump float;
+uniform sampler2D u_texture;
+uniform sampler2D u_lutTex;   // per-TEXEL color LUT, 1px tall (see u_lut)
+uniform sampler2D u_maskTex;  // quad-shaped coverage mask, unit 2 (see u_mask)
+// The flipbook grid, ALSO declared in the vertex stage: a uniform shared across stages must match in type AND
+// PRECISION, and the vertex stage's float default is highp while this one's is mediump — declaring these as a
+// plain float here fails to LINK (silently: no particle program, so no particle canvases at all).
+uniform highp float u_hframes;
+uniform highp float u_vframes;
+uniform int u_textured;
+uniform int u_lut;        // 1 = recolor through the LUT, indexed by the source RED channel
+uniform int u_additive;   // 1 = additive: emit the particle's LIGHT (Godot ADD: src.rgb * src.a)
+uniform int u_alphaFromRed;  // 1 = coverage comes from the source RED channel, not its alpha
+uniform int u_erode;         // 1 = apply the constant-erosion smoothstep below
+uniform vec2 u_erodeFactors; // (threshold, softness) for that smoothstep
+uniform int u_mask;          // 1 = multiply coverage by u_maskTex's red, sampled over the QUAD
+uniform int u_uvPolar;       // 1 = sample the sheet through Godot's polar_coordinates remap
+in vec2 v_uv;
+in vec2 v_quad;
+in vec2 v_cell;
+in vec4 v_color;
+out vec4 fragColor;
+void main() {
+  vec2 uv = v_uv;
+  if (u_uvPolar == 1) {
+    // Godot polar_coordinates(UV, vec2(0.5), 1, 1) (shaders/vfx/_util/polar_coordinates.gdshaderinc):
+    // x = radius from the sprite center (0..1.41 at the corners), y = the angle mapped to 0..1, both wrapped.
+    // A radial sheet (common_ring_polar_a) is a RING only through this; sampled flat it is a vertical BAR.
+    vec2 dir = v_quad - 0.5;
+    float radius = length(dir) * 2.0;
+    float angle = atan(dir.y, dir.x) * (1.0 / (3.1416 * 2.0));
+    uv = (v_cell + mod(vec2(radius, angle), 1.0)) / vec2(u_hframes, u_vframes);
+  }
+  vec4 tex;
+  if (u_textured == 1) {
+    tex = texture(u_texture, uv);
+  } else {
+    // Soft round dot when the system has no texture — measured across the QUAD, not the
+    // atlas-mapped UV, so it stays centered whatever the (meaningless, textureless) grid is.
+    float r = length(v_quad - 0.5) * 2.0;
+    tex = vec4(1.0, 1.0, 1.0, 1.0 - smoothstep(0.7, 1.0, r));
+  }
+  // COVERAGE — taken PRE-LUT, because the LUT is a color lookup INDEXED by that same red channel: reading it
+  // afterwards would sample the LUT's own (usually white) output instead of the sheet's shape. STS2's
+  // grayscale VFX sheets are alpha-less PNGs, so tex.a is 1.0 everywhere and the alpha branch draws a SQUARE.
+  float coverage = u_alphaFromRed == 1 ? tex.r : tex.a;
+  if (u_lut == 1) {
+    // Godot's VFX particle-shader family: COLOR = vec4(texture(lut, texture_color.rr).rgb,
+    // alpha) * vertex_color. The sprite sheet is a single-channel MASK, so its own RGB is
+    // meaningless (it reads as a red/orange block); the LUT holds the real colors. Sampled
+    // AFTER the texture/dot resolve so both branches are recolored, and the source ALPHA is
+    // preserved untouched — only RGB comes from the LUT.
+    tex = vec4(texture(u_lutTex, vec2(tex.r, 0.5)).rgb, tex.a);
+  }
+  if (u_erode == 1) {
+    // Godot erosion_from_factors(vec2(threshold, softness), coverage) — a CONSTANT erosion curve, i.e. the
+    // threshold does not sweep over the particle's life (see ParticleSpecConfig.alphaErode).
+    coverage = smoothstep(u_erodeFactors.x, u_erodeFactors.x + u_erodeFactors.y, coverage);
+  }
+  if (u_mask == 1) {
+    // Godot's mask sampler reads the sprite's own UV, NOT the flipbook cell — it shapes the whole quad.
+    coverage *= texture(u_maskTex, v_quad).r;
+  }
+  tex.a = coverage;
+  vec4 col = tex * v_color;
+  if (u_additive == 1) {
+    // Additive sprites contribute light = color x alpha (Godot BLEND_MODE_ADD adds
+    // src.rgb * src.a to the framebuffer, nothing where light is 0 -- so an opaque-black
+    // glow background or an alpha-shaped sprite's transparent area both add nothing).
+    // Emit that light RAW and SUM it across particles (blendFunc ONE, ONE into the
+    // accumulator FBO); the resolve pass then derives the per-pixel TOTAL's peak-channel
+    // coverage ONCE and presents the pair premultiplied. Normalizing per PARTICLE here
+    // (the old path) amplified every faint texel to full brightness and let overlaps
+    // clamp to white while stacking coverage -- a subtle 5-particle fog rendered as an
+    // opaque white haze wall.
+    fragColor = vec4(col.rgb * tex.a * v_color.a, 0.0);
+  } else {
+    // PREMULTIPLIED, under blendFactorsFor(0)'s ONE / ONE_MINUS_SRC_ALPHA -- the shared canvas
+    // declares premultipliedAlpha: true (../webgl/shared-gl.ts) and this is that contract.
+    // Algebraically identical to emitting straight col under SRC_ALPHA / ONE_MINUS_SRC_ALPHA
+    // (both land col.rgb*col.a + dst*(1-col.a)), and written THIS way so the fragment and the
+    // canvas state the same thing -- the same pairing render-webgpu.ts's fs_particles uses, since
+    // a GPUCanvasContext has no straight-alpha mode to differ with.
+    fragColor = vec4(col.rgb * col.a, col.a);
+  }
+}`;
+const RESOLVE_VERTEX_SRC = `#version 300 es
+layout(location = 0) in vec2 a_pos;   // full-screen clip-space quad (shared-gl quad buffer)
+void main() {
+  gl_Position = vec4(a_pos, 0.0, 1.0);
+}`;
+const RESOLVE_FRAGMENT_SRC = `#version 300 es
+precision mediump float;
+uniform sampler2D u_accum;
+out vec4 fragColor;
+void main() {
+  // Same viewport rect + origin as the accumulate pass, so fragment coords match texels.
+  vec3 light = texelFetch(u_accum, ivec2(gl_FragCoord.xy), 0).rgb;
+  float cov = max(max(light.r, light.g), light.b);
+  fragColor = vec4(light, cov);
+}`;
+const cached = /* @__PURE__ */ new WeakMap();
+function getParticleProgram(gl) {
+	const existing = cached.get(gl);
+	if (existing) {
+		existing.pinned = true;
+		return existing.program;
+	}
+	const program = compileProgram$2(gl, VERTEX_SRC, FRAGMENT_SRC);
+	const resolveProgram = compileProgram$2(gl, RESOLVE_VERTEX_SRC, RESOLVE_FRAGMENT_SRC);
+	if (!program || !resolveProgram) {
+		if (program) gl.deleteProgram(program);
+		if (resolveProgram) gl.deleteProgram(resolveProgram);
+		cached.set(gl, {
+			program: null,
+			refs: 0,
+			pinned: true
+		});
+		return null;
+	}
+	const cornerBuffer = gl.createBuffer();
+	if (!cornerBuffer) {
+		gl.deleteProgram(program);
+		gl.deleteProgram(resolveProgram);
+		cached.set(gl, {
+			program: null,
+			refs: 0,
+			pinned: true
+		});
+		return null;
+	}
+	gl.bindBuffer(gl.ARRAY_BUFFER, cornerBuffer);
+	gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+		-.5,
+		-.5,
+		.5,
+		-.5,
+		-.5,
+		.5,
+		.5,
+		.5
+	]), gl.STATIC_DRAW);
+	const result = {
+		program,
+		cornerBuffer,
+		uViewport: gl.getUniformLocation(program, "u_viewport"),
+		uHframes: gl.getUniformLocation(program, "u_hframes"),
+		uVframes: gl.getUniformLocation(program, "u_vframes"),
+		uTexture: gl.getUniformLocation(program, "u_texture"),
+		uLutTex: gl.getUniformLocation(program, "u_lutTex"),
+		uMaskTex: gl.getUniformLocation(program, "u_maskTex"),
+		uTextured: gl.getUniformLocation(program, "u_textured"),
+		uLut: gl.getUniformLocation(program, "u_lut"),
+		uAdditive: gl.getUniformLocation(program, "u_additive"),
+		uAlphaFromRed: gl.getUniformLocation(program, "u_alphaFromRed"),
+		uErode: gl.getUniformLocation(program, "u_erode"),
+		uErodeFactors: gl.getUniformLocation(program, "u_erodeFactors"),
+		uMask: gl.getUniformLocation(program, "u_mask"),
+		uUvPolar: gl.getUniformLocation(program, "u_uvPolar"),
+		resolveProgram,
+		uAccum: gl.getUniformLocation(resolveProgram, "u_accum"),
+		accum: null
+	};
+	cached.set(gl, {
+		program: result,
+		refs: 0,
+		pinned: true
+	});
+	return result;
+}
+/** Acquire a shared program lease for a producer that will later release it. */
+function acquireParticleProgram(gl) {
+	const entry = cached.get(gl);
+	if (entry) {
+		if (!entry.program) return null;
+		entry.refs += 1;
+		return entry.program;
+	}
+	const program = getParticleProgram(gl);
+	const created = cached.get(gl);
+	created.pinned = false;
+	created.refs = 1;
+	return program;
+}
+function destroyCachedProgram(gl, program) {
+	gl.deleteProgram(program.program);
+	gl.deleteProgram(program.resolveProgram);
+	gl.deleteBuffer(program.cornerBuffer);
+	if (program.accum) {
+		gl.deleteFramebuffer(program.accum.fbo);
+		gl.deleteTexture(program.accum.texture);
+	}
+}
+/** Release a producer lease. Pinned HTML consumers keep their shared program alive. */
+function releaseParticleProgram(gl, contextLost = false) {
+	const entry = cached.get(gl);
+	if (!entry) return;
+	entry.refs = Math.max(0, entry.refs - 1);
+	if (entry.refs !== 0 || entry.pinned) return;
+	cached.delete(gl);
+	if (entry.program && !contextLost) destroyCachedProgram(gl, entry.program);
+}
+function ensureAccumTarget(gl, program, w, h) {
+	let accum = program.accum;
+	if (!accum) {
+		const fbo = gl.createFramebuffer();
+		const texture = gl.createTexture();
+		if (!fbo || !texture) {
+			if (fbo) gl.deleteFramebuffer(fbo);
+			if (texture) gl.deleteTexture(texture);
+			return null;
+		}
+		accum = {
+			fbo,
+			texture,
+			width: 0,
+			height: 0
+		};
+		program.accum = accum;
+	}
+	if (accum.width < w || accum.height < h) {
+		const width = Math.max(accum.width, w);
+		const height = Math.max(accum.height, h);
+		gl.bindTexture(gl.TEXTURE_2D, accum.texture);
+		gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+		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.NEAREST);
+		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+		gl.bindFramebuffer(gl.FRAMEBUFFER, accum.fbo);
+		gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, accum.texture, 0);
+		if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !== gl.FRAMEBUFFER_COMPLETE) {
+			gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+			gl.deleteFramebuffer(accum.fbo);
+			gl.deleteTexture(accum.texture);
+			program.accum = null;
+			return null;
+		}
+		gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+		accum.width = width;
+		accum.height = height;
+	}
+	return accum;
+}
+/** Allocate additive accumulation storage before a caller mutates simulation state. */
+function prepareParticleDraw(gl, program, opts) {
+	if (opts.blendMode !== 1) return true;
+	return ensureAccumTarget(gl, program, opts.targetW ?? opts.viewportW, opts.targetH ?? opts.viewportH) !== null;
+}
+function blendFactorsFor(blendMode) {
+	if (blendMode === 1) return [
+		"ONE",
+		"ONE",
+		"ONE",
+		"ONE"
+	];
+	return [
+		"ONE",
+		"ONE_MINUS_SRC_ALPHA",
+		"ONE",
+		"ONE_MINUS_SRC_ALPHA"
+	];
+}
+const INSTANCE_ATTRS = [
+	{
+		loc: 1,
+		size: 2,
+		offset: 0
+	},
+	{
+		loc: 2,
+		size: 2,
+		offset: 2
+	},
+	{
+		loc: 3,
+		size: 1,
+		offset: 4
+	},
+	{
+		loc: 4,
+		size: 4,
+		offset: 5
+	},
+	{
+		loc: 5,
+		size: 1,
+		offset: 9
+	}
+];
+function drawParticles(sharedGl, program, buffer, opts) {
+	const { gl } = sharedGl;
+	if (buffer.count <= 0) return true;
+	const instanceGpuBuffer = uploadInstances(gl, buffer);
+	if (!instanceGpuBuffer) return false;
+	const additive = opts.blendMode === 1;
+	const targetW = opts.targetW ?? opts.viewportW;
+	const targetH = opts.targetH ?? opts.viewportH;
+	if (additive) {
+		if (!prepareParticleDraw(gl, program, opts)) return false;
+		const accum = program.accum;
+		gl.bindFramebuffer(gl.FRAMEBUFFER, accum.fbo);
+		gl.viewport(0, 0, targetW, targetH);
+		gl.clearColor(0, 0, 0, 0);
+		gl.clear(gl.COLOR_BUFFER_BIT);
+	}
+	gl.useProgram(program.program);
+	gl.bindBuffer(gl.ARRAY_BUFFER, program.cornerBuffer);
+	gl.enableVertexAttribArray(0);
+	gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+	gl.vertexAttribDivisor(0, 0);
+	gl.bindBuffer(gl.ARRAY_BUFFER, instanceGpuBuffer);
+	const strideBytes = INSTANCE_STRIDE * 4;
+	for (let index = 0; index < INSTANCE_ATTRS.length; index += 1) {
+		const attr = INSTANCE_ATTRS[index];
+		gl.enableVertexAttribArray(attr.loc);
+		gl.vertexAttribPointer(attr.loc, attr.size, gl.FLOAT, false, strideBytes, attr.offset * 4);
+		gl.vertexAttribDivisor(attr.loc, 1);
+	}
+	if (program.uViewport) gl.uniform2f(program.uViewport, opts.viewportW, opts.viewportH);
+	const textured = Boolean(opts.textured && opts.texture);
+	const hframes = textured ? Math.max(1, opts.hframes) : 1;
+	const vframes = textured ? Math.max(1, opts.vframes) : 1;
+	if (program.uHframes) gl.uniform1f(program.uHframes, hframes);
+	if (program.uVframes) gl.uniform1f(program.uVframes, vframes);
+	if (program.uTextured) gl.uniform1i(program.uTextured, textured ? 1 : 0);
+	if (program.uAdditive) gl.uniform1i(program.uAdditive, additive ? 1 : 0);
+	if (program.uAlphaFromRed) gl.uniform1i(program.uAlphaFromRed, opts.alphaFromRed ? 1 : 0);
+	const erode = opts.erode ?? null;
+	if (program.uErode) gl.uniform1i(program.uErode, erode ? 1 : 0);
+	if (program.uErodeFactors) gl.uniform2f(program.uErodeFactors, erode ? erode.threshold : 0, erode ? erode.softness : 0);
+	if (program.uUvPolar) gl.uniform1i(program.uUvPolar, opts.uvPolar ? 1 : 0);
+	gl.activeTexture(gl.TEXTURE0);
+	if (opts.texture && program.uTexture) {
+		gl.bindTexture(gl.TEXTURE_2D, opts.texture);
+		gl.uniform1i(program.uTexture, 0);
+	} else gl.bindTexture(gl.TEXTURE_2D, null);
+	const lut = opts.lutTexture ?? null;
+	gl.activeTexture(gl.TEXTURE1);
+	gl.bindTexture(gl.TEXTURE_2D, lut);
+	if (program.uLutTex) gl.uniform1i(program.uLutTex, 1);
+	if (program.uLut) gl.uniform1i(program.uLut, lut ? 1 : 0);
+	const mask = opts.maskTexture ?? null;
+	gl.activeTexture(gl.TEXTURE2);
+	gl.bindTexture(gl.TEXTURE_2D, mask);
+	if (program.uMaskTex) gl.uniform1i(program.uMaskTex, 2);
+	if (program.uMask) gl.uniform1i(program.uMask, mask ? 1 : 0);
+	gl.activeTexture(gl.TEXTURE0);
+	gl.enable(gl.BLEND);
+	gl.blendEquation(gl.FUNC_ADD);
+	if (additive) gl.blendFuncSeparate(gl.ONE, gl.ONE, gl.ONE, gl.ONE);
+	else gl.blendFuncSeparate(gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+	gl.disable(gl.DEPTH_TEST);
+	gl.drawArraysInstanced(gl.TRIANGLE_STRIP, 0, 4, buffer.count);
+	for (let index = 0; index < INSTANCE_ATTRS.length; index += 1) {
+		const attr = INSTANCE_ATTRS[index];
+		gl.vertexAttribDivisor(attr.loc, 0);
+		gl.disableVertexAttribArray(attr.loc);
+	}
+	if (additive && program.accum) {
+		gl.bindFramebuffer(gl.FRAMEBUFFER, opts.targetFramebuffer ?? null);
+		gl.viewport(0, 0, targetW, targetH);
+		gl.useProgram(program.resolveProgram);
+		gl.bindBuffer(gl.ARRAY_BUFFER, sharedGl.quad);
+		gl.enableVertexAttribArray(0);
+		gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+		gl.vertexAttribDivisor(0, 0);
+		gl.activeTexture(gl.TEXTURE0);
+		gl.bindTexture(gl.TEXTURE_2D, program.accum.texture);
+		if (program.uAccum) gl.uniform1i(program.uAccum, 0);
+		if (opts.additiveResolveIntoExisting) {
+			gl.enable(gl.BLEND);
+			gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD);
+			gl.blendFuncSeparate(gl.ONE, gl.ONE, gl.ONE, gl.ONE);
+		} else gl.disable(gl.BLEND);
+		gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+	}
+	return true;
+}
+//#endregion
+//#region src/shader-webgl.ts
+/** Allocate the shared clip-space quad used by full-surface shader draws. */
+function createWebglFullscreenQuad(gl) {
+	const quad = gl.createBuffer();
+	if (!quad) return null;
+	gl.bindBuffer(gl.ARRAY_BUFFER, quad);
+	gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+		-1,
+		-1,
+		1,
+		-1,
+		-1,
+		1,
+		1,
+		1
+	]), gl.STATIC_DRAW);
+	return quad;
+}
+function createWebglTexture(gl) {
+	return gl.createTexture();
+}
+function setTextureSampling(gl, repeat, nearest = false) {
+	const wrap = repeat ? gl.REPEAT : gl.CLAMP_TO_EDGE;
+	const filter = nearest ? gl.NEAREST : gl.LINEAR;
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrap);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrap);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
+	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
+}
+/** Upload bytes, an image, or a canvas with Godot's top-left UV convention. */
+function uploadWebglTexture(gl, texture, source, width, height, opts = {}) {
+	gl.bindTexture(gl.TEXTURE_2D, texture);
+	gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+	gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+	if (source instanceof Uint8Array) gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width ?? 1, height ?? 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, source);
+	else gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+	setTextureSampling(gl, opts.repeat === true, opts.nearest === true);
+}
+function createWebglPlaceholderTexture(gl, repeat) {
+	const texture = createWebglTexture(gl);
+	if (texture) uploadWebglTexture(gl, texture, new Uint8Array([
+		0,
+		0,
+		0,
+		0
+	]), 1, 1, { repeat });
+	return texture;
+}
+const COMPILE_POLL_MS = 1;
+const COMPILE_MAX_WAIT_MS = 3e3;
+const parallelCompileExts = /* @__PURE__ */ new WeakMap();
+function parallelCompileExt(gl) {
+	const cached = parallelCompileExts.get(gl);
+	if (cached !== void 0) return cached;
+	let ext = null;
+	try {
+		const found = gl.getExtension("KHR_parallel_shader_compile");
+		ext = found && typeof found.COMPLETION_STATUS_KHR === "number" ? { COMPLETION_STATUS_KHR: found.COMPLETION_STATUS_KHR } : null;
+	} catch {
+		ext = null;
+	}
+	parallelCompileExts.set(gl, ext);
+	return ext;
+}
+const FAILED_PROGRAM = {
+	ready: () => true,
+	finish: () => null
+};
+/** Kick compilation and linking without synchronously asking the driver for status. */
+function startProgram(gl, vertexSrc, fragmentSrc, beforeLink) {
+	const vs = startShader(gl, gl.VERTEX_SHADER, vertexSrc);
+	const fs = startShader(gl, gl.FRAGMENT_SHADER, fragmentSrc);
+	if (!vs || !fs) {
+		if (vs) gl.deleteShader(vs);
+		if (fs) gl.deleteShader(fs);
+		return FAILED_PROGRAM;
+	}
+	const program = gl.createProgram();
+	if (!program) {
+		gl.deleteShader(vs);
+		gl.deleteShader(fs);
+		return FAILED_PROGRAM;
+	}
+	gl.attachShader(program, vs);
+	gl.attachShader(program, fs);
+	beforeLink?.(program);
+	gl.linkProgram(program);
+	const ext = parallelCompileExt(gl);
+	let completed = false;
+	return {
+		ready() {
+			if (completed || !ext) return true;
+			completed = gl.getProgramParameter(program, ext.COMPLETION_STATUS_KHR) === true;
+			return completed;
+		},
+		finish() {
+			if (gl.getProgramParameter(program, gl.LINK_STATUS)) {
+				gl.deleteShader(vs);
+				gl.deleteShader(fs);
+				return program;
+			}
+			let compileFailed = false;
+			for (const shader of [vs, fs]) {
+				if (gl.getShaderParameter(shader, gl.COMPILE_STATUS)) continue;
+				compileFailed = true;
+				console.warn("[gsw webgl] shader compile failed:", gl.getShaderInfoLog(shader));
+			}
+			if (!compileFailed) console.warn("[gsw webgl] program link failed:", gl.getProgramInfoLog(program));
+			gl.deleteShader(vs);
+			gl.deleteShader(fs);
+			gl.deleteProgram(program);
+			return null;
+		}
+	};
+}
+/** Compile and link synchronously for callers that cannot yield. */
+function compileProgram(gl, vertexSrc, fragmentSrc, beforeLink) {
+	return startProgram(gl, vertexSrc, fragmentSrc, beforeLink).finish();
+}
+const compileWaiters = /* @__PURE__ */ new Set();
+let compilePollTimer = null;
+function performanceNow() {
+	return typeof performance !== "undefined" && performance.now ? performance.now() : 0;
+}
+function pollCompiles() {
+	compilePollTimer = null;
+	const now = performanceNow();
+	for (const waiter of [...compileWaiters]) {
+		if (!waiter.pending.ready() && now < waiter.deadline) continue;
+		compileWaiters.delete(waiter);
+		waiter.wake();
+	}
+	if (compileWaiters.size > 0) scheduleCompilePoll();
+}
+function scheduleCompilePoll() {
+	if (compilePollTimer === null) compilePollTimer = setTimeout(pollCompiles, COMPILE_POLL_MS);
+}
+/** Finish when the parallel-compile extension says its status query will not block. */
+async function compileProgramAsync(gl, vertexSrc, fragmentSrc, beforeLink) {
+	const pending = startProgram(gl, vertexSrc, fragmentSrc, beforeLink);
+	if (!pending.ready() && typeof setTimeout === "function") await new Promise((wake) => {
+		compileWaiters.add({
+			pending,
+			deadline: performanceNow() + COMPILE_MAX_WAIT_MS,
+			wake
+		});
+		scheduleCompilePoll();
+	});
+	return pending.finish();
+}
+/** Execute one Godot shader frame in a borrowed context; no DOM, scheduling, or capture work. */
+function drawGodotWebglShaderFrame(gl, frame) {
+	const loc = (name) => frame.locations.get(name) ?? null;
+	const one = (name, value) => {
+		const l = loc(name);
+		if (l) gl.uniform1f(l, value);
+	};
+	const two = (name, value) => {
+		const l = loc(name);
+		if (l) gl.uniform2f(l, value[0] ?? 0, value[1] ?? 0);
+	};
+	const four = (name, value) => {
+		const l = loc(name);
+		if (l) gl.uniform4f(l, value[0] ?? 0, value[1] ?? 0, value[2] ?? 0, value[3] ?? 0);
+	};
+	gl.viewport(0, 0, frame.width, frame.height);
+	gl.disable(gl.SCISSOR_TEST);
+	gl.disable(gl.DEPTH_TEST);
+	gl.disable(gl.BLEND);
+	gl.useProgram(frame.program);
+	gl.bindBuffer(gl.ARRAY_BUFFER, frame.quad);
+	gl.enableVertexAttribArray(0);
+	gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+	gl.activeTexture(gl.TEXTURE0);
+	gl.bindTexture(gl.TEXTURE_2D, frame.texture);
+	{
+		const l = loc("TEXTURE");
+		if (l) gl.uniform1i(l, 0);
+	}
+	if (frame.time !== void 0) one("TIME", frame.time);
+	if (frame.texturePixelSize) two("TEXTURE_PIXEL_SIZE", frame.texturePixelSize);
+	four("MODULATE", frame.modulate);
+	two("_godot_uv_fit", frame.uvFit);
+	four("_godot_uv_window", frame.uvWindow);
+	if (frame.screenOrigin) two("_godot_screen_origin", frame.screenOrigin);
+	if (frame.screenSize) two("_godot_screen_size", frame.screenSize);
+	if (frame.screenTexture) {
+		const unit = frame.screenTextureUnit ?? 1;
+		gl.activeTexture(gl.TEXTURE0 + unit);
+		gl.bindTexture(gl.TEXTURE_2D, frame.screenTexture);
+		const l = loc("SCREEN_TEXTURE");
+		if (l) gl.uniform1i(l, unit);
+	}
+	if (frame.screenPixelSize) two("SCREEN_PIXEL_SIZE", frame.screenPixelSize);
+	for (const sampler of frame.samplers) {
+		gl.activeTexture(gl.TEXTURE0 + sampler.unit);
+		gl.bindTexture(gl.TEXTURE_2D, sampler.texture);
+		const l = loc(sampler.name);
+		if (l) gl.uniform1i(l, sampler.unit);
+	}
+	for (const uniform of frame.uniforms) uploadGodotShaderUniform(gl, loc(uniform.name), uniform, frame.params[uniform.name], frame.paramKinds[uniform.name]);
+	gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+}
+/** Exact Godot scalar/vector/array upload rules. Callers retain their own binding model. */
+function uploadGodotShaderUniform(gl, location, uniform, raw, paramKind) {
+	if (!location) return;
+	const value = raw ?? uniform.default;
+	const values = Array.isArray(value) ? [...value] : [];
+	const pad = (length) => {
+		const out = values.slice(0, length);
+		while (out.length < length) out.push(0);
+		return out;
+	};
+	if (uniform.arrayLength) {
+		const n = uniform.arrayLength;
+		if (uniform.type === "float") gl.uniform1fv(location, new Float32Array(pad(n)));
+		else if (uniform.type === "int" || uniform.type === "bool") gl.uniform1iv(location, new Int32Array(pad(n).map(Math.round)));
+		else if (uniform.type === "vec2") gl.uniform2fv(location, new Float32Array(pad(n * 2)));
+		else if (uniform.type === "vec3") {
+			const flat = paramKind === "PackedColorArray" && values.length % 4 === 0 ? values.filter((_, i) => i % 4 !== 3) : values;
+			while (flat.length < n * 3) flat.push(0);
+			gl.uniform3fv(location, new Float32Array(flat.slice(0, n * 3)));
+		} else if (uniform.type === "vec4") gl.uniform4fv(location, new Float32Array(pad(n * 4)));
+		return;
+	}
+	if (uniform.type === "float") gl.uniform1f(location, typeof value === "number" ? value : 0);
+	else if (uniform.type === "int" || uniform.type === "bool") gl.uniform1i(location, typeof value === "number" ? Math.round(value) : 0);
+	else if (uniform.type === "vec2") gl.uniform2f(location, values[0] ?? 0, values[1] ?? 0);
+	else if (uniform.type === "vec3") gl.uniform3f(location, values[0] ?? 0, values[1] ?? 0, values[2] ?? 0);
+	else if (uniform.type === "vec4") gl.uniform4f(location, values[0] ?? 0, values[1] ?? 0, values[2] ?? 0, values[3] ?? 0);
+}
+function startShader(gl, type, source) {
+	const shader = gl.createShader(type);
+	if (!shader) return null;
+	gl.shaderSource(shader, source);
+	gl.compileShader(shader);
+	return shader;
+}
+/** Clear a supplied framebuffer's draw region; callers control its lifetime and binding. */
+function clearWebglSurface(gl, width, height, scissorToViewport = false) {
+	gl.viewport(0, 0, width, height);
+	if (scissorToViewport) {
+		gl.enable(gl.SCISSOR_TEST);
+		gl.scissor(0, 0, width, height);
+	}
+	gl.clearColor(0, 0, 0, 0);
+	gl.clear(gl.COLOR_BUFFER_BIT);
+	if (scissorToViewport) gl.disable(gl.SCISSOR_TEST);
+}
+/** Release an owned texture. Borrowed texture handles must not be passed here. */
+function deleteWebglTexture(gl, texture) {
+	gl.deleteTexture(texture);
+}
+//#endregion
+//#region src/webgl.ts
+/**
+* DOM-free effect targets for a canvas stage.
+*
+* This module deliberately accepts an already-created WebGL2 context.  It never
+* asks for a canvas, creates an element, or schedules a frame: the caller owns
+* the stage, painter ordering, and clock.  The small raw-GLSL and procedural
+* particle subsets below are useful without claiming to be a Godot material or
+* GPUParticles interpreter.
+*/
+/** Allocate reusable, DOM-free simulation and instance storage for a normalized Godot particle spec. */
+function createGodotParticleScratch(config, maxInstances) {
+	const normalized = normalizeParticleRenderConfig(config);
+	return {
+		config: normalized,
+		state: createParticleState(normalized, maxInstances),
+		instances: new InstanceBuffer(Math.max(1, maxInstances ?? normalized.amount))
+	};
+}
+const FULLSCREEN_VERTEX = `#version 300 es
+out vec2 v_uv;
+const vec2 POSITIONS[3] = vec2[3](vec2(-1.0, -1.0), vec2(3.0, -1.0), vec2(-1.0, 3.0));
+void main() {
+  vec2 position = POSITIONS[gl_VertexID];
+  v_uv = position * 0.5 + 0.5;
+  gl_Position = vec4(position, 0.0, 1.0);
+}`;
+const GODOT_DEFAULT_FIT = [1, 1];
+const GODOT_DEFAULT_WINDOW = [
+	0,
+	0,
+	1,
+	1
+];
+const GODOT_DEFAULT_MODULATE = [
+	1,
+	1,
+	1,
+	1
+];
+const GODOT_DEFAULT_SCREEN_RECT = [
+	0,
+	0,
+	1,
+	1
+];
+const PARTICLE_VERTEX = `#version 300 es
+uniform float u_time;
+uniform float u_delta;
+uniform float u_seed;
+uniform float u_lifetime;
+uniform float u_emission_rate;
+uniform float u_max_particles;
+uniform vec2 u_position;
+uniform float u_direction;
+uniform float u_spread;
+uniform vec2 u_speed;
+uniform vec2 u_gravity;
+uniform vec2 u_resolution;
+uniform vec2 u_size;
+out float v_progress;
+out float v_alive;
+float hash(float value) { return fract(sin(value) * 43758.5453123); }
+void main() {
+  float id = float(gl_VertexID);
+  float emission = max(u_emission_rate, 0.0001);
+  float active = min(u_max_particles, ceil(emission * u_lifetime));
+  float period = active / emission;
+  float now = max(0.0, u_time + u_delta);
+  float birth = floor((now * emission - id) / active) * period + id / emission;
+  float age = now - birth;
+  float effectiveLifetime = min(u_lifetime, period);
+  float progress = clamp(age / effectiveLifetime, 0.0, 1.0);
+  float angle = u_direction + (hash(id + u_seed) - 0.5) * u_spread;
+  float speed = mix(u_speed.x, u_speed.y, hash(id * 7.0 + u_seed));
+  vec2 velocity = vec2(cos(angle), sin(angle)) * speed;
+  vec2 pixel = u_position + velocity * age + 0.5 * u_gravity * age * age;
+  vec2 clip = pixel / u_resolution * 2.0 - 1.0;
+  gl_Position = vec4(clip * vec2(1.0, -1.0), 0.0, 1.0);
+  gl_PointSize = mix(u_size.x, u_size.y, progress);
+  v_progress = progress;
+  v_alive = step(0.0, birth) * step(0.0, age) * step(age, effectiveLifetime);
+}`;
+/** Safe ceiling for the stateless point-particle subset. Larger systems are refused. */
+const MAX_HEADLESS_PARTICLES = 16384;
+const PARTICLE_FRAGMENT = `#version 300 es
+precision highp float;
+uniform vec4 u_start_color;
+uniform vec4 u_end_color;
+in float v_progress;
+in float v_alive;
+out vec4 fragColor;
+void main() {
+  if (v_alive < 0.5) discard;
+  vec2 centered = gl_PointCoord * 2.0 - 1.0;
+  float coverage = smoothstep(1.0, 0.7, dot(centered, centered));
+  vec4 color = mix(u_start_color, u_end_color, v_progress);
+  fragColor = vec4(color.rgb * color.a, color.a) * coverage;
+}`;
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function fail(code, message, feature) {
+	return {
+		ok: false,
+		diagnostic: {
+			code,
+			message,
+			feature
+		}
+	};
+}
+function targetDimensions(width, height) {
+	if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) return null;
+	return [Math.max(1, Math.round(width)), Math.max(1, Math.round(height))];
+}
+function directParticleTransform(transform) {
+	const values = transform ?? [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+	if (!values.every(Number.isFinite)) return null;
+	const [xx, xy, yx, yy, originX, originY] = values;
+	const xLength = Math.hypot(xx, xy);
+	const yLength = Math.hypot(yx, yy);
+	const tolerance = Math.max(1, xLength * yLength) * 1e-6;
+	if (xLength <= 1e-9 || Math.abs(xLength - yLength) > tolerance || Math.abs(xx * yx + xy * yy) > tolerance || xx * yy - xy * yx <= 0) return null;
+	return {
+		xx,
+		xy,
+		yx,
+		yy,
+		originX,
+		originY,
+		scale: xLength,
+		rotation: Math.atan2(xy, xx)
+	};
+}
+function directParticleModulate(modulate) {
+	const value = modulate ?? [
+		1,
+		1,
+		1,
+		1
+	];
+	return value.every(Number.isFinite) ? [
+		value[0],
+		value[1],
+		value[2],
+		value[3]
+	] : null;
+}
+function compileProgram$1(gl, vertexSource, fragmentSource) {
+	const vertex = gl.createShader(gl.VERTEX_SHADER);
+	const fragment = gl.createShader(gl.FRAGMENT_SHADER);
+	if (!vertex || !fragment) {
+		if (vertex) gl.deleteShader(vertex);
+		if (fragment) gl.deleteShader(fragment);
+		return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not allocate an effect shader.");
+	}
+	gl.shaderSource(vertex, vertexSource);
+	gl.shaderSource(fragment, fragmentSource);
+	gl.compileShader(vertex);
+	gl.compileShader(fragment);
+	if (!gl.getShaderParameter(vertex, gl.COMPILE_STATUS) || !gl.getShaderParameter(fragment, gl.COMPILE_STATUS)) {
+		const log = gl.getShaderInfoLog(vertex) || gl.getShaderInfoLog(fragment) || "unknown compiler error";
+		gl.deleteShader(vertex);
+		gl.deleteShader(fragment);
+		return fail("SHADER_COMPILE_FAILED", log);
+	}
+	const program = gl.createProgram();
+	if (!program) {
+		gl.deleteShader(vertex);
+		gl.deleteShader(fragment);
+		return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not allocate an effect program.");
+	}
+	gl.attachShader(program, vertex);
+	gl.attachShader(program, fragment);
+	gl.linkProgram(program);
+	gl.deleteShader(vertex);
+	gl.deleteShader(fragment);
+	if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+		const log = gl.getProgramInfoLog(program) || "unknown linker error";
+		gl.deleteProgram(program);
+		return fail("SHADER_COMPILE_FAILED", log);
+	}
+	const vao = gl.createVertexArray();
+	if (!vao) {
+		gl.deleteProgram(program);
+		return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not allocate an effect vertex array.");
+	}
+	return ok({
+		program,
+		vao,
+		locations: /* @__PURE__ */ new Map()
+	});
+}
+function destroyProgram(gl, program) {
+	if (!program) return;
+	gl.deleteVertexArray(program.vao);
+	gl.deleteProgram(program.program);
+}
+function shaderDiagnostic(pass) {
+	const known = new Set([
+		"screen-texture",
+		"time",
+		"delta",
+		"seed",
+		"external-textures",
+		"multiple-render-targets",
+		"transform-feedback",
+		"godot-source"
+	]);
+	const seen = /* @__PURE__ */ new Set();
+	for (const feature of pass.features ?? []) {
+		if (!known.has(feature)) return {
+			code: "UNSUPPORTED_SHADER_FEATURE",
+			message: `Unknown headless shader capability ${feature}.`,
+			feature
+		};
+		if (seen.has(feature)) return {
+			code: "UNSUPPORTED_SHADER_FEATURE",
+			message: `Duplicate headless shader capability ${feature}.`,
+			feature
+		};
+		seen.add(feature);
+	}
+	for (const [name, value] of Object.entries(pass.uniforms ?? {})) {
+		const components = typeof value === "number" ? [value] : value;
+		if (!/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(name) || typeof value !== "number" && (value.length < 2 || value.length > 4) || !Array.from(components).every(Number.isFinite)) return {
+			code: "UNSUPPORTED_SHADER_FEATURE",
+			message: "Shader uniform names and values must be finite GLSL scalar/vector values.",
+			feature: `uniform:${name}`
+		};
+	}
+	const unsupported = new Set([
+		"external-textures",
+		"multiple-render-targets",
+		"transform-feedback",
+		"godot-source"
+	]);
+	const requested = pass.features?.find((feature) => unsupported.has(feature));
+	if (requested) return {
+		code: "UNSUPPORTED_SHADER_FEATURE",
+		message: `Headless shader passes do not support ${requested}.`,
+		feature: requested
+	};
+	if (!/^\s*#version\s+300\s+es\b/m.test(pass.fragmentSource) || !/\bvoid\s+main\s*\(/.test(pass.fragmentSource)) return {
+		code: "UNSUPPORTED_SHADER_FEATURE",
+		message: "A headless shader pass must be a complete GLSL ES 3 fragment shader.",
+		feature: "raw-glsl300es"
+	};
+	const samplers = [...pass.fragmentSource.matchAll(/uniform\s+sampler\w+\s+(\w+)/g)].map((match) => match[1]);
+	if (samplers.some((name) => name !== "u_screenTexture")) return {
+		code: "UNSUPPORTED_SHADER_FEATURE",
+		message: "Only the explicit u_screenTexture sampler is supported by this headless pass.",
+		feature: "external-textures"
+	};
+	if (samplers.includes("u_screenTexture") && !pass.features?.includes("screen-texture")) return {
+		code: "UNSUPPORTED_SHADER_FEATURE",
+		message: "u_screenTexture requires the explicit screen-texture capability declaration.",
+		feature: "screen-texture"
+	};
+	return null;
+}
+function particleDiagnostic(parameters) {
+	const features = parameters.features;
+	if (features?.emissionShape && features.emissionShape !== "point") return {
+		code: "UNSUPPORTED_PARTICLE_FEATURE",
+		message: "Only point particle emission is supported.",
+		feature: `emissionShape:${features.emissionShape}`
+	};
+	for (const feature of [
+		"collision",
+		"attractors",
+		"textureAtlas"
+	]) if (features?.[feature]) return {
+		code: "UNSUPPORTED_PARTICLE_FEATURE",
+		message: `Particle ${feature} is not supported by the stateless headless path.`,
+		feature
+	};
+	if (![
+		parameters.maxParticles,
+		parameters.emissionRate,
+		parameters.lifetimeSeconds,
+		parameters.position[0],
+		parameters.position[1],
+		parameters.directionRadians,
+		parameters.spreadRadians,
+		parameters.speedMin,
+		parameters.speedMax,
+		parameters.gravity[0],
+		parameters.gravity[1],
+		parameters.startSizePx,
+		parameters.endSizePx,
+		...parameters.startColor,
+		...parameters.endColor
+	].every(Number.isFinite)) return {
+		code: "UNSUPPORTED_PARTICLE_FEATURE",
+		message: "Particle parameters must all be finite numbers.",
+		feature: "parameters"
+	};
+	if (!Number.isInteger(parameters.maxParticles) || parameters.maxParticles <= 0 || parameters.maxParticles > 16384 || parameters.emissionRate <= 0 || parameters.lifetimeSeconds <= 0 || parameters.speedMin < 0 || parameters.speedMax < parameters.speedMin || parameters.startSizePx < 0 || parameters.endSizePx < 0 || parameters.startColor.some((value) => value < 0 || value > 1) || parameters.endColor.some((value) => value < 0 || value > 1)) return {
+		code: "UNSUPPORTED_PARTICLE_FEATURE",
+		message: "Particle counts, emission rate, and lifetime must be positive.",
+		feature: "parameters"
+	};
+	return null;
+}
+function renderInputDiagnostic(input) {
+	if (!Number.isFinite(input.time) || !Number.isFinite(input.delta) || input.time < 0 || input.delta < 0 || "seed" in input && input.seed !== void 0 && !Number.isFinite(input.seed)) return {
+		code: "INVALID_RENDER_INPUT",
+		message: "Effect time, delta, and seed must be finite; time and delta must be non-negative.",
+		feature: "render-input"
+	};
+	return null;
+}
+function applyGodotBlend(gl, blend) {
+	gl.enable(gl.BLEND);
+	if (blend === "sub") {
+		gl.blendEquationSeparate(gl.FUNC_REVERSE_SUBTRACT, gl.FUNC_ADD);
+		gl.blendFuncSeparate(gl.ONE, gl.ONE, gl.ONE, gl.ONE);
+		return;
+	}
+	gl.blendEquationSeparate(gl.FUNC_ADD, gl.FUNC_ADD);
+	if (blend === "add") {
+		gl.blendFuncSeparate(gl.ONE, gl.ONE, gl.ONE, gl.ONE);
+		return;
+	}
+	if (blend === "mul") {
+		gl.blendFuncSeparate(gl.DST_COLOR, gl.ZERO, gl.DST_ALPHA, gl.ZERO);
+		return;
+	}
+	gl.blendFuncSeparate(gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+}
+/** Create a DOM-free owner for effect FBOs and their ordered GPU passes. */
+function createHeadlessEffectsStage(gl) {
+	const targets = /* @__PURE__ */ new Set();
+	const invalidatables = /* @__PURE__ */ new Set();
+	let disposed = false;
+	let snapshot = null;
+	let opaqueWhite = null;
+	let opaqueWhiteFilled = false;
+	let opaqueWhiteResult = null;
+	function state() {
+		if (disposed) return fail("DISPOSED", "The headless effects stage has been disposed.");
+		if (gl.isContextLost()) return fail("CONTEXT_LOST", "The WebGL context is lost; invalidate and wait for restoration.");
+		return null;
+	}
+	function makeTarget() {
+		const target = {
+			texture: null,
+			framebuffer: null,
+			width: 0,
+			height: 0
+		};
+		targets.add(target);
+		return target;
+	}
+	function discardTarget(target, callGl) {
+		if (callGl) {
+			if (target.framebuffer) gl.deleteFramebuffer(target.framebuffer);
+			if (target.texture) gl.deleteTexture(target.texture);
+		}
+		target.texture = null;
+		target.framebuffer = null;
+		target.width = 0;
+		target.height = 0;
+	}
+	function resizeTarget(target, width, height) {
+		const current = state();
+		if (current) return current;
+		const dimensions = targetDimensions(width, height);
+		if (!dimensions) return fail("INVALID_DIMENSIONS", "Effect targets need finite dimensions greater than zero.");
+		const [nextWidth, nextHeight] = dimensions;
+		if (target.texture && target.framebuffer && target.width === nextWidth && target.height === nextHeight) return ok(void 0);
+		const texture = gl.createTexture();
+		const framebuffer = gl.createFramebuffer();
+		if (!texture || !framebuffer) {
+			if (texture) gl.deleteTexture(texture);
+			if (framebuffer) gl.deleteFramebuffer(framebuffer);
+			return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not allocate an RGBA8 effect target.");
+		}
+		gl.bindTexture(gl.TEXTURE_2D, texture);
+		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, framebuffer);
+		gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+		const complete = gl.checkFramebufferStatus(gl.FRAMEBUFFER) === gl.FRAMEBUFFER_COMPLETE;
+		gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+		if (!complete) {
+			gl.deleteFramebuffer(framebuffer);
+			gl.deleteTexture(texture);
+			return fail("FRAMEBUFFER_INCOMPLETE", "WebGL rejected the RGBA8 effect framebuffer.");
+		}
+		discardTarget(target, true);
+		target.texture = texture;
+		target.framebuffer = framebuffer;
+		target.width = nextWidth;
+		target.height = nextHeight;
+		return ok(void 0);
+	}
+	function copy(source, destination, filter) {
+		const previousRead = gl.getParameter(gl.READ_FRAMEBUFFER_BINDING);
+		const previousDraw = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+		try {
+			gl.disable(gl.SCISSOR_TEST);
+			gl.bindFramebuffer(gl.READ_FRAMEBUFFER, source.framebuffer);
+			gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, destination.framebuffer);
+			gl.blitFramebuffer(0, 0, source.width, source.height, 0, 0, destination.width, destination.height, gl.COLOR_BUFFER_BIT, filter === "linear" ? gl.LINEAR : gl.NEAREST);
+		} finally {
+			gl.bindFramebuffer(gl.READ_FRAMEBUFFER, previousRead);
+			gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, previousDraw);
+		}
+	}
+	function snapshotFor(target) {
+		if (!snapshot) snapshot = makeTarget();
+		const resized = resizeTarget(snapshot, target.width, target.height);
+		if (!resized.ok) return resized;
+		copy(target, snapshot, "nearest");
+		return ok(snapshot);
+	}
+	/** A stage-owned, opaque TEXTURE fallback for ColorRect/pure-fill shaders. */
+	function whiteTarget() {
+		if (!opaqueWhite) opaqueWhite = makeTarget();
+		if (!opaqueWhite.texture || !opaqueWhite.framebuffer) {
+			const resized = resizeTarget(opaqueWhite, 1, 1);
+			if (!resized.ok) return resized;
+			opaqueWhiteFilled = false;
+		}
+		if (opaqueWhiteFilled && opaqueWhiteResult) return opaqueWhiteResult;
+		const previous = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+		try {
+			gl.bindFramebuffer(gl.FRAMEBUFFER, opaqueWhite.framebuffer);
+			gl.viewport(0, 0, 1, 1);
+			gl.disable(gl.SCISSOR_TEST);
+			gl.clearColor(1, 1, 1, 1);
+			gl.clear(gl.COLOR_BUFFER_BIT);
+			opaqueWhiteFilled = true;
+			opaqueWhiteResult = ok(opaqueWhite);
+		} finally {
+			gl.bindFramebuffer(gl.FRAMEBUFFER, previous);
+		}
+		return ok(opaqueWhite);
+	}
+	function snapshotFramebuffer(framebuffer, width, height) {
+		if (!snapshot) snapshot = makeTarget();
+		const resized = resizeTarget(snapshot, width, height);
+		if (!resized.ok) return resized;
+		const previousRead = gl.getParameter(gl.READ_FRAMEBUFFER_BINDING);
+		const previousDraw = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+		try {
+			gl.disable(gl.SCISSOR_TEST);
+			gl.bindFramebuffer(gl.READ_FRAMEBUFFER, framebuffer);
+			gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, snapshot.framebuffer);
+			gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, gl.COLOR_BUFFER_BIT, gl.NEAREST);
+		} finally {
+			gl.bindFramebuffer(gl.READ_FRAMEBUFFER, previousRead);
+			gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, previousDraw);
+		}
+		return ok(snapshot);
+	}
+	function targetFor(value) {
+		return targets.has(value) ? value : null;
+	}
+	function textureInputFor(value) {
+		const owned = targetFor(value);
+		if (owned?.texture && owned.width > 0 && owned.height > 0) return {
+			texture: owned.texture,
+			width: owned.width,
+			height: owned.height,
+			owned
+		};
+		const borrowed = value;
+		if (!borrowed.texture || !Number.isFinite(borrowed.width) || !Number.isFinite(borrowed.height) || borrowed.width <= 0 || borrowed.height <= 0) return null;
+		return {
+			texture: borrowed.texture,
+			width: borrowed.width,
+			height: borrowed.height,
+			owned: null
+		};
+	}
+	function uniformLocation(program, name) {
+		const known = program.locations.get(name);
+		if (known !== void 0) return known;
+		if (program.locations.has(name)) return null;
+		const location = gl.getUniformLocation(program.program, name);
+		program.locations.set(name, location);
+		return location;
+	}
+	function applyUniform(program, name, value) {
+		const location = uniformLocation(program, name);
+		if (location === null) return;
+		if (typeof value === "number") gl.uniform1f(location, value);
+		else if (value.length === 2) gl.uniform2f(location, value[0], value[1]);
+		else if (value.length === 3) gl.uniform3f(location, value[0], value[1], value[2]);
+		else gl.uniform4f(location, value[0], value[1], value[2], value[3]);
+	}
+	function createShaderProducer(pass, width, height) {
+		const invalid = state();
+		if (invalid) return invalid;
+		const diagnostic = shaderDiagnostic(pass);
+		if (diagnostic) return {
+			ok: false,
+			diagnostic
+		};
+		const target = makeTarget();
+		const allocated = resizeTarget(target, width, height);
+		if (!allocated.ok) {
+			targets.delete(target);
+			return allocated;
+		}
+		let requestedWidth = target.width;
+		let requestedHeight = target.height;
+		const resolution = [target.width, target.height];
+		const uniformEntries = Object.entries(pass.uniforms ?? {});
+		const rendered = ok(target);
+		let program = null;
+		let producerDisposed = false;
+		const needsScreen = pass.features?.includes("screen-texture") === true;
+		function ensureProgram() {
+			if (program) return ok(program);
+			const compiled = compileProgram$1(gl, FULLSCREEN_VERTEX, pass.fragmentSource);
+			if (compiled.ok) program = compiled.value;
+			return compiled;
+		}
+		const producer = {
+			target,
+			warmUp() {
+				const current = state();
+				if (current) return current;
+				if (producerDisposed) return fail("DISPOSED", "The shader producer has been disposed.");
+				const ready = ensureProgram();
+				return ready.ok ? ok(void 0) : ready;
+			},
+			resize(nextWidth, nextHeight) {
+				if (producerDisposed) return fail("DISPOSED", "The shader producer has been disposed.");
+				const resized = resizeTarget(target, nextWidth, nextHeight);
+				if (resized.ok) {
+					requestedWidth = target.width;
+					requestedHeight = target.height;
+					resolution[0] = target.width;
+					resolution[1] = target.height;
+				}
+				return resized;
+			},
+			render(input) {
+				const inputDiagnostic = renderInputDiagnostic(input);
+				if (inputDiagnostic) return {
+					ok: false,
+					diagnostic: inputDiagnostic
+				};
+				const current = state();
+				if (current) return current;
+				if (producerDisposed) return fail("DISPOSED", "The shader producer has been disposed.");
+				if (!target.texture || !target.framebuffer) {
+					const reallocated = resizeTarget(target, requestedWidth, requestedHeight);
+					if (!reallocated.ok) return reallocated;
+				}
+				let screen = null;
+				if (needsScreen) {
+					if (!input.screenTexture) return fail("SCREEN_TEXTURE_REQUIRED", "This shader pass declared screen-texture but no accumulated target was supplied.");
+					screen = targetFor(input.screenTexture);
+					if (!screen?.texture || !screen.framebuffer) return fail("FOREIGN_TARGET", "screenTexture must be a live target owned by this headless effects stage.");
+					if (screen === target) {
+						const captured = snapshotFor(screen);
+						if (!captured.ok) return captured;
+						screen = captured.value;
+					}
+				}
+				const ready = ensureProgram();
+				if (!ready.ok) return ready;
+				const previousFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+				try {
+					gl.bindFramebuffer(gl.FRAMEBUFFER, target.framebuffer);
+					gl.viewport(0, 0, target.width, target.height);
+					gl.disable(gl.SCISSOR_TEST);
+					gl.clearColor(0, 0, 0, 0);
+					gl.clear(gl.COLOR_BUFFER_BIT);
+					gl.enable(gl.BLEND);
+					gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+					gl.useProgram(ready.value.program);
+					gl.bindVertexArray(ready.value.vao);
+					applyUniform(ready.value, "u_time", input.time);
+					applyUniform(ready.value, "u_delta", input.delta);
+					applyUniform(ready.value, "u_seed", input.seed ?? 0);
+					applyUniform(ready.value, "u_resolution", resolution);
+					for (const [name, value] of uniformEntries) applyUniform(ready.value, name, value);
+					if (screen) {
+						gl.activeTexture(gl.TEXTURE0);
+						gl.bindTexture(gl.TEXTURE_2D, screen.texture);
+						const location = uniformLocation(ready.value, "u_screenTexture");
+						if (location) gl.uniform1i(location, 0);
+					}
+					gl.drawArrays(gl.TRIANGLES, 0, 3);
+					gl.bindVertexArray(null);
+					return rendered;
+				} finally {
+					gl.bindFramebuffer(gl.FRAMEBUFFER, previousFramebuffer);
+				}
+			},
+			renderScreen(input, context) {
+				const inputDiagnostic = renderInputDiagnostic(input);
+				if (inputDiagnostic) return {
+					ok: false,
+					diagnostic: inputDiagnostic
+				};
+				if (!needsScreen) return fail("UNSUPPORTED_SHADER_FEATURE", "Only a screen-texture pass can be recorded as a screen effect.", "screen-texture");
+				if (context.damage) return fail("UNSUPPORTED_SHADER_FEATURE", "Screen-dependent effects decline partial damage execution.", "partial-damage");
+				const resized = producer.resize(context.width, context.height);
+				if (!resized.ok) return resized;
+				const captured = snapshotFramebuffer(context.framebuffer, context.width, context.height);
+				if (!captured.ok) return captured;
+				const renderedScreen = producer.render({
+					time: input.time,
+					delta: input.delta,
+					seed: input.seed,
+					screenTexture: captured.value
+				});
+				if (!renderedScreen.ok) return renderedScreen;
+				const previousRead = gl.getParameter(gl.READ_FRAMEBUFFER_BINDING);
+				const previousDraw = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+				try {
+					gl.bindFramebuffer(gl.READ_FRAMEBUFFER, target.framebuffer);
+					gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, context.framebuffer);
+					gl.enable(gl.SCISSOR_TEST);
+					gl.scissor(context.scissor.x, context.scissor.y, context.scissor.width, context.scissor.height);
+					gl.blitFramebuffer(0, 0, target.width, target.height, 0, 0, context.width, context.height, gl.COLOR_BUFFER_BIT, gl.NEAREST);
+				} finally {
+					gl.bindFramebuffer(gl.READ_FRAMEBUFFER, previousRead);
+					gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, previousDraw);
+				}
+				return ok(void 0);
+			},
+			invalidate() {
+				destroyProgram(gl, program);
+				program = null;
+				discardTarget(target, true);
+			},
+			invalidateContextLoss() {
+				program = null;
+				discardTarget(target, false);
+			},
+			dispose() {
+				if (!producerDisposed) {
+					producerDisposed = true;
+					destroyProgram(gl, program);
+					program = null;
+					discardTarget(target, true);
+					targets.delete(target);
+					invalidatables.delete(producer);
+				}
+			}
+		};
+		invalidatables.add(producer);
+		return ok(producer);
+	}
+	function createGodotShaderProducer(pass, width, height) {
+		const invalid = state();
+		if (invalid) return invalid;
+		let transpiled;
+		try {
+			transpiled = transpileGodotShader(pass.source);
+		} catch (error) {
+			return fail("UNSUPPORTED_SHADER_FEATURE", error instanceof UnsupportedShaderError ? error.message : `Godot shader transpilation failed: ${error instanceof Error ? error.message : String(error)}`, "godot-source");
+		}
+		const suppliedSamplers = { ...pass.samplers ?? {} };
+		for (const sampler of transpiled.samplers) {
+			if (!suppliedSamplers[sampler.name]) return fail("UNSUPPORTED_SHADER_FEATURE", `Godot sampler ${sampler.name} needs an explicit stage-owned target.`, `sampler:${sampler.name}`);
+			if (sampler.repeat) return fail("UNSUPPORTED_SHADER_FEATURE", `Godot sampler ${sampler.name} requests repeat sampling, which stage targets cannot mutate.`, `sampler:${sampler.name}:repeat`);
+		}
+		for (const uniform of transpiled.uniforms) if (uniform.arrayLength || ![
+			"float",
+			"int",
+			"bool",
+			"vec2",
+			"vec3",
+			"vec4"
+		].includes(uniform.type)) return fail("UNSUPPORTED_SHADER_FEATURE", `Godot uniform ${uniform.name} (${uniform.type}) is not supported headlessly.`, `uniform:${uniform.name}`);
+		const componentCount = (type) => type === "vec2" ? 2 : type === "vec3" ? 3 : type === "vec4" ? 4 : 1;
+		const uniformValues = {};
+		for (const uniform of transpiled.uniforms) {
+			const raw = pass.uniforms?.[uniform.name] ?? uniform.default;
+			if (raw === void 0) continue;
+			const expected = componentCount(uniform.type);
+			const values = typeof raw === "number" ? null : raw;
+			if (expected === 1 && typeof raw !== "number" || expected !== 1 && (!values || values.length !== expected) || typeof raw === "number" && !Number.isFinite(raw) || values && !values.every(Number.isFinite)) return fail("UNSUPPORTED_SHADER_FEATURE", `Godot uniform ${uniform.name} must be ${expected} finite numeric component${expected === 1 ? "" : "s"}.`, `uniform:${uniform.name}`);
+			uniformValues[uniform.name] = typeof raw === "number" ? raw : [...raw];
+		}
+		const fit = [...pass.uvFit ?? GODOT_DEFAULT_FIT];
+		const window = [...pass.uvWindow ?? GODOT_DEFAULT_WINDOW];
+		const modulate = [...pass.modulate ?? GODOT_DEFAULT_MODULATE];
+		if (!fit.every(Number.isFinite) || !window.every(Number.isFinite) || !modulate.every(Number.isFinite)) return fail("UNSUPPORTED_SHADER_FEATURE", "Godot shader fit, window, and modulate values must be finite.", "render-parameters");
+		const target = makeTarget();
+		const allocated = resizeTarget(target, width, height);
+		if (!allocated.ok) {
+			targets.delete(target);
+			return allocated;
+		}
+		let requestedWidth = target.width;
+		let requestedHeight = target.height;
+		let program = null;
+		let producerDisposed = false;
+		const rendered = ok(target);
+		const noScreen = ok(null);
+		const texturePixelSize = [1, 1];
+		const screenPixelSize = [1, 1];
+		const screenOrigin = [0, 0];
+		const screenSize = [1, 1];
+		const ensureProgram = () => {
+			if (program) return ok(program);
+			const compiled = compileProgram$1(gl, FULLSCREEN_VERTEX, transpiled.fragmentGlsl);
+			if (compiled.ok) program = compiled.value;
+			return compiled;
+		};
+		const stageTarget = (value, label) => {
+			if (!value) return ok(null);
+			const texture = textureInputFor(value);
+			return texture ? ok(texture) : fail("FOREIGN_TARGET", `${label} must be a live same-context stage target or texture handle.`);
+		};
+		const suppliedTexture = stageTarget(pass.texture, "TEXTURE");
+		if (!suppliedTexture.ok) {
+			discardTarget(target, true);
+			targets.delete(target);
+			return suppliedTexture;
+		}
+		const baseTexture = suppliedTexture.value;
+		const samplerTargets = [];
+		for (const sampler of transpiled.samplers) {
+			const supplied = stageTarget(suppliedSamplers[sampler.name], `sampler:${sampler.name}`);
+			if (!supplied.ok || !supplied.value) {
+				discardTarget(target, true);
+				targets.delete(target);
+				return supplied.ok ? fail("UNSUPPORTED_SHADER_FEATURE", `Godot sampler ${sampler.name} needs an explicit target.`, `sampler:${sampler.name}`) : supplied;
+			}
+			samplerTargets.push(supplied.value);
+		}
+		const applyGodotUniform = (p, uniform) => {
+			const raw = uniformValues[uniform.name];
+			const loc = uniformLocation(p, uniform.name);
+			if (!loc) return;
+			if (typeof raw === "number") {
+				if (uniform.type === "float") gl.uniform1f(loc, raw);
+				else if (uniform.type === "int" || uniform.type === "bool") gl.uniform1i(loc, Math.round(raw));
+				return;
+			}
+			const values = raw ?? [];
+			if (uniform.type === "float") gl.uniform1f(loc, 0);
+			else if (uniform.type === "int" || uniform.type === "bool") gl.uniform1i(loc, 0);
+			else if (uniform.type === "vec2") gl.uniform2f(loc, values[0] ?? 0, values[1] ?? 0);
+			else if (uniform.type === "vec3") gl.uniform3f(loc, values[0] ?? 0, values[1] ?? 0, values[2] ?? 0);
+			else gl.uniform4f(loc, values[0] ?? 0, values[1] ?? 0, values[2] ?? 0, values[3] ?? 0);
+		};
+		const liveDependencies = ok(void 0);
+		const dependenciesLive = () => {
+			if (baseTexture && (baseTexture.owned ? !targets.has(baseTexture.owned) || !baseTexture.owned.texture || !baseTexture.owned.framebuffer : typeof gl.isTexture === "function" && !gl.isTexture(baseTexture.texture))) return fail("FOREIGN_TARGET", "A Godot shader dependency is no longer a live stage-owned target.", "dependency");
+			for (let i = 0; i < samplerTargets.length; i += 1) {
+				const dependency = samplerTargets[i];
+				if (dependency.owned ? !targets.has(dependency.owned) || !dependency.owned.texture || !dependency.owned.framebuffer : typeof gl.isTexture === "function" && !gl.isTexture(dependency.texture)) return fail("FOREIGN_TARGET", "A Godot shader dependency is no longer a live stage-owned target.", "dependency");
+			}
+			return liveDependencies;
+		};
+		const producer = {
+			target,
+			blend: transpiled.blend,
+			warmUp() {
+				const current = state();
+				if (current) return current;
+				if (producerDisposed) return fail("DISPOSED", "The Godot shader producer has been disposed.");
+				const ready = ensureProgram();
+				return ready.ok ? ok(void 0) : ready;
+			},
+			resize(nextWidth, nextHeight) {
+				if (producerDisposed) return fail("DISPOSED", "The Godot shader producer has been disposed.");
+				const resized = resizeTarget(target, nextWidth, nextHeight);
+				if (resized.ok) {
+					requestedWidth = target.width;
+					requestedHeight = target.height;
+				}
+				return resized;
+			},
+			render(input) {
+				const inputDiagnostic = renderInputDiagnostic(input);
+				if (inputDiagnostic) return {
+					ok: false,
+					diagnostic: inputDiagnostic
+				};
+				if (input.screenRect && !input.screenRect.every(Number.isFinite)) return fail("INVALID_RENDER_INPUT", "Godot screenRect values must be finite.", "screen-rect");
+				const current = state();
+				if (current) return current;
+				if (producerDisposed) return fail("DISPOSED", "The Godot shader producer has been disposed.");
+				if (!target.texture || !target.framebuffer) {
+					const resized = resizeTarget(target, requestedWidth, requestedHeight);
+					if (!resized.ok) return resized;
+				}
+				const dependencies = dependenciesLive();
+				if (!dependencies.ok) return dependencies;
+				const white = baseTexture ? null : whiteTarget();
+				if (white && !white.ok) return white;
+				const texture = baseTexture ?? white?.value;
+				const screen = transpiled.usesScreenTexture ? stageTarget(input.screenTexture, "SCREEN_TEXTURE") : noScreen;
+				if (!screen.ok) return screen;
+				if (transpiled.usesScreenTexture && !screen.value) return fail("SCREEN_TEXTURE_REQUIRED", "This Godot shader samples SCREEN_TEXTURE but no accumulated target was supplied.");
+				const screenTarget = screen.value === target ? snapshotFor(target) : screen;
+				if (!screenTarget.ok) return screenTarget;
+				const ready = ensureProgram();
+				if (!ready.ok) return ready;
+				const previous = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+				try {
+					gl.bindFramebuffer(gl.FRAMEBUFFER, target.framebuffer);
+					gl.viewport(0, 0, target.width, target.height);
+					gl.disable(gl.SCISSOR_TEST);
+					gl.disable(gl.BLEND);
+					gl.clearColor(0, 0, 0, 0);
+					gl.clear(gl.COLOR_BUFFER_BIT);
+					gl.useProgram(ready.value.program);
+					gl.bindVertexArray(ready.value.vao);
+					gl.activeTexture(gl.TEXTURE0);
+					gl.bindTexture(gl.TEXTURE_2D, texture?.texture ?? null);
+					const textureLoc = uniformLocation(ready.value, "TEXTURE");
+					if (textureLoc) gl.uniform1i(textureLoc, 0);
+					if (transpiled.usesTime) applyUniform(ready.value, "TIME", input.time);
+					if (transpiled.usesTexturePixelSize) {
+						texturePixelSize[0] = 1 / Math.max(1, texture?.width ?? 1);
+						texturePixelSize[1] = 1 / Math.max(1, texture?.height ?? 1);
+						applyUniform(ready.value, "TEXTURE_PIXEL_SIZE", texturePixelSize);
+					}
+					applyUniform(ready.value, "MODULATE", modulate);
+					applyUniform(ready.value, "_godot_uv_fit", fit);
+					applyUniform(ready.value, "_godot_uv_window", window);
+					const rect = input.screenRect ?? GODOT_DEFAULT_SCREEN_RECT;
+					if (transpiled.usesScreenUv) {
+						screenOrigin[0] = rect[0];
+						screenOrigin[1] = rect[1];
+						screenSize[0] = rect[2];
+						screenSize[1] = rect[3];
+						applyUniform(ready.value, "_godot_screen_origin", screenOrigin);
+						applyUniform(ready.value, "_godot_screen_size", screenSize);
+					}
+					if (screenTarget.value) {
+						gl.activeTexture(gl.TEXTURE0 + 1);
+						gl.bindTexture(gl.TEXTURE_2D, screenTarget.value.texture);
+						const loc = uniformLocation(ready.value, "SCREEN_TEXTURE");
+						if (loc) gl.uniform1i(loc, 1);
+					}
+					if (transpiled.usesScreenPixelSize) {
+						screenPixelSize[0] = 1 / Math.max(1, screenTarget.value?.width ?? target.width);
+						screenPixelSize[1] = 1 / Math.max(1, screenTarget.value?.height ?? target.height);
+						applyUniform(ready.value, "SCREEN_PIXEL_SIZE", screenPixelSize);
+					}
+					let unit = 2;
+					for (let i = 0; i < transpiled.samplers.length; i += 1) {
+						const sampler = transpiled.samplers[i];
+						const value = samplerTargets[i];
+						gl.activeTexture(gl.TEXTURE0 + unit);
+						gl.bindTexture(gl.TEXTURE_2D, value.texture);
+						const loc = uniformLocation(ready.value, sampler.name);
+						if (loc) gl.uniform1i(loc, unit++);
+					}
+					for (const uniform of transpiled.uniforms) applyGodotUniform(ready.value, uniform);
+					gl.drawArrays(gl.TRIANGLES, 0, 3);
+					gl.bindVertexArray(null);
+					return rendered;
+				} finally {
+					gl.bindFramebuffer(gl.FRAMEBUFFER, previous);
+				}
+			},
+			renderScreen(input, context) {
+				if (!transpiled.usesScreenTexture) return fail("UNSUPPORTED_SHADER_FEATURE", "Only a Godot SCREEN_TEXTURE shader can be recorded as a screen effect.", "screen-texture");
+				if (context.damage) return fail("UNSUPPORTED_SHADER_FEATURE", "Screen-dependent effects decline partial damage execution.", "partial-damage");
+				const dependencies = dependenciesLive();
+				if (!dependencies.ok) return dependencies;
+				const rect = input.screenRect;
+				if (!rect?.every(Number.isFinite) || rect[0] < 0 || rect[1] < 0 || rect[2] <= 0 || rect[3] <= 0 || rect[0] + rect[2] > 1 || rect[1] + rect[3] > 1) return fail("UNSUPPORTED_SHADER_FEATURE", "Screen shaders need a finite, normalized axis-aligned screenRect.", "screen-rect");
+				const resized = producer.resize(context.width, context.height);
+				if (!resized.ok) return resized;
+				const captured = snapshotFramebuffer(context.framebuffer, context.width, context.height);
+				if (!captured.ok) return captured;
+				copy(captured.value, target, "nearest");
+				const x = Math.round(rect[0] * context.width);
+				const x1 = Math.round((rect[0] + rect[2]) * context.width);
+				const topY = Math.round(rect[1] * context.height);
+				const bottomY = Math.round((rect[1] + rect[3]) * context.height);
+				const y = context.height - bottomY;
+				const width = x1 - x;
+				const height = bottomY - topY;
+				const left = Math.max(x, context.scissor.x);
+				const bottom = Math.max(y, context.scissor.y);
+				const right = Math.min(x1, context.scissor.x + context.scissor.width);
+				const top = Math.min(context.height - topY, context.scissor.y + context.scissor.height);
+				if (right <= left || top <= bottom) return ok(void 0);
+				const ready = ensureProgram();
+				if (!ready.ok) return ready;
+				const white = baseTexture ? null : whiteTarget();
+				if (white && !white.ok) return white;
+				const texture = baseTexture ?? white?.value;
+				const previous = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+				try {
+					gl.bindFramebuffer(gl.FRAMEBUFFER, target.framebuffer);
+					gl.viewport(x, y, width, height);
+					gl.enable(gl.SCISSOR_TEST);
+					gl.scissor(left, bottom, right - left, top - bottom);
+					applyGodotBlend(gl, transpiled.blend);
+					gl.useProgram(ready.value.program);
+					gl.bindVertexArray(ready.value.vao);
+					gl.activeTexture(gl.TEXTURE0);
+					gl.bindTexture(gl.TEXTURE_2D, texture?.texture ?? null);
+					const textureLoc = uniformLocation(ready.value, "TEXTURE");
+					if (textureLoc) gl.uniform1i(textureLoc, 0);
+					if (transpiled.usesTime) applyUniform(ready.value, "TIME", input.time);
+					if (transpiled.usesTexturePixelSize) {
+						texturePixelSize[0] = 1 / Math.max(1, texture?.width ?? 1);
+						texturePixelSize[1] = 1 / Math.max(1, texture?.height ?? 1);
+						applyUniform(ready.value, "TEXTURE_PIXEL_SIZE", texturePixelSize);
+					}
+					applyUniform(ready.value, "MODULATE", modulate);
+					applyUniform(ready.value, "_godot_uv_fit", fit);
+					applyUniform(ready.value, "_godot_uv_window", window);
+					screenOrigin[0] = rect[0];
+					screenOrigin[1] = rect[1];
+					screenSize[0] = rect[2];
+					screenSize[1] = rect[3];
+					if (transpiled.usesScreenUv) {
+						applyUniform(ready.value, "_godot_screen_origin", screenOrigin);
+						applyUniform(ready.value, "_godot_screen_size", screenSize);
+					}
+					gl.activeTexture(gl.TEXTURE0 + 1);
+					gl.bindTexture(gl.TEXTURE_2D, captured.value.texture);
+					const screenLoc = uniformLocation(ready.value, "SCREEN_TEXTURE");
+					if (screenLoc) gl.uniform1i(screenLoc, 1);
+					if (transpiled.usesScreenPixelSize) {
+						screenPixelSize[0] = 1 / context.width;
+						screenPixelSize[1] = 1 / context.height;
+						applyUniform(ready.value, "SCREEN_PIXEL_SIZE", screenPixelSize);
+					}
+					let unit = 2;
+					for (let i = 0; i < transpiled.samplers.length; i += 1) {
+						const sampler = transpiled.samplers[i];
+						gl.activeTexture(gl.TEXTURE0 + unit);
+						gl.bindTexture(gl.TEXTURE_2D, samplerTargets[i].texture);
+						const loc = uniformLocation(ready.value, sampler.name);
+						if (loc) gl.uniform1i(loc, unit++);
+					}
+					for (const uniform of transpiled.uniforms) applyGodotUniform(ready.value, uniform);
+					gl.drawArrays(gl.TRIANGLES, 0, 3);
+					gl.bindVertexArray(null);
+				} finally {
+					gl.bindFramebuffer(gl.FRAMEBUFFER, previous);
+				}
+				const previousRead = gl.getParameter(gl.READ_FRAMEBUFFER_BINDING);
+				const previousDraw = gl.getParameter(gl.DRAW_FRAMEBUFFER_BINDING);
+				try {
+					gl.bindFramebuffer(gl.READ_FRAMEBUFFER, target.framebuffer);
+					gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, context.framebuffer);
+					gl.enable(gl.SCISSOR_TEST);
+					gl.scissor(context.scissor.x, context.scissor.y, context.scissor.width, context.scissor.height);
+					gl.blitFramebuffer(0, 0, target.width, target.height, 0, 0, context.width, context.height, gl.COLOR_BUFFER_BIT, gl.NEAREST);
+				} finally {
+					gl.bindFramebuffer(gl.READ_FRAMEBUFFER, previousRead);
+					gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, previousDraw);
+				}
+				return ok(void 0);
+			},
+			invalidate() {
+				destroyProgram(gl, program);
+				program = null;
+				discardTarget(target, true);
+			},
+			invalidateContextLoss() {
+				program = null;
+				discardTarget(target, false);
+			},
+			dispose() {
+				if (!producerDisposed) {
+					producerDisposed = true;
+					destroyProgram(gl, program);
+					program = null;
+					discardTarget(target, true);
+					targets.delete(target);
+					invalidatables.delete(producer);
+				}
+			}
+		};
+		invalidatables.add(producer);
+		return ok(producer);
+	}
+	function createParticleProducer(parameters, width, height) {
+		const invalid = state();
+		if (invalid) return invalid;
+		const diagnostic = particleDiagnostic(parameters);
+		if (diagnostic) return {
+			ok: false,
+			diagnostic
+		};
+		const target = makeTarget();
+		const allocated = resizeTarget(target, width, height);
+		if (!allocated.ok) {
+			targets.delete(target);
+			return allocated;
+		}
+		let requestedWidth = target.width;
+		let requestedHeight = target.height;
+		const resolution = [target.width, target.height];
+		const speed = [parameters.speedMin, parameters.speedMax];
+		const size = [parameters.startSizePx, parameters.endSizePx];
+		const rendered = ok(target);
+		let program = null;
+		let producerDisposed = false;
+		const count = Math.min(Math.floor(parameters.maxParticles), Math.max(1, Math.ceil(parameters.emissionRate * parameters.lifetimeSeconds)));
+		function ensureProgram() {
+			if (program) return ok(program);
+			const compiled = compileProgram$1(gl, PARTICLE_VERTEX, PARTICLE_FRAGMENT);
+			if (compiled.ok) program = compiled.value;
+			return compiled;
+		}
+		const producer = {
+			target,
+			warmUp() {
+				const current = state();
+				if (current) return current;
+				if (producerDisposed) return fail("DISPOSED", "The particle producer has been disposed.");
+				const ready = ensureProgram();
+				return ready.ok ? ok(void 0) : ready;
+			},
+			resize(nextWidth, nextHeight) {
+				if (producerDisposed) return fail("DISPOSED", "The particle producer has been disposed.");
+				const resized = resizeTarget(target, nextWidth, nextHeight);
+				if (resized.ok) {
+					requestedWidth = target.width;
+					requestedHeight = target.height;
+					resolution[0] = target.width;
+					resolution[1] = target.height;
+				}
+				return resized;
+			},
+			render(input) {
+				const inputDiagnostic = renderInputDiagnostic(input);
+				if (inputDiagnostic) return {
+					ok: false,
+					diagnostic: inputDiagnostic
+				};
+				const current = state();
+				if (current) return current;
+				if (producerDisposed) return fail("DISPOSED", "The particle producer has been disposed.");
+				if (!target.framebuffer) {
+					const reallocated = resizeTarget(target, requestedWidth, requestedHeight);
+					if (!reallocated.ok) return reallocated;
+				}
+				const ready = ensureProgram();
+				if (!ready.ok) return ready;
+				const previousFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+				try {
+					gl.bindFramebuffer(gl.FRAMEBUFFER, target.framebuffer);
+					gl.viewport(0, 0, target.width, target.height);
+					gl.disable(gl.SCISSOR_TEST);
+					gl.clearColor(0, 0, 0, 0);
+					gl.clear(gl.COLOR_BUFFER_BIT);
+					gl.enable(gl.BLEND);
+					gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+					gl.useProgram(ready.value.program);
+					gl.bindVertexArray(ready.value.vao);
+					applyUniform(ready.value, "u_time", input.time);
+					applyUniform(ready.value, "u_delta", input.delta);
+					applyUniform(ready.value, "u_seed", input.seed);
+					applyUniform(ready.value, "u_lifetime", parameters.lifetimeSeconds);
+					applyUniform(ready.value, "u_emission_rate", parameters.emissionRate);
+					applyUniform(ready.value, "u_max_particles", parameters.maxParticles);
+					applyUniform(ready.value, "u_position", parameters.position);
+					applyUniform(ready.value, "u_direction", parameters.directionRadians);
+					applyUniform(ready.value, "u_spread", parameters.spreadRadians);
+					applyUniform(ready.value, "u_speed", speed);
+					applyUniform(ready.value, "u_gravity", parameters.gravity);
+					applyUniform(ready.value, "u_resolution", resolution);
+					applyUniform(ready.value, "u_size", size);
+					applyUniform(ready.value, "u_start_color", parameters.startColor);
+					applyUniform(ready.value, "u_end_color", parameters.endColor);
+					gl.drawArrays(gl.POINTS, 0, count);
+					gl.bindVertexArray(null);
+					return rendered;
+				} finally {
+					gl.bindFramebuffer(gl.FRAMEBUFFER, previousFramebuffer);
+				}
+			},
+			invalidate() {
+				destroyProgram(gl, program);
+				program = null;
+				discardTarget(target, true);
+			},
+			invalidateContextLoss() {
+				program = null;
+				discardTarget(target, false);
+			},
+			dispose() {
+				if (!producerDisposed) {
+					producerDisposed = true;
+					destroyProgram(gl, program);
+					program = null;
+					discardTarget(target, true);
+					targets.delete(target);
+					invalidatables.delete(producer);
+				}
+			}
+		};
+		invalidatables.add(producer);
+		return ok(producer);
+	}
+	function createGodotParticleProducer(pass, width, height) {
+		const invalid = state();
+		if (invalid) return invalid;
+		if (!pass.config && !pass.scratch) return fail("UNSUPPORTED_PARTICLE_FEATURE", "A particle pass needs config or caller-owned scratch.", "config");
+		if (pass.scratch && pass.config) return fail("UNSUPPORTED_PARTICLE_FEATURE", "When scratch is supplied, omit config: scratch is the semantic owner.", "scratch-config");
+		const config = pass.scratch ? pass.scratch.config : normalizeParticleRenderConfig(pass.config);
+		const sprite = pass.spriteTexture ? textureInputFor(pass.spriteTexture) : null;
+		const lut = pass.lutTexture ? textureInputFor(pass.lutTexture) : null;
+		const mask = pass.maskTexture ? textureInputFor(pass.maskTexture) : null;
+		if (pass.spriteTexture && !sprite) return fail("FOREIGN_TARGET", "A textured particle system needs a live sprite target owned by this stage.", "sprite-texture");
+		if (pass.lutTexture && !lut || pass.maskTexture && !mask) return fail("FOREIGN_TARGET", "Particle auxiliary textures must be live targets owned by this stage.", "auxiliary-texture");
+		const unsupported = [
+			"collision",
+			"attractors",
+			"trails",
+			"customMaterial"
+		].find((feature) => pass.features?.[feature]);
+		if (unsupported) return fail("UNSUPPORTED_PARTICLE_FEATURE", `Headless Godot particles do not support ${unsupported}.`, unsupported);
+		if (config.emissionShape === 4 || config.emissionShape === 5) return fail("UNSUPPORTED_PARTICLE_FEATURE", "Point-list and directed-point emission require their authored point data.", "emission-shape");
+		const scratch = pass.scratch ?? createGodotParticleScratch(config);
+		const ownsScratch = !pass.scratch;
+		if (scratch.instances.data.length / 10 < scratch.state.count) return fail("UNSUPPORTED_PARTICLE_FEATURE", "Scratch cannot hold the configured particle count.", "scratch-capacity");
+		const target = makeTarget();
+		const allocated = resizeTarget(target, width, height);
+		if (!allocated.ok) {
+			targets.delete(target);
+			return allocated;
+		}
+		const semanticConfig = scratch.config;
+		const packing = {
+			state: scratch.state,
+			config: semanticConfig,
+			instances: scratch.instances,
+			textureWidth: 0,
+			textureHeight: 0,
+			origin: void 0,
+			transform: void 0,
+			modulate: void 0
+		};
+		let requestedWidth = target.width, requestedHeight = target.height;
+		let program = null;
+		let quad = null;
+		let producerDisposed = false;
+		let lastTime = null;
+		let preprocessed = false;
+		const rendered = ok(target);
+		const warmed = ok(void 0);
+		const particleGl = {
+			gl,
+			quad: null
+		};
+		const drawOptions = {
+			texture: sprite?.texture ?? null,
+			textured: Boolean(sprite),
+			lutTexture: lut?.texture ?? null,
+			maskTexture: mask?.texture ?? null,
+			hframes: semanticConfig.hframes,
+			vframes: semanticConfig.vframes,
+			blendMode: semanticConfig.blendMode,
+			viewportW: target.width,
+			viewportH: target.height,
+			alphaFromRed: semanticConfig.alphaFromRed,
+			erode: semanticConfig.alphaErode,
+			uvPolar: semanticConfig.uvPolar,
+			targetFramebuffer: target.framebuffer
+		};
+		const ensure = () => {
+			if (program) return readyResult;
+			const compiled = acquireParticleProgram(gl);
+			if (!compiled) return fail("SHADER_COMPILE_FAILED", "WebGL could not compile the shared Godot particle renderer.");
+			quad = gl.createBuffer();
+			if (!quad) {
+				releaseParticleProgram(gl);
+				return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not allocate the particle resolve quad.");
+			}
+			gl.bindBuffer(gl.ARRAY_BUFFER, quad);
+			gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+				-1,
+				-1,
+				1,
+				-1,
+				-1,
+				1,
+				1,
+				1
+			]), gl.STATIC_DRAW);
+			program = compiled;
+			particleGl.quad = quad;
+			readyResult = ok(compiled);
+			return readyResult;
+		};
+		let readyResult = null;
+		const dependencyLive = (value) => !(value && (value.owned ? !targets.has(value.owned) || !value.owned.texture || !value.owned.framebuffer : typeof gl.isTexture === "function" && !gl.isTexture(value.texture)));
+		const reset = () => {
+			const s = scratch.state;
+			s.time = 0;
+			s.cycle = 0;
+			s.remainder = 0;
+			s.emitting = true;
+			for (let index = 0; index < s.particles.length; index += 1) s.particles[index].active = false;
+		};
+		const preprocess = () => {
+			if (preprocessed) return;
+			preprocessParticles(scratch.state);
+			preprocessed = true;
+		};
+		const producer = {
+			target,
+			scratch,
+			warmUp() {
+				const current = state();
+				if (current) return current;
+				if (producerDisposed) return fail("DISPOSED", "The Godot particle producer has been disposed.");
+				const ready = ensure();
+				if (!ready.ok) return ready;
+				if (!prepareParticleDraw(gl, ready.value, drawOptions) || false) return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not prepare particle draw resources.");
+				return warmed;
+			},
+			resize(nextWidth, nextHeight) {
+				if (producerDisposed) return fail("DISPOSED", "The Godot particle producer has been disposed.");
+				const resized = resizeTarget(target, nextWidth, nextHeight);
+				if (resized.ok) {
+					requestedWidth = target.width;
+					requestedHeight = target.height;
+					drawOptions.viewportW = target.width;
+					drawOptions.viewportH = target.height;
+					drawOptions.targetFramebuffer = target.framebuffer;
+				}
+				return resized;
+			},
+			render(input) {
+				if (input.origin !== void 0 && (input.origin.length !== 2 || !input.origin.every(Number.isFinite)) || !Number.isFinite(input.time) || !Number.isFinite(input.delta) || input.time < 0 || input.delta < 0) return fail("INVALID_RENDER_INPUT", "Particle time and delta must be finite and non-negative.", "render-input");
+				if (!input.restart && lastTime !== null) {
+					if (input.time < lastTime) return fail("INVALID_RENDER_INPUT", "Particle time must be monotonic unless restart is set.", "time");
+					if (Math.abs(input.delta - (input.time - lastTime)) > 1e-6) return fail("INVALID_RENDER_INPUT", "Particle delta must reconcile with caller time.", "time-delta");
+				}
+				const current = state();
+				if (current) return current;
+				if (producerDisposed) return fail("DISPOSED", "The Godot particle producer has been disposed.");
+				if (!target.texture || !target.framebuffer) {
+					const resized = resizeTarget(target, requestedWidth, requestedHeight);
+					if (!resized.ok) return resized;
+				}
+				if (!dependencyLive(sprite)) return fail("FOREIGN_TARGET", "Particle sprite texture is no longer live.", "sprite-texture");
+				if (!dependencyLive(lut)) return fail("FOREIGN_TARGET", "Particle LUT texture is no longer live.", "lut-texture");
+				if (!dependencyLive(mask)) return fail("FOREIGN_TARGET", "Particle mask texture is no longer live.", "mask-texture");
+				const ready = ensure();
+				if (!ready.ok) return ready;
+				drawOptions.viewportW = target.width;
+				drawOptions.viewportH = target.height;
+				drawOptions.targetFramebuffer = target.framebuffer;
+				if (!prepareParticleDraw(gl, ready.value, drawOptions)) return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not allocate the additive particle target.");
+				if (input.restart) {
+					reset();
+					preprocessed = false;
+				}
+				preprocess();
+				scratch.state.emitting = input.emitting;
+				simulateParticles(scratch.state, input.delta);
+				lastTime = input.time;
+				const buffer = scratch.instances;
+				packing.textureWidth = semanticConfig.textureWidth > 0 ? semanticConfig.textureWidth : sprite?.width ?? 16;
+				packing.textureHeight = semanticConfig.textureHeight > 0 ? semanticConfig.textureHeight : sprite?.height ?? 16;
+				packing.origin = input.origin;
+				packParticleInstances(packing);
+				const previous = gl.getParameter(gl.FRAMEBUFFER_BINDING);
+				try {
+					gl.bindFramebuffer(gl.FRAMEBUFFER, target.framebuffer);
+					gl.viewport(0, 0, target.width, target.height);
+					gl.disable(gl.SCISSOR_TEST);
+					gl.clearColor(0, 0, 0, 0);
+					gl.clear(gl.COLOR_BUFFER_BIT);
+					if (buffer.count === 0) return rendered;
+					if (!drawParticles(particleGl, ready.value, buffer, drawOptions)) return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not allocate the additive particle target.");
+					return rendered;
+				} finally {
+					gl.bindFramebuffer(gl.FRAMEBUFFER, previous);
+				}
+			},
+			invalidate() {
+				if (program) releaseParticleProgram(gl);
+				program = null;
+				if (quad) gl.deleteBuffer(quad);
+				quad = null;
+				if (ownsScratch) disposeParticleInstanceBuffer(gl, scratch.instances);
+				discardTarget(target, true);
+			},
+			invalidateContextLoss() {
+				if (program) releaseParticleProgram(gl, true);
+				program = null;
+				quad = null;
+				invalidateParticleInstanceBuffer(gl, scratch.instances);
+				discardTarget(target, false);
+			},
+			dispose() {
+				if (!producerDisposed) {
+					producerDisposed = true;
+					producer.invalidate();
+					targets.delete(target);
+					invalidatables.delete(producer);
+				}
+			}
+		};
+		invalidatables.add(producer);
+		return ok(producer);
+	}
+	function createGodotParticleDirectPass(pass) {
+		const invalid = state();
+		if (invalid) return invalid;
+		if (!pass.config && !pass.scratch) return fail("UNSUPPORTED_PARTICLE_FEATURE", "A particle pass needs config or caller-owned scratch.", "config");
+		if (pass.scratch && pass.config) return fail("UNSUPPORTED_PARTICLE_FEATURE", "When scratch is supplied, omit config: scratch is the semantic owner.", "scratch-config");
+		const config = pass.scratch ? pass.scratch.config : normalizeParticleRenderConfig(pass.config);
+		const sprite = pass.spriteTexture ? textureInputFor(pass.spriteTexture) : null;
+		const lut = pass.lutTexture ? textureInputFor(pass.lutTexture) : null;
+		const mask = pass.maskTexture ? textureInputFor(pass.maskTexture) : null;
+		if (pass.spriteTexture && !sprite) return fail("FOREIGN_TARGET", "A textured particle system needs a live sprite target owned by this stage.", "sprite-texture");
+		if (pass.lutTexture && !lut || pass.maskTexture && !mask) return fail("FOREIGN_TARGET", "Particle auxiliary textures must be live targets owned by this stage.", "auxiliary-texture");
+		const unsupported = [
+			"collision",
+			"attractors",
+			"trails",
+			"customMaterial"
+		].find((feature) => pass.features?.[feature]);
+		if (unsupported) return fail("UNSUPPORTED_PARTICLE_FEATURE", `Headless Godot particles do not support ${unsupported}.`, unsupported);
+		if (config.emissionShape === 4 || config.emissionShape === 5) return fail("UNSUPPORTED_PARTICLE_FEATURE", "Point-list and directed-point emission require their authored point data.", "emission-shape");
+		const scratch = pass.scratch ?? createGodotParticleScratch(config);
+		const ownsScratch = !pass.scratch;
+		if (scratch.instances.data.length / 10 < scratch.state.count) return fail("UNSUPPORTED_PARTICLE_FEATURE", "Scratch cannot hold the configured particle count.", "scratch-capacity");
+		const semanticConfig = scratch.config;
+		const packing = {
+			state: scratch.state,
+			config: semanticConfig,
+			instances: scratch.instances,
+			textureWidth: 0,
+			textureHeight: 0,
+			origin: void 0,
+			transform: void 0,
+			modulate: void 0
+		};
+		let program = null;
+		let quad = null;
+		let disposedProducer = false;
+		let preprocessed = false;
+		let lastTime = null;
+		const particleGl = {
+			gl,
+			quad: null
+		};
+		const drawOptions = {
+			texture: sprite?.texture ?? null,
+			textured: Boolean(sprite),
+			lutTexture: lut?.texture ?? null,
+			maskTexture: mask?.texture ?? null,
+			hframes: semanticConfig.hframes,
+			vframes: semanticConfig.vframes,
+			blendMode: semanticConfig.blendMode,
+			viewportW: 1,
+			viewportH: 1,
+			alphaFromRed: semanticConfig.alphaFromRed,
+			erode: semanticConfig.alphaErode,
+			uvPolar: semanticConfig.uvPolar,
+			targetFramebuffer: null,
+			additiveResolveIntoExisting: true
+		};
+		let readyResult = null;
+		const ensure = () => {
+			if (program) return readyResult;
+			const compiled = acquireParticleProgram(gl);
+			if (!compiled) return fail("SHADER_COMPILE_FAILED", "WebGL could not compile the shared Godot particle renderer.");
+			quad = gl.createBuffer();
+			if (!quad) {
+				releaseParticleProgram(gl);
+				return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not allocate the particle resolve quad.");
+			}
+			gl.bindBuffer(gl.ARRAY_BUFFER, quad);
+			gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+				-1,
+				-1,
+				1,
+				-1,
+				-1,
+				1,
+				1,
+				1
+			]), gl.STATIC_DRAW);
+			program = compiled;
+			particleGl.quad = quad;
+			readyResult = ok(compiled);
+			return readyResult;
+		};
+		const dependencyLive = (value) => !(value && (value.owned ? !targets.has(value.owned) || !value.owned.texture || !value.owned.framebuffer : typeof gl.isTexture === "function" && !gl.isTexture(value.texture)));
+		const reset = () => {
+			const state = scratch.state;
+			state.time = 0;
+			state.cycle = 0;
+			state.remainder = 0;
+			state.emitting = true;
+			for (const particle of state.particles) particle.active = false;
+		};
+		const preprocess = () => {
+			if (preprocessed) return;
+			preprocessParticles(scratch.state);
+			preprocessed = true;
+		};
+		const producer = {
+			scratch,
+			warmUp() {
+				const current = state();
+				if (current) return current;
+				if (disposedProducer) return fail("DISPOSED", "The Godot particle pass has been disposed.");
+				const ready = ensure();
+				if (!ready.ok) return ready;
+				if (!prepareParticleDraw(gl, ready.value, drawOptions) || false) return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not prepare particle draw resources.");
+				preprocess();
+				return ok(void 0);
+			},
+			draw(input, context) {
+				if (input.origin !== void 0 && (input.origin.length !== 2 || !input.origin.every(Number.isFinite)) || !Number.isFinite(input.time) || !Number.isFinite(input.delta) || input.time < 0 || input.delta < 0 || !Number.isFinite(context.width) || !Number.isFinite(context.height) || context.width <= 0 || context.height <= 0) return fail("INVALID_RENDER_INPUT", "Particle time, delta, and target dimensions must be finite and positive.", "render-input");
+				const transform = directParticleTransform(input.transform);
+				if (!transform) return fail("UNSUPPORTED_PARTICLE_FEATURE", "Direct particles require a finite uniform-scale rotation and translation transform.", "transform");
+				const modulate = directParticleModulate(input.modulate);
+				if (!modulate) return fail("INVALID_RENDER_INPUT", "Direct particle modulation components must be finite.", "modulate");
+				if (!input.restart && lastTime !== null) {
+					if (input.time < lastTime) return fail("INVALID_RENDER_INPUT", "Particle time must be monotonic unless restart is set.", "time");
+					if (Math.abs(input.delta - (input.time - lastTime)) > 1e-6) return fail("INVALID_RENDER_INPUT", "Particle delta must reconcile with caller time.", "time-delta");
+				}
+				const current = state();
+				if (current) return current;
+				if (disposedProducer) return fail("DISPOSED", "The Godot particle pass has been disposed.");
+				if (!dependencyLive(sprite)) return fail("FOREIGN_TARGET", "Particle sprite texture is no longer live.", "sprite-texture");
+				if (!dependencyLive(lut)) return fail("FOREIGN_TARGET", "Particle LUT texture is no longer live.", "lut-texture");
+				if (!dependencyLive(mask)) return fail("FOREIGN_TARGET", "Particle mask texture is no longer live.", "mask-texture");
+				const ready = ensure();
+				if (!ready.ok) return ready;
+				drawOptions.viewportW = Math.floor(context.width);
+				drawOptions.viewportH = Math.floor(context.height);
+				drawOptions.targetFramebuffer = context.framebuffer;
+				if (!prepareParticleDraw(gl, ready.value, drawOptions)) return fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not allocate the shared additive particle target.");
+				if (input.restart) {
+					reset();
+					preprocessed = false;
+				}
+				preprocess();
+				scratch.state.emitting = input.emitting;
+				simulateParticles(scratch.state, input.delta);
+				lastTime = input.time;
+				const buffer = scratch.instances;
+				packing.textureWidth = semanticConfig.textureWidth > 0 ? semanticConfig.textureWidth : sprite?.width ?? 16;
+				packing.textureHeight = semanticConfig.textureHeight > 0 ? semanticConfig.textureHeight : sprite?.height ?? 16;
+				packing.origin = input.origin;
+				packing.transform = transform;
+				packing.modulate = modulate;
+				packParticleInstances(packing);
+				if (buffer.count === 0) return ok(void 0);
+				gl.bindFramebuffer(gl.FRAMEBUFFER, context.framebuffer);
+				gl.viewport(0, 0, drawOptions.viewportW, drawOptions.viewportH);
+				return drawParticles(particleGl, ready.value, buffer, drawOptions) ? ok(void 0) : fail("RESOURCE_ALLOCATION_FAILED", "WebGL could not draw the shared particle pass.");
+			},
+			invalidate() {
+				if (program) releaseParticleProgram(gl);
+				program = null;
+				readyResult = null;
+				if (quad) gl.deleteBuffer(quad);
+				quad = null;
+				particleGl.quad = null;
+				if (ownsScratch) disposeParticleInstanceBuffer(gl, scratch.instances);
+			},
+			invalidateContextLoss() {
+				if (program) releaseParticleProgram(gl, true);
+				program = null;
+				readyResult = null;
+				quad = null;
+				particleGl.quad = null;
+				invalidateParticleInstanceBuffer(gl, scratch.instances);
+			},
+			dispose() {
+				if (disposedProducer) return;
+				disposedProducer = true;
+				producer.invalidate();
+				invalidatables.delete(producer);
+			}
+		};
+		invalidatables.add(producer);
+		return ok(producer);
+	}
+	return {
+		gl,
+		createShaderProducer,
+		createGodotShaderProducer,
+		createParticleProducer,
+		createGodotParticleProducer,
+		createGodotParticleDirectPass,
+		executeScreenSample(command) {
+			const current = state();
+			if (current) return current;
+			const source = targetFor(command.source);
+			const destination = targetFor(command.destination);
+			if (!source?.texture || !source.framebuffer || !destination?.texture || !destination.framebuffer) return fail("FOREIGN_TARGET", "Screen sample commands require live targets owned by this headless effects stage.");
+			if (source === destination) {
+				const captured = snapshotFor(source);
+				if (!captured.ok) return captured;
+				copy(captured.value, destination, command.filter ?? "nearest");
+			} else copy(source, destination, command.filter ?? "nearest");
+			return ok(void 0);
+		},
+		invalidate() {
+			for (const item of [...invalidatables]) item.invalidate();
+			if (snapshot) discardTarget(snapshot, true);
+			if (opaqueWhite) discardTarget(opaqueWhite, true);
+			opaqueWhiteFilled = false;
+			opaqueWhiteResult = null;
+		},
+		invalidateContextLoss() {
+			for (const item of [...invalidatables]) item.invalidateContextLoss();
+			if (snapshot) discardTarget(snapshot, false);
+			if (opaqueWhite) discardTarget(opaqueWhite, false);
+			opaqueWhiteFilled = false;
+			opaqueWhiteResult = null;
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			for (const item of [...invalidatables]) item.dispose();
+			if (snapshot) discardTarget(snapshot, true);
+			if (opaqueWhite) discardTarget(opaqueWhite, true);
+			snapshot = null;
+			opaqueWhite = null;
+			opaqueWhiteFilled = false;
+			opaqueWhiteResult = null;
+			targets.clear();
+		}
+	};
+}
+//#endregion
+export { MAX_HEADLESS_PARTICLES, blendFactorsFor, clearWebglSurface, compileProgram, compileProgramAsync, createGodotParticleScratch, createHeadlessEffectsStage, createWebglFullscreenQuad, createWebglPlaceholderTexture, createWebglTexture, deleteWebglTexture, disposeParticleInstanceBuffer, drawGodotWebglShaderFrame, drawParticles, getParticleProgram, invalidateParticleInstanceBuffer, prepareParticleDraw, startProgram, uploadGodotShaderUniform, uploadWebglTexture };
+
+//# sourceMappingURL=webgl.mjs.map