@godot-scene-web/effects 0.1.0

package/dist/shaders/index.js

@@ -0,0 +1,1664 @@
+//#region src/shaders/godot-shader.ts
+var UnsupportedShaderError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnsupportedShaderError";
+	}
+};
+async function expandGodotShaderIncludes(source, resolveInclude, seen = /* @__PURE__ */ new Set(), depth = 0) {
+	if (depth > 16) throw new UnsupportedShaderError("shader include depth exceeded");
+	const includePattern = /^[ \t]*#include\s+"([^"]+)"[ \t]*$/gm;
+	const chunks = [];
+	let lastIndex = 0;
+	for (const match of source.matchAll(includePattern)) {
+		const index = match.index ?? 0;
+		chunks.push(source.slice(lastIndex, index));
+		const includePath = match[1];
+		if (seen.has(includePath)) chunks.push(`\n/* skipped recursive include ${includePath} */\n`);
+		else {
+			const included = await resolveInclude(includePath);
+			if (included === void 0) chunks.push(match[0]);
+			else {
+				const nextSeen = new Set(seen);
+				nextSeen.add(includePath);
+				chunks.push(await expandGodotShaderIncludes(included, resolveInclude, nextSeen, depth + 1));
+			}
+		}
+		lastIndex = index + match[0].length;
+	}
+	chunks.push(source.slice(lastIndex));
+	return chunks.join("");
+}
+const UNSUPPORTED_BUILTINS = [
+	"FRAGCOORD",
+	"NORMAL",
+	"NORMAL_TEXTURE",
+	"POINT_COORD",
+	"VERTEX",
+	"INSTANCE_ID",
+	"INSTANCE_CUSTOM",
+	"SPECULAR_SHININESS",
+	"LIGHT",
+	"LIGHT_COLOR",
+	"AT_LIGHT_PASS",
+	"CUSTOM0",
+	"CUSTOM1"
+];
+const GLSL_SAMPLER_TYPES = new Set(["sampler2D"]);
+const SCALAR_OR_VECTOR = /^(float|int|bool|vec2|vec3|vec4|mat2|mat3|mat4|ivec2|ivec3|ivec4|bvec2|bvec3|bvec4)$/;
+/** Transpile a `.gdshader` source string. Throws `UnsupportedShaderError`. */
+function transpileGodotShader(source) {
+	const parsed = parseShader(sanitizeReservedIdentifiers(stripComments(unwrapShaderResource(source))));
+	rejectUnsupported(shaderLogic(parsed), parsed);
+	const analysis = analyzeShader(parsed);
+	return {
+		vertexGlsl: VERTEX_GLSL,
+		fragmentGlsl: assembleFragment({
+			parsed,
+			analysis,
+			varyingLocals: analysis.varyingHoists.map((v) => `${v.type} ${v.name} = ${v.expr};`)
+		}),
+		uniforms: parsed.uniforms,
+		samplers: parsed.samplers,
+		blend: parsed.blend,
+		usesTime: analysis.usesTime,
+		usesTexturePixelSize: analysis.usesTexturePixelSize,
+		usesScreenUv: analysis.usesScreenUv,
+		usesScreenTexture: analysis.usesScreenTexture,
+		usesScreenPixelSize: analysis.usesScreenPixelSize
+	};
+}
+const VERTEX_GLSL = `#version 300 es
+in vec2 a_pos;
+out vec2 v_uv;
+void main() {
+  v_uv = a_pos * 0.5 + 0.5;
+  gl_Position = vec4(a_pos, 0.0, 1.0);
+}
+`;
+function assembleFragment(input) {
+	const { parsed, analysis } = input;
+	const decls = [
+		"uniform sampler2D TEXTURE;",
+		"uniform vec2 _godot_uv_fit;",
+		"uniform vec4 _godot_uv_window;",
+		...analysis.usesTime ? ["uniform float TIME;"] : [],
+		...analysis.usesTexturePixelSize ? ["uniform vec2 TEXTURE_PIXEL_SIZE;"] : [],
+		...analysis.needsModulate ? ["uniform vec4 MODULATE;"] : [],
+		...analysis.usesScreenUv ? ["uniform vec2 _godot_screen_origin;", "uniform vec2 _godot_screen_size;"] : [],
+		...analysis.usesScreenTexture ? ["uniform sampler2D SCREEN_TEXTURE;", ...parsed.screenTextureNames.filter((name) => name !== "SCREEN_TEXTURE").map((name) => `#define ${name} SCREEN_TEXTURE`)] : [],
+		...analysis.usesScreenPixelSize ? ["uniform vec2 SCREEN_PIXEL_SIZE;"] : [],
+		...analysis.usesPi ? ["const float PI = 3.141592653589793;"] : []
+	];
+	for (const u of parsed.uniforms) decls.push(`uniform ${u.type} ${u.name}${u.arrayLength ? `[${u.arrayLength}]` : ""};`);
+	for (const s of parsed.samplers) decls.push(`uniform sampler2D ${s.name};`);
+	const helpers = promoteIntLiterals(parsed.helpers, parsed.intIdentifiers).trim();
+	const body = promoteIntLiterals(parsed.fragmentBody, parsed.intIdentifiers);
+	return `#version 300 es
+precision highp float;
+in vec2 v_uv;
+out vec4 fragColor;
+${decls.join("\n")}
+${helpers ? `${helpers}\n` : ""}
+void main() {
+  vec2 GODOT_UV = _godot_uv_window.xy + vec2(v_uv.x, 1.0 - v_uv.y) * _godot_uv_window.zw;
+  vec2 UV = (GODOT_UV - 0.5) / _godot_uv_fit + 0.5;
+${analysis.usesScreenUv ? "  vec2 SCREEN_UV = _godot_screen_origin + GODOT_UV * _godot_screen_size;\n" : ""}  vec4 COLOR = ${analysis.opaqueColor ? "vec4(texture(TEXTURE, UV).rgb, 1.0)" : "texture(TEXTURE, UV)"};
+${input.varyingLocals.map((l) => `  ${l}`).join("\n")}
+${indent(body)}
+${analysis.autoModulate ? "  COLOR *= MODULATE;" : ""}
+  // PREMULTIPLIED. The shared canvas declares \`premultipliedAlpha: true\` (webgl/shared-gl.ts), so
+  // this is THE canvas contract: return rgb*a with a. The shader backend draws with BLEND OFF, so
+  // whatever this writes IS the buffer — returning straight COLOR here halos every partially
+  // transparent node, and neither the compiler nor a readback of the canvas would say so.
+  // Character-for-character the WGSL emitter's return (webgpu/transpile-wgsl.ts), on purpose: one
+  // contract, two languages.
+  fragColor = vec4(COLOR.rgb * COLOR.a, COLOR.a);
+}
+`;
+}
+/** The text every built-in flag is scanned over. The vertex body and the top-level
+*  helpers count, not just `fragment()`: a helper may read TIME/PI, and a varying
+*  computed in `vertex()` is hoisted into the fragment. `rejectUnsupported` must be
+*  given this same region, or a guard would scan less text than the flags did. */
+function shaderLogic(parsed) {
+	return `${parsed.helpers}\n${parsed.vertexBody ?? ""}\n${parsed.fragmentBody}`;
+}
+/** Derive the emitter-neutral facts about a parsed shader (see `ShaderAnalysis`).
+*  Pure, and deliberately NOT a validator: run `rejectUnsupported(analysis.logic,
+*  parsed)` for that, before analyzing, so an unsupported built-in outranks a
+*  varying-hoist complaint. Throws `UnsupportedShaderError` only for a `vertex()`
+*  body that cannot be reduced to constant varying assignments. */
+function analyzeShader(parsed) {
+	const logic = shaderLogic(parsed);
+	const usesTime = hasToken(logic, "TIME");
+	const usesTexturePixelSize = hasToken(logic, "TEXTURE_PIXEL_SIZE");
+	const usesScreenUv = hasToken(logic, "SCREEN_UV");
+	const usesScreenTexture = hasToken(logic, "SCREEN_TEXTURE") || parsed.screenTextureNames.some((name) => hasToken(logic, name));
+	const usesScreenPixelSize = hasToken(logic, "SCREEN_PIXEL_SIZE");
+	const usesPi = hasToken(logic, "PI");
+	const usesModulateBuiltin = hasToken(parsed.fragmentBody, "MODULATE");
+	const vertexReadsModulate = parsed.vertexBody !== null && hasToken(parsed.vertexBody, "COLOR");
+	const overwritesColorRgb = /\bCOLOR(\.rgb)?\s*=(?!=)/.test(parsed.fragmentBody);
+	const bodyReadsColor = hasToken(parsed.fragmentBody.replace(/\bCOLOR(?:\.[rgba]+)?\s*=(?!=)/g, ""), "COLOR");
+	const pureFillOverwrite = overwritesColorRgb && !bodyReadsColor;
+	const autoModulate = !usesModulateBuiltin && !vertexReadsModulate && !pureFillOverwrite;
+	const usesColorAlpha = /\bCOLOR\.a\b/.test(parsed.fragmentBody);
+	const samplesNodeTexture = hasToken(parsed.fragmentBody, "TEXTURE");
+	const opaqueColor = pureFillOverwrite && !usesColorAlpha && !samplesNodeTexture;
+	const varyingHoists = buildVaryingHoists(parsed);
+	return {
+		logic,
+		usesTime,
+		usesTexturePixelSize,
+		usesScreenUv,
+		usesScreenTexture,
+		usesScreenPixelSize,
+		usesPi,
+		needsModulate: usesModulateBuiltin || autoModulate || varyingHoists.length > 0,
+		autoModulate,
+		opaqueColor,
+		varyingHoists
+	};
+}
+function buildVaryingHoists(parsed) {
+	if (parsed.vertexBody === null || parsed.varyings.length === 0) return [];
+	const typeByName = new Map(parsed.varyings.map((v) => [v.name, v.type]));
+	const hoists = [];
+	const statements = parsed.vertexBody.split(";").map((s) => s.trim()).filter(Boolean);
+	for (const statement of statements) {
+		const eq = statement.indexOf("=");
+		if (eq < 0) throw new UnsupportedShaderError(`vertex(): only constant varying assignments are supported, got "${statement}"`);
+		const lhs = statement.slice(0, eq).trim();
+		const rhs = statement.slice(eq + 1).trim();
+		const type = typeByName.get(lhs);
+		if (!type) throw new UnsupportedShaderError(`vertex(): assignment to non-varying "${lhs}" is not supported`);
+		const expr = replaceToken(promoteIntLiterals(rhs), "COLOR", "MODULATE");
+		hoists.push({
+			type,
+			name: lhs,
+			expr
+		});
+	}
+	return hoists;
+}
+/** Parse cleaned Godot source (run `stripComments` + `sanitizeReservedIdentifiers`
+*  first) into the emitter-neutral `ParsedShader`. Throws `UnsupportedShaderError`. */
+function parseShader(src) {
+	const shaderType = /shader_type\s+([a-z_]+)\s*;/.exec(src);
+	if (!shaderType) throw new UnsupportedShaderError("missing shader_type declaration");
+	if (shaderType[1] !== "canvas_item") throw new UnsupportedShaderError(`unsupported shader_type "${shaderType[1]}" (only canvas_item)`);
+	const blend = parseBlendMode(src);
+	const { uniforms, samplers, screenTextureNames } = parseUniforms(src);
+	const varyings = parseVaryings(src);
+	const fragment = extractFunction(src, "fragment");
+	if (fragment === null) throw new UnsupportedShaderError("missing fragment() function");
+	const vertex = extractFunction(src, "vertex");
+	let helpers = src.replace(/shader_type\s+[a-z_]+\s*;/g, "").replace(/render_mode[^;]*;/g, "").replace(/uniform[^;]*;/g, "").replace(/varying[^;]*;/g, "");
+	helpers = removeFunction(helpers, "fragment");
+	helpers = removeFunction(helpers, "vertex");
+	const stray = RESOURCE_SECTION_RE.exec(helpers);
+	if (stray) throw new UnsupportedShaderError(`source is a Godot resource container, not shader code (found "${stray[0]}")`);
+	return {
+		blend,
+		uniforms,
+		samplers,
+		screenTextureNames,
+		varyings,
+		vertexBody: vertex,
+		fragmentBody: fragment,
+		helpers: helpers.trim(),
+		intIdentifiers: parseIntIdentifiers(src, uniforms)
+	};
+}
+function parseBlendMode(src) {
+	const match = /render_mode\s+([^;]+);/.exec(src);
+	if (!match) return "mix";
+	const modes = match[1].split(",").map((m) => m.trim());
+	for (const mode of modes) {
+		if (mode === "blend_add") return "add";
+		if (mode === "blend_sub") return "sub";
+		if (mode === "blend_mul") return "mul";
+		if (mode === "blend_premul_alpha") return "premul_alpha";
+		if (mode === "blend_mix") return "mix";
+	}
+	return "mix";
+}
+function parseUniforms(src) {
+	const uniforms = [];
+	const samplers = [];
+	const screenTextureNames = [];
+	for (const match of src.matchAll(/uniform\s+([a-zA-Z0-9_]+)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*([^;]*);/g)) {
+		const type = match[1];
+		const name = match[2];
+		const rest = match[3].trim();
+		const arrayLength = parseArrayLength(rest, src);
+		if (GLSL_SAMPLER_TYPES.has(type)) {
+			if (/\bhint_screen_texture\b/.test(rest)) {
+				screenTextureNames.push(name);
+				continue;
+			}
+			samplers.push({
+				name,
+				repeat: /\brepeat_enable\b/.test(rest)
+			});
+			continue;
+		}
+		if (!SCALAR_OR_VECTOR.test(type)) throw new UnsupportedShaderError(`unsupported uniform type "${type}"`);
+		uniforms.push({
+			type,
+			name,
+			...arrayLength ? { arrayLength } : {},
+			default: parseUniformDefault(rest)
+		});
+	}
+	return {
+		uniforms,
+		samplers,
+		screenTextureNames
+	};
+}
+function parseArrayLength(rest, src) {
+	const match = /^\[\s*([^\]]+)\s*\]/.exec(rest);
+	if (!match) return;
+	const constants = parseConstInts(src);
+	const expr = match[1].replace(/[A-Za-z_][A-Za-z0-9_]*/g, (name) => constants.has(name) ? String(constants.get(name)) : "NaN");
+	if (!/^[0-9+\-*/ ().NaN]+$/.test(expr)) return;
+	try {
+		const value = Function(`"use strict"; return (${expr});`)();
+		return Number.isFinite(value) && value > 0 ? Math.round(value) : void 0;
+	} catch {
+		return;
+	}
+}
+function parseConstInts(src) {
+	const out = /* @__PURE__ */ new Map();
+	for (const match of src.matchAll(/\bconst\s+int\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(-?\d+)\s*;/g)) out.set(match[1], Number.parseInt(match[2], 10));
+	return out;
+}
+function parseIntIdentifiers(src, uniforms) {
+	const out = new Set(uniforms.filter((u) => u.type === "int").map((u) => u.name));
+	for (const match of src.matchAll(/\b(?:const\s+)?int\s+([A-Za-z_][A-Za-z0-9_]*)/g)) out.add(match[1]);
+	return out;
+}
+function parseUniformDefault(rest) {
+	const eq = rest.indexOf("=");
+	if (eq < 0) return;
+	const value = rest.slice(eq + 1).trim();
+	const ctor = /^[a-z0-9]*vec[234]\s*\(([^)]*)\)$/.exec(value);
+	if (ctor) return ctor[1].split(",").map((c) => scalarLiteral(c.trim()) ?? NaN);
+	return scalarLiteral(value);
+}
+function scalarLiteral(value) {
+	if (value === "true") return 1;
+	if (value === "false") return 0;
+	const num = Number.parseFloat(value);
+	return Number.isFinite(num) ? num : void 0;
+}
+function parseVaryings(src) {
+	const out = [];
+	for (const match of src.matchAll(/varying\s+([a-zA-Z0-9_]+)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*;/g)) out.push({
+		type: match[1],
+		name: match[2]
+	});
+	return out;
+}
+/** Throw `UnsupportedShaderError` for constructs no emitter supports. Give it
+*  `shaderLogic(parsed)` — the same region the analysis flags are scanned over. */
+function rejectUnsupported(logic, parsed) {
+	for (const builtin of UNSUPPORTED_BUILTINS) if (hasToken(logic, builtin)) throw new UnsupportedShaderError(`unsupported built-in "${builtin}"`);
+	if (/\bwhile\b/.test(logic)) throw new UnsupportedShaderError("while loops are not supported");
+	if (/\b(uint|uvec[234])\b/.test(logic)) throw new UnsupportedShaderError("unsigned integer variables are not supported");
+}
+/** The escapes Godot writes into a `.tres` string literal. */
+function unescapeResourceString(text) {
+	return text.replace(/\\(u[0-9a-fA-F]{4}|[\s\S])/g, (_all, esc) => {
+		if (esc[0] === "u") return String.fromCharCode(Number.parseInt(esc.slice(1), 16));
+		switch (esc) {
+			case "n": return "\n";
+			case "t": return "	";
+			case "r": return "\r";
+			case "b": return "\b";
+			case "f": return "\f";
+			default: return esc;
+		}
+	});
+}
+/**
+* The shader source inside a Godot text-resource container, or `source` unchanged.
+*
+* Throws {@link UnsupportedShaderError} for a container with no usable `code` property —
+* NEVER returns the container. That refusal is the whole point: before it existed, every
+* parse step happened to succeed against a `.tres` (the `shader_type`, the `uniform`
+* declarations and the `fragment()` body all match INSIDE the escaped `code` string), and
+* then the subtractive `helpers` residual in `parseShader` carried the entire container
+* into the emitted GLSL — declarations, then `[gd_resource type="VisualShader" …` as the
+* first line of what should have been shader code. The driver reported a syntax error at
+* a `[`, which is a long way from "this file is not a shader".
+*/
+function unwrapShaderResource(source) {
+	if (!/^\s*\[gd_resource\b/.test(source)) return source;
+	const match = /^code\s*=\s*"((?:[^"\\]|\\[\s\S])*)"/m.exec(source);
+	if (!match) throw new UnsupportedShaderError("Godot resource container has no `code` property (not a shader resource)");
+	const code = unescapeResourceString(match[1]).trim();
+	if (code === "") throw new UnsupportedShaderError("Godot resource container has an empty `code` property");
+	return code;
+}
+/** Sections that can only come from a resource container — never legal shader source. */
+const RESOURCE_SECTION_RE = /\[(?:gd_resource|sub_resource|ext_resource|resource)\b/;
+function stripComments(src) {
+	return src.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, "");
+}
+function sanitizeReservedIdentifiers(src) {
+	return replaceToken(src, "input", "inputValue");
+}
+function extractFunction(src, name) {
+	const head = new RegExp(`void\\s+${name}\\s*\\(\\s*\\)\\s*\\{`).exec(src);
+	if (!head) return null;
+	const open = head.index + head[0].length - 1;
+	const end = matchBrace(src, open);
+	return src.slice(open + 1, end);
+}
+function removeFunction(src, name) {
+	const head = new RegExp(`void\\s+${name}\\s*\\(\\s*\\)\\s*\\{`).exec(src);
+	if (!head) return src;
+	const end = matchBrace(src, head.index + head[0].length - 1);
+	return src.slice(0, head.index) + src.slice(end + 1);
+}
+/** Index of the `}` closing the `{` at `openIndex`. Brace depth only — enough for the
+*  supported subset, which has no braces inside strings (Godot shaders have none). */
+function matchBrace(src, openIndex) {
+	let depth = 0;
+	for (let i = openIndex; i < src.length; i += 1) if (src[i] === "{") depth += 1;
+	else if (src[i] === "}") {
+		depth -= 1;
+		if (depth === 0) return i;
+	}
+	throw new UnsupportedShaderError("unbalanced braces");
+}
+function promoteIntLiterals(src, intIdentifiers = []) {
+	const ranges = skipRanges(src);
+	const intNames = [...intIdentifiers];
+	return src.replace(/(?<![\w.])(\d+)(?![\w.])/g, (match, _digits, offset) => {
+		if (ranges.some(([start, end]) => offset >= start && offset < end)) return match;
+		if (intNames.length > 0 && isIntegerComparisonLiteral(src, offset, intNames)) return match;
+		return `${match}.0`;
+	});
+}
+function skipRanges(src) {
+	const ranges = [];
+	for (const re of [
+		/\[[^\]]*\]/g,
+		/\bfor\s*\([^)]*\)/g,
+		/\b(?:const\s+)?int\s+[^;]+;/g
+	]) for (const match of src.matchAll(re)) {
+		const index = match.index ?? 0;
+		ranges.push([index, index + match[0].length]);
+	}
+	return ranges;
+}
+function isIntegerComparisonLiteral(src, offset, tokens) {
+	let start = offset;
+	while (start > 0 && !";{}\n".includes(src[start - 1])) start -= 1;
+	let end = offset;
+	while (end < src.length && !";{}\n".includes(src[end])) end += 1;
+	const statement = src.slice(start, end);
+	const localOffset = offset - start;
+	const before = statement.slice(0, localOffset);
+	const after = statement.slice(localOffset + String(src.slice(offset).match(/^\d+/)?.[0] ?? "").length);
+	const comparison = "(?:==|!=|<=|>=|<|>)";
+	return tokens.some((token) => {
+		const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		return new RegExp(`\\b${escaped}\\b\\s*${comparison}\\s*$`).test(before) || new RegExp(`^\\s*${comparison}\\s*\\b${escaped}\\b`).test(after);
+	});
+}
+/** Whole-identifier match: `TIME` must not fire on `LIFETIME`, `COLOR` not on
+*  `COLOR_KEY`. Every built-in probe in this file goes through it. */
+function hasToken(src, token) {
+	return new RegExp(`(?<![\\w])${escapeRegExp(token)}(?![\\w])`).test(src);
+}
+/** Whole-identifier replace, same boundary rule as `hasToken`. */
+function replaceToken(src, token, replacement) {
+	return src.replace(new RegExp(`(?<![\\w])${escapeRegExp(token)}(?![\\w])`, "g"), replacement);
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function indent(text) {
+	return text.split("\n").map((line) => line.trim() ? `  ${line.trim()}` : "").join("\n");
+}
+//#endregion
+//#region src/shaders/transpile-wgsl.ts
+/** "WGSL can't, WebGL can." Thrown for shapes the GLSL emitter renders happily; the
+*  runtime answers it with a per-binding WebGL fallback, not with the CSS fallback. */
+var UnsupportedWgslShaderError = class extends UnsupportedShaderError {
+	constructor(message) {
+		super(message);
+		this.name = "UnsupportedWgslShaderError";
+	}
+};
+const VERTEX_ENTRY = "vs_main";
+const FRAGMENT_ENTRY = "fs_main";
+const BINDINGS = {
+	uniform: 0,
+	texture: 1,
+	textureSampler: 2,
+	userSamplersBase: 3
+};
+/** Transpile a `.gdshader` source string to one WGSL module plus its uniform layout.
+*  Throws `UnsupportedShaderError` (no backend can) or `UnsupportedWgslShaderError`
+*  (this backend can't — fall the binding back to WebGL). */
+function transpileGodotShaderWgsl(source) {
+	const parsed = parseShader(sanitizeReservedIdentifiers(stripComments(unwrapShaderResource(source))));
+	rejectUnsupported(shaderLogic(parsed), parsed);
+	const analysis = analyzeShader(parsed);
+	rejectScreenCapture(parsed, analysis);
+	const defines = extractDefines(parsed);
+	const renames = buildRenameMap(parsed, defines);
+	const plan = buildUniformPlan(parsed, analysis, renames);
+	const globals = (text) => applyGlobals(text, defines, renames, plan);
+	const helpersText = globals(parsed.helpers);
+	const bodyText = globals(parsed.fragmentBody);
+	rejectStrayDirectives(helpersText, bodyText);
+	rejectFragmentLocalsInHelpers(parsed.helpers, plan);
+	const ctx = createContext(parsed, plan, renames);
+	const helpers = translateHelpers(helpersText, ctx);
+	const fragmentCtx = childContext(ctx);
+	seedFragmentScope(fragmentCtx, analysis);
+	const bodyLines = translateBlock(bodyText, fragmentCtx);
+	return {
+		wgsl: assembleModule({
+			parsed,
+			analysis,
+			plan,
+			renames,
+			ctx,
+			helpers,
+			varyingLines: analysis.varyingHoists.map((hoist) => {
+				const name = renameOf(hoist.name, renames);
+				const type = localWgslType(hoist.type, `varying "${hoist.name}"`);
+				fragmentCtx.scope.set(name, type);
+				return `var ${name}: ${type} = ${translateExpr(globals(hoist.expr), fragmentCtx)};`;
+			}),
+			bodyLines
+		}),
+		vertexEntry: VERTEX_ENTRY,
+		fragmentEntry: FRAGMENT_ENTRY,
+		uniformStructSizeBytes: plan.layout.sizeBytes,
+		builtinOffsets: plan.builtinOffsets,
+		uniforms: plan.uniformFields,
+		samplers: parsed.samplers,
+		bindings: BINDINGS,
+		blend: parsed.blend,
+		usesTime: analysis.usesTime,
+		usesTexturePixelSize: analysis.usesTexturePixelSize,
+		usesScreenUv: analysis.usesScreenUv
+	};
+}
+const SCALAR_LAYOUT = {
+	f32: {
+		align: 4,
+		size: 4
+	},
+	i32: {
+		align: 4,
+		size: 4
+	},
+	u32: {
+		align: 4,
+		size: 4
+	},
+	vec2f: {
+		align: 8,
+		size: 8
+	},
+	vec2i: {
+		align: 8,
+		size: 8
+	},
+	vec3f: {
+		align: 16,
+		size: 12
+	},
+	vec3i: {
+		align: 16,
+		size: 12
+	},
+	vec4f: {
+		align: 16,
+		size: 16
+	},
+	vec4i: {
+		align: 16,
+		size: 16
+	},
+	mat2x2f: {
+		align: 8,
+		size: 16
+	},
+	mat3x3f: {
+		align: 16,
+		size: 48
+	},
+	mat4x4f: {
+		align: 16,
+		size: 64
+	}
+};
+function roundUp(multiple, value) {
+	return Math.ceil(value / multiple) * multiple;
+}
+/** Lay out a WGSL `var<uniform>` struct by the uniform address space rules: members keep
+*  DECLARATION ORDER (a reorder would silently move every offset a writer already holds),
+*  each is placed at the next multiple of its alignment, and the struct size is rounded up
+*  to the struct alignment. Arrays get an element stride of `roundUp(align(E), size(E))`,
+*  which the uniform address space additionally requires to be a multiple of 16 — so
+*  `array<vec3f, N>` and `array<vec4f, N>` are natively fine and `array<f32, N>` /
+*  `array<vec2f, N>` are refused (they would need per-element padding on the host side).
+*
+*  These are exactly WGSL's own natural layout rules, applied to the members in the order
+*  the module declares them, which is why the emitted struct carries no explicit padding
+*  members: the compiler computes the same offsets this function records. */
+function wgslStructLayout(fields) {
+	const members = [];
+	let offset = 0;
+	let structAlign = 16;
+	for (const field of fields) {
+		const base = SCALAR_LAYOUT[field.type];
+		if (!base) throw new UnsupportedWgslShaderError(`uniform type "${field.type}" has no WGSL uniform layout`);
+		let align = base.align;
+		let size = base.size;
+		if (field.arrayLength !== void 0) {
+			const stride = roundUp(base.align, base.size);
+			if (stride % 16 !== 0) throw new UnsupportedWgslShaderError(`uniform array "${field.name}" of ${field.type} needs a 16-byte element stride in the WGSL uniform address space (got ${stride}); array-of-scalar uniforms are deferred`);
+			align = Math.max(16, base.align);
+			size = stride * field.arrayLength;
+		}
+		offset = roundUp(align, offset);
+		members.push({
+			name: field.name,
+			type: field.type,
+			...field.arrayLength !== void 0 ? { arrayLength: field.arrayLength } : {},
+			offsetBytes: offset,
+			sizeBytes: size,
+			alignBytes: align
+		});
+		offset += size;
+		structAlign = Math.max(structAlign, align);
+	}
+	return {
+		members,
+		sizeBytes: roundUp(structAlign, offset),
+		alignBytes: structAlign
+	};
+}
+function rejectScreenCapture(parsed, analysis) {
+	if (parsed.screenTextureNames.length > 0) throw new UnsupportedWgslShaderError(`hint_screen_texture sampler "${parsed.screenTextureNames[0]}" is not supported on WebGPU: capturing what was already composited is a runtime architecture question, so this binding falls back to WebGL`);
+	if (analysis.usesScreenTexture) throw new UnsupportedWgslShaderError("SCREEN_TEXTURE is not supported on WebGPU: capturing what was already composited is a runtime architecture question, so this binding falls back to WebGL");
+	if (analysis.usesScreenPixelSize) throw new UnsupportedWgslShaderError("SCREEN_PIXEL_SIZE is not supported on WebGPU: it sizes the screen capture, which this backend does not produce");
+}
+/** Simple `#define A B` token aliases, pulled out of the helper text so they can be
+*  substituted (WGSL has no preprocessor). Anything more than a single-token alias is
+*  named and refused. */
+function extractDefines(parsed) {
+	const out = [];
+	for (const match of parsed.helpers.matchAll(/^[ \t]*#define\s+([A-Za-z_]\w*)\s+([^\n]*)$/gm)) {
+		const value = match[2].trim();
+		if (!/^[A-Za-z_]\w*$/.test(value)) throw new UnsupportedWgslShaderError(`#define "${match[1]}" is not a simple token alias and WGSL has no preprocessor`);
+		out.push([match[1], value]);
+	}
+	return out;
+}
+function rejectStrayDirectives(helpers, body) {
+	for (const text of [helpers, body]) {
+		const stray = /^[ \t]*#\s*([a-z_]+)/m.exec(text);
+		if (stray) throw new UnsupportedWgslShaderError(`preprocessor directive "#${stray[1]}" has no WGSL equivalent`);
+	}
+}
+/** `UV` / `SCREEN_UV` / `COLOR` are fragment-LOCAL in both emitters (the GLSL one declares
+*  them inside `main()` too), so a top-level helper that reads one cannot be given them
+*  without inventing a calling convention. Refuse per-binding rather than emit a module
+*  that names an undeclared identifier. */
+function rejectFragmentLocalsInHelpers(helpers, plan) {
+	for (const token of [
+		"UV",
+		"SCREEN_UV",
+		"COLOR",
+		"GODOT_UV"
+	]) if (hasToken(helpers, token)) throw new UnsupportedWgslShaderError(`helper function reads the fragment-local built-in "${token}"`);
+	for (const name of plan.boolUniformNames) if (hasToken(helpers, name)) throw new UnsupportedWgslShaderError(`helper function reads the bool uniform "${name}", which is hoisted as a fragment-local alias (WGSL bool is not host-shareable)`);
+}
+const WGSL_RESERVED = new Set([
+	"alias",
+	"break",
+	"case",
+	"const",
+	"const_assert",
+	"continue",
+	"continuing",
+	"default",
+	"diagnostic",
+	"discard",
+	"else",
+	"enable",
+	"false",
+	"fn",
+	"for",
+	"if",
+	"let",
+	"loop",
+	"override",
+	"requires",
+	"return",
+	"struct",
+	"switch",
+	"true",
+	"var",
+	"while",
+	"NULL",
+	"Self",
+	"abstract",
+	"active",
+	"alignas",
+	"alignof",
+	"as",
+	"asm",
+	"asm_fragment",
+	"async",
+	"attribute",
+	"auto",
+	"await",
+	"become",
+	"binding_array",
+	"cast",
+	"catch",
+	"class",
+	"co_await",
+	"co_return",
+	"co_yield",
+	"coherent",
+	"column_major",
+	"common",
+	"compile",
+	"compile_fragment",
+	"concept",
+	"const_cast",
+	"consteval",
+	"constexpr",
+	"constinit",
+	"crate",
+	"debugger",
+	"decltype",
+	"delete",
+	"demote",
+	"demote_to_helper",
+	"do",
+	"dynamic_cast",
+	"enum",
+	"explicit",
+	"export",
+	"extends",
+	"extern",
+	"external",
+	"fallthrough",
+	"filter",
+	"final",
+	"finally",
+	"friend",
+	"from",
+	"fxgroup",
+	"get",
+	"goto",
+	"groupshared",
+	"highp",
+	"impl",
+	"implements",
+	"import",
+	"inline",
+	"instanceof",
+	"interface",
+	"layout",
+	"lowp",
+	"macro",
+	"macro_rules",
+	"match",
+	"mediump",
+	"meta",
+	"mod",
+	"module",
+	"move",
+	"mut",
+	"mutable",
+	"namespace",
+	"new",
+	"nil",
+	"noexcept",
+	"noinline",
+	"nointerpolation",
+	"non_coherent",
+	"noncoherent",
+	"noperspective",
+	"null",
+	"nullptr",
+	"of",
+	"operator",
+	"package",
+	"packoffset",
+	"partition",
+	"pass",
+	"patch",
+	"pixelfragment",
+	"precise",
+	"precision",
+	"premerge",
+	"priv",
+	"protected",
+	"pub",
+	"public",
+	"readonly",
+	"ref",
+	"regardless",
+	"register",
+	"reinterpret_cast",
+	"require",
+	"resource",
+	"restrict",
+	"self",
+	"set",
+	"shared",
+	"sizeof",
+	"smooth",
+	"snorm",
+	"static",
+	"static_assert",
+	"static_cast",
+	"std",
+	"subroutine",
+	"super",
+	"target",
+	"template",
+	"this",
+	"thread_local",
+	"throw",
+	"trait",
+	"try",
+	"type",
+	"typedef",
+	"typeid",
+	"typename",
+	"union",
+	"unless",
+	"unorm",
+	"unsafe",
+	"unsized",
+	"use",
+	"using",
+	"varying",
+	"virtual",
+	"volatile",
+	"wgsl",
+	"where",
+	"write",
+	"writeonly",
+	"yield"
+]);
+const EMITTER_OWNED = new Set([
+	"_u",
+	"Uniforms",
+	"VsOut",
+	"raw_uv",
+	VERTEX_ENTRY,
+	FRAGMENT_ENTRY,
+	"godot_mod",
+	"godot_mod2",
+	"godot_mod3",
+	"godot_mod4",
+	"godot_inverse3",
+	"TEXTURE_smp",
+	"GODOT_UV",
+	"uv_fit",
+	"uv_window",
+	"time",
+	"texture_pixel_size",
+	"modulate",
+	"screen_origin",
+	"screen_size"
+]);
+const RENAME_SUFFIX = "_gsw";
+function renameOf(name, renames) {
+	return renames.get(name) ?? name;
+}
+function buildRenameMap(parsed, defines) {
+	const text = `${parsed.helpers}\n${parsed.fragmentBody}`;
+	if (/(?<![\w])_swz\d*(?![\w])/.test(text)) throw new UnsupportedWgslShaderError("the identifier prefix \"_swz\" is reserved for swizzle-assignment temporaries");
+	const candidates = /* @__PURE__ */ new Set();
+	for (const match of text.matchAll(/(?<![\w])(?:const\s+)?(?:void|float|int|bool|uint|vec[234]|ivec[234]|bvec[234]|mat[234])\s+([A-Za-z_]\w*)/g)) candidates.add(match[1]);
+	for (const uniform of parsed.uniforms) candidates.add(uniform.name);
+	for (const sampler of parsed.samplers) candidates.add(sampler.name);
+	for (const varying of parsed.varyings) candidates.add(varying.name);
+	for (const [name] of defines) candidates.delete(name);
+	const renames = /* @__PURE__ */ new Map();
+	for (const name of candidates) if (WGSL_RESERVED.has(name) || EMITTER_OWNED.has(name)) renames.set(name, `${name}${RENAME_SUFFIX}`);
+	return renames;
+}
+/** The two whole-text passes every chunk of shader logic goes through before it is
+*  parsed statement by statement: resolve `#define` aliases and reserved-word renames,
+*  then bind every uniform / built-in read to its member of the one uniform struct. */
+function applyGlobals(text, defines, renames, plan) {
+	let out = text.replace(/^[ \t]*#define\s+[A-Za-z_]\w*\s+[^\n]*$/gm, "");
+	for (const [name, value] of defines) out = replaceToken(out, name, value);
+	for (const [from, to] of renames) out = replaceToken(out, from, to);
+	for (const [wgslName, member] of plan.memberByWgslName) {
+		if (plan.boolUniformNames.has(wgslName)) continue;
+		if (member.builtin) continue;
+		out = replaceToken(out, wgslName, `_u.${wgslName}`);
+	}
+	if (plan.builtinOffsets.time !== void 0) out = replaceToken(out, "TIME", "_u.time");
+	if (plan.builtinOffsets.texturePixelSize !== void 0) out = replaceToken(out, "TEXTURE_PIXEL_SIZE", "_u.texture_pixel_size");
+	if (plan.builtinOffsets.modulate !== void 0) out = replaceToken(out, "MODULATE", "_u.modulate");
+	return out;
+}
+const UNIFORM_WGSL_TYPE = {
+	float: "f32",
+	int: "i32",
+	bool: "f32",
+	vec2: "vec2f",
+	vec3: "vec3f",
+	vec4: "vec4f",
+	ivec2: "vec2i",
+	ivec3: "vec3i",
+	ivec4: "vec4i",
+	mat2: "mat2x2f",
+	mat3: "mat3x3f",
+	mat4: "mat4x4f"
+};
+function buildUniformPlan(parsed, analysis, renames) {
+	const members = [{
+		wgslName: "uv_window",
+		type: "vec4f",
+		builtin: true
+	}, {
+		wgslName: "uv_fit",
+		type: "vec2f",
+		builtin: true
+	}];
+	if (analysis.usesTime) members.push({
+		wgslName: "time",
+		type: "f32",
+		builtin: true
+	});
+	if (analysis.usesTexturePixelSize) members.push({
+		wgslName: "texture_pixel_size",
+		type: "vec2f",
+		builtin: true
+	});
+	if (analysis.usesScreenUv) {
+		members.push({
+			wgslName: "screen_origin",
+			type: "vec2f",
+			builtin: true
+		});
+		members.push({
+			wgslName: "screen_size",
+			type: "vec2f",
+			builtin: true
+		});
+	}
+	if (analysis.needsModulate) members.push({
+		wgslName: "modulate",
+		type: "vec4f",
+		builtin: true
+	});
+	const boolUniformNames = /* @__PURE__ */ new Set();
+	for (const uniform of parsed.uniforms) {
+		const type = UNIFORM_WGSL_TYPE[uniform.type];
+		if (!type) throw new UnsupportedWgslShaderError(`uniform type "${uniform.type}" has no WGSL uniform equivalent`);
+		if (/^bvec[234]$/.test(uniform.type)) throw new UnsupportedWgslShaderError(`bool-vector uniform "${uniform.name}" is not host-shareable in WGSL`);
+		const wgslName = renameOf(uniform.name, renames);
+		if (uniform.type === "bool") {
+			if (uniform.arrayLength !== void 0) throw new UnsupportedWgslShaderError(`bool array uniform "${uniform.name}" is not supported`);
+			boolUniformNames.add(wgslName);
+		}
+		members.push({
+			wgslName,
+			type,
+			builtin: false,
+			...uniform.arrayLength !== void 0 ? { arrayLength: uniform.arrayLength } : {}
+		});
+	}
+	const layout = wgslStructLayout(members.map((m) => ({
+		name: m.wgslName,
+		type: m.type,
+		...m.arrayLength !== void 0 ? { arrayLength: m.arrayLength } : {}
+	})));
+	const offsetOf = new Map(layout.members.map((m) => [m.name, m.offsetBytes]));
+	const sizeOf = new Map(layout.members.map((m) => [m.name, m.sizeBytes]));
+	const builtinOffsets = {
+		uvFit: offsetOf.get("uv_fit") ?? 0,
+		uvWindow: offsetOf.get("uv_window") ?? 0
+	};
+	if (analysis.usesTime) builtinOffsets.time = offsetOf.get("time");
+	if (analysis.usesTexturePixelSize) builtinOffsets.texturePixelSize = offsetOf.get("texture_pixel_size");
+	if (analysis.usesScreenUv) {
+		builtinOffsets.screenOrigin = offsetOf.get("screen_origin");
+		builtinOffsets.screenSize = offsetOf.get("screen_size");
+	}
+	if (analysis.needsModulate) builtinOffsets.modulate = offsetOf.get("modulate");
+	const uniformFields = parsed.uniforms.map((uniform) => {
+		const wgslName = renameOf(uniform.name, renames);
+		return {
+			name: uniform.name,
+			type: UNIFORM_WGSL_TYPE[uniform.type],
+			godotType: uniform.type,
+			...uniform.arrayLength !== void 0 ? { arrayLength: uniform.arrayLength } : {},
+			offsetBytes: offsetOf.get(wgslName) ?? 0,
+			sizeBytes: sizeOf.get(wgslName) ?? 0,
+			...uniform.default !== void 0 ? { default: uniform.default } : {}
+		};
+	});
+	const memberByWgslName = new Map(members.map((m) => [m.wgslName, m]));
+	const memberTypes = /* @__PURE__ */ new Map();
+	for (const member of members) memberTypes.set(`_u.${member.wgslName}`, member.arrayLength !== void 0 ? `array<${member.type},${member.arrayLength}>` : member.type);
+	return {
+		layout,
+		builtinOffsets,
+		uniformFields,
+		members,
+		memberByWgslName,
+		boolUniformNames,
+		memberTypes
+	};
+}
+function createContext(parsed, plan, renames) {
+	const scope = new Map(plan.memberTypes);
+	for (const name of plan.boolUniformNames) scope.set(name, "bool");
+	const textures = new Set(["TEXTURE"]);
+	for (const sampler of parsed.samplers) textures.add(renameOf(sampler.name, renames));
+	const uniformNames = /* @__PURE__ */ new Set();
+	for (const uniform of parsed.uniforms) uniformNames.add(renameOf(uniform.name, renames));
+	for (const match of `${parsed.helpers}\n${parsed.fragmentBody}`.matchAll(/(?<![\w])(?:const\s+)?(?:float|int|bool|uint|vec[234]|ivec[234]|bvec[234]|mat[234])\s+([A-Za-z_]\w*)/g)) {
+		const name = renameOf(match[1], renames);
+		if (uniformNames.has(name)) throw new UnsupportedWgslShaderError(`local "${match[1]}" shadows the uniform of the same name`);
+	}
+	return {
+		scope,
+		fnReturns: /* @__PURE__ */ new Map(),
+		needMod: /* @__PURE__ */ new Set(),
+		needInverse: { mat3: false },
+		swizzle: { next: 0 },
+		textures,
+		uniformNames
+	};
+}
+function childContext(ctx) {
+	return {
+		...ctx,
+		scope: new Map(ctx.scope)
+	};
+}
+function seedFragmentScope(ctx, analysis) {
+	ctx.scope.set("COLOR", "vec4f");
+	ctx.scope.set("UV", "vec2f");
+	ctx.scope.set("GODOT_UV", "vec2f");
+	ctx.scope.set("PI", "f32");
+	if (analysis.usesScreenUv) ctx.scope.set("SCREEN_UV", "vec2f");
+}
+function translateHelpers(helpers, ctx) {
+	const consts = [];
+	const fns = [];
+	const parsedFns = [];
+	let i = 0;
+	while (i < helpers.length) {
+		while (i < helpers.length && /\s/.test(helpers[i])) i += 1;
+		if (i >= helpers.length) break;
+		if (helpers[i] === ";") {
+			i += 1;
+			continue;
+		}
+		const rest = helpers.slice(i);
+		const constMatch = /^const\s+([A-Za-z_]\w*)\s+([A-Za-z_]\w*)\s*=([\s\S]*?);/.exec(rest);
+		if (constMatch) {
+			const type = localWgslType(constMatch[1], `const "${constMatch[2]}"`);
+			ctx.scope.set(constMatch[2], type);
+			consts.push(`const ${constMatch[2]}: ${type} = ${translateExpr(constMatch[3], ctx)};`);
+			i += constMatch[0].length;
+			continue;
+		}
+		const fnMatch = /^([A-Za-z_]\w*)\s+([A-Za-z_]\w*)\s*\(/.exec(rest);
+		if (fnMatch) {
+			const open = i + fnMatch[0].length - 1;
+			const closeParen = matchParen(helpers, open);
+			let k = closeParen + 1;
+			while (k < helpers.length && /\s/.test(helpers[k])) k += 1;
+			if (helpers[k] !== "{") throw new UnsupportedWgslShaderError(`helper "${fnMatch[2]}" has no body (forward declarations are not supported)`);
+			const closeBrace = matchBrace(helpers, k);
+			parsedFns.push({
+				ret: fnMatch[1],
+				name: fnMatch[2],
+				params: helpers.slice(open + 1, closeParen),
+				body: helpers.slice(k + 1, closeBrace)
+			});
+			i = closeBrace + 1;
+			continue;
+		}
+		throw new UnsupportedWgslShaderError(`unsupported top-level construct "${rest.slice(0, 40).trim()}"`);
+	}
+	for (const fn of parsedFns) if (fn.ret !== "void") ctx.fnReturns.set(fn.name, localWgslType(fn.ret, `helper "${fn.name}"`));
+	for (const fn of parsedFns) {
+		const fnCtx = childContext(ctx);
+		const params = parseParams(fn.params, fn.name, fnCtx);
+		const signature = fn.ret === "void" ? `fn ${fn.name}(${params.join(", ")}) {` : `fn ${fn.name}(${params.join(", ")}) -> ${ctx.fnReturns.get(fn.name)} {`;
+		fns.push([
+			signature,
+			...indentLines(translateBlock(fn.body, fnCtx)),
+			"}"
+		].join("\n"));
+	}
+	return {
+		consts,
+		fns
+	};
+}
+function parseParams(params, fnName, ctx) {
+	const trimmed = params.trim();
+	if (!trimmed || trimmed === "void") return [];
+	return splitTopLevel(trimmed, ",").map((param) => {
+		const match = /^(?:(in|out|inout)\s+)?([A-Za-z_]\w*)\s+([A-Za-z_]\w*)$/.exec(param.trim());
+		if (!match) throw new UnsupportedWgslShaderError(`helper "${fnName}" has an unsupported parameter "${param.trim()}"`);
+		if (match[1] === "out" || match[1] === "inout") throw new UnsupportedWgslShaderError(`helper "${fnName}" uses an ${match[1]} parameter; WGSL would need a pointer`);
+		const type = localWgslType(match[2], `parameter "${match[3]}"`);
+		if (ctx.uniformNames.has(match[3])) throw new UnsupportedWgslShaderError(`parameter "${match[3]}" of helper "${fnName}" shadows a uniform`);
+		ctx.scope.set(match[3], type);
+		return `${match[3]}: ${type}`;
+	});
+}
+const LOCAL_WGSL_TYPE = {
+	...UNIFORM_WGSL_TYPE,
+	bool: "bool",
+	bvec2: "vec2<bool>",
+	bvec3: "vec3<bool>",
+	bvec4: "vec4<bool>"
+};
+function localWgslType(godotType, what) {
+	const type = LOCAL_WGSL_TYPE[godotType];
+	if (!type) throw new UnsupportedWgslShaderError(`${what} has unsupported type "${godotType}"`);
+	return type;
+}
+const DECLARATION = /^(const\s+)?(float|int|bool|uint|vec[234]|ivec[234]|bvec[234]|mat[234])\s+([A-Za-z_]\w*)\s*(\[[^\]]*\])?\s*(?:=([\s\S]*))?$/;
+function translateBlock(src, ctx) {
+	const lines = [];
+	let i = 0;
+	while (i < src.length) {
+		while (i < src.length && /\s/.test(src[i])) i += 1;
+		if (i >= src.length) break;
+		if (src[i] === ";") {
+			i += 1;
+			continue;
+		}
+		if (src[i] === "{") {
+			const close = matchBrace(src, i);
+			lines.push("{");
+			lines.push(...indentLines(translateBlock(src.slice(i + 1, close), ctx)));
+			lines.push("}");
+			i = close + 1;
+			continue;
+		}
+		let depth = 0;
+		let stop = -1;
+		let stopChar = "";
+		for (let j = i; j < src.length; j += 1) {
+			const c = src[j];
+			if (c === "(" || c === "[") depth += 1;
+			else if (c === ")" || c === "]") depth -= 1;
+			else if (depth === 0 && (c === ";" || c === "{" || c === "}")) {
+				stop = j;
+				stopChar = c;
+				break;
+			}
+		}
+		if (stop < 0) {
+			const tail = src.slice(i).trim();
+			if (tail) throw new UnsupportedWgslShaderError(`unterminated statement "${tail}"`);
+			break;
+		}
+		if (stopChar === "}") throw new UnsupportedWgslShaderError(`unbalanced braces near "${src.slice(i, stop).trim()}"`);
+		if (stopChar === "{") {
+			const header = src.slice(i, stop).trim();
+			const close = matchBrace(src, stop);
+			lines.push(...translateControl(header, src.slice(stop + 1, close), ctx));
+			i = close + 1;
+			while (i < src.length && /\s/.test(src[i])) i += 1;
+			if (src[i] === ";") i += 1;
+			continue;
+		}
+		lines.push(...translateStatement(src.slice(i, stop).trim(), ctx));
+		i = stop + 1;
+	}
+	return mergeElse(lines);
+}
+function translateControl(header, inner, ctx) {
+	if (/^while\b/.test(header)) throw new UnsupportedShaderError("while loops are not supported");
+	if (/^for\b/.test(header)) {
+		const open = header.indexOf("(");
+		if (open < 0 || matchParen(header, open) !== header.length - 1) throw new UnsupportedWgslShaderError(`unsupported for header "${header}"`);
+		const clauses = splitTopLevel(header.slice(open + 1, header.length - 1), ";");
+		if (clauses.length !== 3) throw new UnsupportedWgslShaderError(`for loop needs init/condition/increment, got "${header}"`);
+		const loop = childContext(ctx);
+		return [
+			`for (${oneLine(clauses[0], loop)}; ${clauses[1].trim() ? translateExpr(clauses[1], loop) : ""}; ${oneLine(clauses[2], loop)}) {`,
+			...indentLines(translateBlock(inner, loop)),
+			"}"
+		];
+	}
+	const ifMatch = /^(else\s+if|if)\b/.exec(header);
+	if (ifMatch) {
+		const open = header.indexOf("(");
+		if (open < 0) throw new UnsupportedWgslShaderError(`unsupported if header "${header}"`);
+		const close = matchParen(header, open);
+		const cond = translateExpr(header.slice(open + 1, close), ctx);
+		return [
+			`${ifMatch[1].startsWith("else") ? "else if" : "if"} (${cond}) {`,
+			...indentLines(translateBlock(inner, childContext(ctx))),
+			"}"
+		];
+	}
+	if (/^else$/.test(header)) return [
+		"else {",
+		...indentLines(translateBlock(inner, childContext(ctx))),
+		"}"
+	];
+	throw new UnsupportedWgslShaderError(`unsupported block header "${header}"`);
+}
+/** A for-clause: one statement, rendered without its terminating `;`. */
+function oneLine(clause, ctx) {
+	const trimmed = clause.trim();
+	if (!trimmed) return "";
+	const lines = translateStatement(trimmed, ctx);
+	if (lines.length !== 1) throw new UnsupportedWgslShaderError(`for clause "${trimmed}" does not translate to a single statement`);
+	return lines[0].replace(/;$/, "");
+}
+function translateStatement(stmt, ctx) {
+	if (!stmt) return [];
+	const controlMatch = /^(if|for|while|else\s+if|else)\b/.exec(stmt);
+	if (controlMatch) {
+		if (controlMatch[1] === "while") throw new UnsupportedShaderError("while loops are not supported");
+		if (controlMatch[1] === "else") return translateControl("else", `${stmt.slice(4).trim()};`, ctx);
+		const open = stmt.indexOf("(");
+		if (open < 0) throw new UnsupportedWgslShaderError(`unsupported statement "${stmt}"`);
+		const close = matchParen(stmt, open);
+		return translateControl(stmt.slice(0, close + 1).trim(), `${stmt.slice(close + 1).trim()};`, ctx);
+	}
+	if (stmt === "continue" || stmt === "break" || stmt === "discard") return [`${stmt};`];
+	if (/^return\b/.test(stmt)) {
+		const value = stmt.slice(6).trim();
+		return value ? [`return ${translateExpr(value, ctx)};`] : ["return;"];
+	}
+	const decl = DECLARATION.exec(stmt);
+	if (decl) {
+		if (decl[4]) throw new UnsupportedWgslShaderError(`local array declaration "${decl[3]}" is not supported`);
+		const type = localWgslType(decl[2], `local "${decl[3]}"`);
+		ctx.scope.set(decl[3], type);
+		if (decl[5] === void 0) return [`var ${decl[3]}: ${type};`];
+		return [`${decl[1] ? "let" : "var"} ${decl[3]}: ${type} = ${translateExpr(decl[5], ctx)};`];
+	}
+	if (/^[A-Za-z_][\w.[\]]*\s*(\+\+|--)$/.test(stmt)) return [`${stmt.replace(/\s+/g, "")};`];
+	const prefixInc = /^(\+\+|--)\s*([A-Za-z_][\w.[\]]*)$/.exec(stmt);
+	if (prefixInc) return [`${prefixInc[2]}${prefixInc[1]};`];
+	const assign = findAssignment(stmt);
+	if (assign) return translateAssignment(assign, ctx);
+	if (/^[A-Za-z_]\w*\s*\(/.test(stmt)) return [`${translateExpr(stmt, ctx)};`];
+	throw new UnsupportedWgslShaderError(`unsupported statement "${stmt}"`);
+}
+function findAssignment(stmt) {
+	let depth = 0;
+	for (let i = 0; i < stmt.length; i += 1) {
+		const c = stmt[i];
+		if (c === "(" || c === "[") depth += 1;
+		else if (c === ")" || c === "]") depth -= 1;
+		else if (depth === 0 && c === "=") {
+			if (stmt[i + 1] === "=") {
+				i += 1;
+				continue;
+			}
+			const prev = stmt[i - 1];
+			if (prev === "=" || prev === "!" || prev === "<" || prev === ">") continue;
+			if (prev === "+" || prev === "-" || prev === "*" || prev === "/") return {
+				lvalue: stmt.slice(0, i - 1),
+				op: `${prev}=`,
+				rvalue: stmt.slice(i + 1)
+			};
+			return {
+				lvalue: stmt.slice(0, i),
+				op: "=",
+				rvalue: stmt.slice(i + 1)
+			};
+		}
+	}
+	return null;
+}
+const LVALUE = /^[A-Za-z_]\w*(?:\.[A-Za-z_]\w*|\[[^\]]*\])*$/;
+const COMPONENT = {
+	x: "x",
+	y: "y",
+	z: "z",
+	w: "w",
+	r: "x",
+	g: "y",
+	b: "z",
+	a: "w"
+};
+function translateAssignment(assign, ctx) {
+	const lvalue = assign.lvalue.trim();
+	if (lvalue.startsWith("_u.")) throw new UnsupportedWgslShaderError(`assignment to the uniform "${lvalue.slice(3)}"`);
+	if (!LVALUE.test(lvalue)) throw new UnsupportedWgslShaderError(`unsupported assignment target "${lvalue}"`);
+	const rvalue = translateExpr(assign.rvalue, ctx);
+	const swizzle = /^(.+)\.([xyzwrgba]{2,4})$/.exec(lvalue);
+	if (!swizzle) return [`${lvalue} ${assign.op} ${rvalue};`];
+	const base = swizzle[1];
+	const comps = [...swizzle[2]];
+	const ctor = swizzleConstructor(base, comps.length, ctx);
+	const temp = `_swz${ctx.swizzle.next}`;
+	ctx.swizzle.next += 1;
+	const lines = [`let ${temp} = ${ctor}(${rvalue});`];
+	comps.forEach((component, index) => {
+		const dst = `${base}.${COMPONENT[component]}`;
+		const src = `${temp}.${"xyzw"[index]}`;
+		lines.push(assign.op === "=" ? `${dst} = ${src};` : `${dst} = ${dst} ${assign.op[0]} ${src};`);
+	});
+	return lines;
+}
+function swizzleConstructor(base, width, ctx) {
+	const type = inferType(base, ctx);
+	return `vec${width}${type && /^vec[234]i$/.test(type) ? "i" : "f"}`;
+}
+function translateExpr(expr, ctx) {
+	const trimmed = expr.trim();
+	const ternary = splitTernary(trimmed);
+	if (ternary) return `select(${translateExpr(ternary.whenFalse, ctx)}, ${translateExpr(ternary.whenTrue, ctx)}, ${translateExpr(ternary.cond, ctx)})`;
+	let out = rewriteTextureCalls(trimmed, ctx);
+	out = rewriteIntrinsics(out, ctx);
+	out = renameConstructors(out);
+	if (out.includes("?")) throw new UnsupportedWgslShaderError(`ternary "?:" is only supported as a complete right-hand side, got "${trimmed}"`);
+	return out.trim();
+}
+function splitTernary(expr) {
+	let depth = 0;
+	let question = -1;
+	for (let i = 0; i < expr.length; i += 1) {
+		const c = expr[i];
+		if (c === "(" || c === "[") depth += 1;
+		else if (c === ")" || c === "]") depth -= 1;
+		else if (depth === 0 && c === "?") {
+			question = i;
+			break;
+		}
+	}
+	if (question < 0) return null;
+	depth = 0;
+	let pending = 0;
+	for (let i = question + 1; i < expr.length; i += 1) {
+		const c = expr[i];
+		if (c === "(" || c === "[") depth += 1;
+		else if (c === ")" || c === "]") depth -= 1;
+		else if (depth === 0 && c === "?") pending += 1;
+		else if (depth === 0 && c === ":") {
+			if (pending > 0) {
+				pending -= 1;
+				continue;
+			}
+			return {
+				cond: expr.slice(0, question),
+				whenTrue: expr.slice(question + 1, i),
+				whenFalse: expr.slice(i + 1)
+			};
+		}
+	}
+	throw new UnsupportedWgslShaderError(`ternary without a ":" in "${expr}"`);
+}
+/** `texture(t, uv)` -> `textureSampleLevel(t, t_smp, uv, 0.0)`. Explicit level 0 rather
+*  than `textureSample`: it sidesteps WGSL's non-uniform-control-flow rule for implicit
+*  derivatives (the corpus samples inside `if`/`for`), and the canvas textures this
+*  runtime binds are single-mip, so level 0 IS the only level — visually identical. */
+function rewriteTextureCalls(src, ctx) {
+	return mapCalls(src, "texture", (args, raw) => {
+		if (args.length !== 2) throw new UnsupportedWgslShaderError(`texture() with ${args.length} arguments is not supported ("${raw}")`);
+		const sampler = args[0].trim();
+		if (!ctx.textures.has(sampler)) throw new UnsupportedWgslShaderError(`texture() on "${sampler}", which is not a declared sampler2D uniform`);
+		return `textureSampleLevel(${sampler}, ${sampler}_smp, ${args[1].trim()}, 0.0)`;
+	});
+}
+function rewriteIntrinsics(src, ctx) {
+	let out = mapCalls(src, "mod", (args, raw) => {
+		if (args.length !== 2) throw new UnsupportedWgslShaderError(`mod() with ${args.length} arguments`);
+		const left = widthOf(args[0], ctx, raw);
+		const right = widthOf(args[1], ctx, raw);
+		const width = Math.max(left, right);
+		ctx.needMod.add(width);
+		return `${width === 1 ? "godot_mod" : `godot_mod${width}`}(${broadcast(args[0].trim(), left, width)}, ${broadcast(args[1].trim(), right, width)})`;
+	});
+	out = mapCalls(out, "atan", (args) => args.length === 2 ? `atan2(${args[0].trim()}, ${args[1].trim()})` : `atan(${args[0].trim()})`);
+	out = mapCalls(out, "inverse", (args, raw) => {
+		const type = inferType(args[0], ctx);
+		if (type !== "mat3x3f") throw new UnsupportedWgslShaderError(`inverse() is only supported on a mat3 (got ${type ?? "an untyped expression"} in "${raw}")`);
+		ctx.needInverse.mat3 = true;
+		return `godot_inverse3(${args[0].trim()})`;
+	});
+	return out;
+}
+function broadcast(expr, from, to) {
+	return from === to ? expr : `vec${to}f(${expr})`;
+}
+function widthOf(expr, ctx, raw) {
+	const type = inferType(expr, ctx);
+	const width = type ? typeWidth(type) : null;
+	if (width === null) throw new UnsupportedWgslShaderError(`cannot infer the component count of "${expr.trim()}" in "${raw}" (WGSL has no function overloading, so mod()'s polyfill is chosen by width)`);
+	return width;
+}
+const CONSTRUCTORS = {
+	float: "f32",
+	int: "i32",
+	vec2: "vec2f",
+	vec3: "vec3f",
+	vec4: "vec4f",
+	ivec2: "vec2i",
+	ivec3: "vec3i",
+	ivec4: "vec4i",
+	bvec2: "vec2<bool>",
+	bvec3: "vec3<bool>",
+	bvec4: "vec4<bool>",
+	mat2: "mat2x2f",
+	mat3: "mat3x3f",
+	mat4: "mat4x4f"
+};
+function renameConstructors(src) {
+	return src.replace(/(?<![\w.])(float|int|vec[234]|ivec[234]|bvec[234]|mat[234])(\s*)\(/g, (_match, name, space) => `${CONSTRUCTORS[name]}${space}(`);
+}
+const VECTOR_TYPE = /^vec([234])([fi])$/;
+function typeWidth(type) {
+	if (type === "f32" || type === "i32" || type === "u32" || type === "bool") return 1;
+	const match = VECTOR_TYPE.exec(type);
+	return match ? Number(match[1]) : null;
+}
+const SCALAR_RETURN = new Set([
+	"length",
+	"dot",
+	"distance",
+	"determinant"
+]);
+const VEC4_RETURN = new Set([
+	"texture",
+	"textureSampleLevel",
+	"textureLoad"
+]);
+const BOOL_RETURN = new Set(["any", "all"]);
+function inferType(expr, ctx) {
+	let e = expr.trim();
+	while (e.startsWith("(") && matchParen(e, 0) === e.length - 1) e = e.slice(1, -1).trim();
+	if (!e) return null;
+	if (hasTopLevelComparison(e)) return "bool";
+	const operands = splitOperands(e);
+	if (operands.length > 1) {
+		let best = null;
+		for (const operand of operands) {
+			const type = inferType(operand, ctx);
+			if (!type) continue;
+			const width = typeWidth(type);
+			const bestWidth = best ? typeWidth(best) : null;
+			if (best === null || (width ?? 0) > (bestWidth ?? 0)) best = type;
+		}
+		return best;
+	}
+	if (/^[-+!~]/.test(e)) return inferType(e.slice(1), ctx);
+	if (/^\d/.test(e) || /^\.\d/.test(e)) return "f32";
+	const call = /^([A-Za-z_]\w*)\s*\(/.exec(e);
+	if (call && matchParen(e, e.indexOf("(")) === e.length - 1) return inferCallType(call[1], e, ctx);
+	const swizzle = /^(.+)\.([xyzwrgba]+)$/.exec(e);
+	if (swizzle) {
+		const baseType = inferType(swizzle[1], ctx);
+		const match = baseType ? VECTOR_TYPE.exec(baseType) : null;
+		if (match) {
+			const width = swizzle[2].length;
+			return width === 1 ? scalarOf(match[2]) : `vec${width}${match[2]}`;
+		}
+	}
+	const index = /^(.+)\[[^\]]*\]$/.exec(e);
+	if (index) {
+		const arrayType = inferType(index[1], ctx);
+		const element = arrayType ? /^array<([^,]+),/.exec(arrayType) : null;
+		if (element) return element[1];
+		if (arrayType === "mat3x3f") return "vec3f";
+		if (arrayType === "mat2x2f") return "vec2f";
+		if (arrayType === "mat4x4f") return "vec4f";
+	}
+	return ctx.scope.get(e) ?? null;
+}
+function scalarOf(suffix) {
+	return suffix === "i" ? "i32" : "f32";
+}
+function inferCallType(name, expr, ctx) {
+	const ctor = CONSTRUCTORS[name];
+	if (ctor) return ctor;
+	if (/^(f32|i32|u32|vec[234][fi]|mat[234]x[234]f)$/.test(name)) return name;
+	if (SCALAR_RETURN.has(name)) return "f32";
+	if (VEC4_RETURN.has(name)) return "vec4f";
+	if (BOOL_RETURN.has(name)) return "bool";
+	const helper = ctx.fnReturns.get(name);
+	if (helper) return helper;
+	const open = expr.indexOf("(");
+	const args = splitTopLevel(expr.slice(open + 1, expr.length - 1), ",");
+	let best = null;
+	for (const arg of args) {
+		if (!arg.trim()) continue;
+		const type = inferType(arg, ctx);
+		if (!type) continue;
+		const bestWidth = best ? typeWidth(best) : null;
+		if (best === null || (typeWidth(type) ?? 0) > (bestWidth ?? 0)) best = type;
+	}
+	return best;
+}
+function hasTopLevelComparison(expr) {
+	let depth = 0;
+	for (let i = 0; i < expr.length; i += 1) {
+		const c = expr[i];
+		if (c === "(" || c === "[") depth += 1;
+		else if (c === ")" || c === "]") depth -= 1;
+		else if (depth === 0) {
+			const pair = expr.slice(i, i + 2);
+			if (pair === "&&" || pair === "||" || pair === "==" || pair === "!=") return true;
+			if ((c === "<" || c === ">") && expr[i + 1] !== "<" && expr[i + 1] !== ">") return true;
+		}
+	}
+	return false;
+}
+/** Split on top-level `+ - * /`, skipping the unary uses (leading, or right after
+*  another operator or an opening delimiter). Only used to find the WIDEST operand. */
+function splitOperands(expr) {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < expr.length; i += 1) {
+		const c = expr[i];
+		if (c === "(" || c === "[") depth += 1;
+		else if (c === ")" || c === "]") depth -= 1;
+		else if (depth === 0 && "+-*/%".includes(c)) {
+			const before = expr.slice(start, i).trim();
+			if (!before) continue;
+			if (/[-+*/%<>=!&|,(]$/.test(before)) continue;
+			parts.push(before);
+			start = i + 1;
+		}
+	}
+	const tail = expr.slice(start).trim();
+	if (tail) parts.push(tail);
+	return parts;
+}
+function mapCalls(src, name, transform) {
+	const pattern = new RegExp(`(?<![\\w.])${name}\\s*\\(`, "g");
+	let out = "";
+	let index = 0;
+	for (;;) {
+		pattern.lastIndex = index;
+		const match = pattern.exec(src);
+		if (!match) {
+			out += src.slice(index);
+			return out;
+		}
+		const open = match.index + match[0].length - 1;
+		const close = matchParen(src, open);
+		const raw = src.slice(match.index, close + 1);
+		const args = splitTopLevel(src.slice(open + 1, close), ",").map((arg) => mapCalls(arg, name, transform));
+		out += src.slice(index, match.index);
+		out += transform(args, raw);
+		index = close + 1;
+	}
+}
+function matchParen(src, openIndex) {
+	let depth = 0;
+	for (let i = openIndex; i < src.length; i += 1) if (src[i] === "(") depth += 1;
+	else if (src[i] === ")") {
+		depth -= 1;
+		if (depth === 0) return i;
+	}
+	throw new UnsupportedWgslShaderError(`unbalanced parentheses in "${src.slice(openIndex, openIndex + 40)}"`);
+}
+function splitTopLevel(src, separator) {
+	const parts = [];
+	let depth = 0;
+	let start = 0;
+	for (let i = 0; i < src.length; i += 1) {
+		const c = src[i];
+		if (c === "(" || c === "[" || c === "{") depth += 1;
+		else if (c === ")" || c === "]" || c === "}") depth -= 1;
+		else if (depth === 0 && c === separator) {
+			parts.push(src.slice(start, i));
+			start = i + 1;
+		}
+	}
+	parts.push(src.slice(start));
+	return parts;
+}
+function indentLines(lines) {
+	return lines.map((line) => line ? `  ${line}` : line);
+}
+function mergeElse(lines) {
+	const out = [];
+	for (const line of lines) {
+		const previous = out[out.length - 1];
+		if (previous !== void 0 && previous.trim() === "}" && /^\s*else\b/.test(line)) {
+			out[out.length - 1] = `${previous} ${line.trim()}`;
+			continue;
+		}
+		out.push(line);
+	}
+	return out;
+}
+const MOD_POLYFILL_HEADER = `// GLSL's mod() is FLOOR-signed (x - y*floor(x/y)); WGSL's % is TRUNC-signed, so they
+// disagree wherever x goes negative — a scrolling UV crossing zero would tear. WGSL has
+// no user-defined function overloading, so the component count lives in the name.`;
+const INVERSE_POLYFILL = `// WGSL has no inverse(). Cofactor / determinant, column-major like both languages.
+fn godot_inverse3(m: mat3x3f) -> mat3x3f {
+  let a = m[0];
+  let b = m[1];
+  let c = m[2];
+  let b01 = c.z * b.y - b.z * c.y;
+  let b11 = b.z * c.x - c.z * b.x;
+  let b21 = c.y * b.x - b.y * c.x;
+  let det = a.x * b01 + a.y * b11 + a.z * b21;
+  let inv = mat3x3f(
+    vec3f(b01, a.z * c.y - c.z * a.y, b.z * a.y - a.z * b.y),
+    vec3f(b11, c.z * a.x - a.z * c.x, a.z * b.x - b.z * a.x),
+    vec3f(b21, a.y * c.x - c.y * a.x, b.y * a.x - a.y * b.x)
+  );
+  return inv * (1.0 / det);
+}`;
+const VS_MAIN = `struct VsOut {
+  @builtin(position) pos: vec4f,
+  @location(0) uv: vec2f,
+}
+
+@vertex
+fn ${VERTEX_ENTRY}(@builtin(vertex_index) index: u32) -> VsOut {
+  // TRIANGLE_STRIP corner order: (-1,-1) (1,-1) (-1,1) (1,1).
+  var corners = array<vec2f, 4>(
+    vec2f(-1.0, -1.0),
+    vec2f(1.0, -1.0),
+    vec2f(-1.0, 1.0),
+    vec2f(1.0, 1.0)
+  );
+  let xy = corners[index];
+  var out: VsOut;
+  out.pos = vec4f(xy, 0.0, 1.0);
+  // Godot's UV is node-local with a TOP-LEFT origin; clip Y is up. The flip lives HERE,
+  // in the vertex stage, so the fragment prelude below is the GLSL one MINUS its
+  // "1.0 - v_uv.y" — one place to get wrong instead of one per fragment.
+  out.uv = vec2f(xy.x * 0.5 + 0.5, 0.5 - xy.y * 0.5);
+  return out;
+}`;
+function assembleModule(input) {
+	const { parsed, analysis, plan, renames, ctx } = input;
+	const structText = [
+		"// One uniform struct for everything the fragment reads. Members are laid out by",
+		"// WGSL's own uniform address space rules IN DECLARATION ORDER, which is exactly what",
+		"// `wgslStructLayout` records — so the byte offsets a writer holds and the offsets the",
+		"// compiler computes are the same numbers, with no explicit padding members to drift.",
+		"struct Uniforms {",
+		...plan.members.map((member) => {
+			const type = member.arrayLength !== void 0 ? `array<${member.type}, ${member.arrayLength}>` : member.type;
+			return `  ${member.wgslName}: ${type},`;
+		}),
+		"}"
+	].join("\n");
+	const bindingLines = [
+		`@group(0) @binding(${BINDINGS.uniform}) var<uniform> _u: Uniforms;`,
+		`@group(0) @binding(${BINDINGS.texture}) var TEXTURE: texture_2d<f32>;`,
+		`@group(0) @binding(${BINDINGS.textureSampler}) var TEXTURE_smp: sampler;`
+	];
+	parsed.samplers.forEach((sampler, i) => {
+		const name = renameOf(sampler.name, renames);
+		bindingLines.push(`@group(0) @binding(${BINDINGS.userSamplersBase + i * 2}) var ${name}: texture_2d<f32>;`);
+		bindingLines.push(`@group(0) @binding(${BINDINGS.userSamplersBase + i * 2 + 1}) var ${name}_smp: sampler;`);
+	});
+	const consts = [];
+	if (analysis.usesPi) consts.push("const PI: f32 = 3.141592653589793;");
+	consts.push(...input.helpers.consts);
+	const polyfills = [];
+	if (ctx.needMod.size > 0) {
+		const widths = [...ctx.needMod].sort((a, b) => a - b);
+		polyfills.push([MOD_POLYFILL_HEADER, ...widths.map((width) => {
+			const type = width === 1 ? "f32" : `vec${width}f`;
+			return `fn ${width === 1 ? "godot_mod" : `godot_mod${width}`}(x: ${type}, y: ${type}) -> ${type} { return x - y * floor(x / y); }`;
+		})].join("\n"));
+	}
+	if (ctx.needInverse.mat3) polyfills.push(INVERSE_POLYFILL);
+	const fragment = [];
+	const bodyTogether = input.bodyLines.join("\n");
+	for (const name of plan.boolUniformNames) if (hasToken(bodyTogether, name)) fragment.push(`let ${name}: bool = (_u.${name} != 0.0);`);
+	fragment.push("let raw_uv = in.uv;");
+	fragment.push("let GODOT_UV = _u.uv_window.xy + raw_uv * _u.uv_window.zw;", "let UV = (GODOT_UV - vec2f(0.5)) / _u.uv_fit + vec2f(0.5);");
+	if (analysis.usesScreenUv) fragment.push("let SCREEN_UV = _u.screen_origin + GODOT_UV * _u.screen_size;");
+	fragment.push(analysis.opaqueColor ? "var COLOR: vec4f = vec4f(textureSampleLevel(TEXTURE, TEXTURE_smp, UV, 0.0).rgb, 1.0);" : "var COLOR: vec4f = textureSampleLevel(TEXTURE, TEXTURE_smp, UV, 0.0);");
+	fragment.push(...input.varyingLines);
+	fragment.push(...input.bodyLines);
+	if (analysis.autoModulate) fragment.push("COLOR = COLOR * _u.modulate;");
+	fragment.push("// PREMULTIPLIED. A GPUCanvasContext offers only alphaMode \"opaque\" | \"premultiplied\",", "// so this is THE canvas contract: return rgb*a with a, and let the pipeline blend", "// one / one-minus-src-alpha on colour AND alpha. Returning straight alpha here halos;", "// returning premultiplied under a src-alpha blend double-multiplies. Neither errors.", "return vec4f(COLOR.rgb * COLOR.a, COLOR.a);");
+	const fsMain = [
+		"@fragment",
+		`fn ${FRAGMENT_ENTRY}(in: VsOut) -> @location(0) vec4f {`,
+		...indentLines(fragment),
+		"}"
+	].join("\n");
+	return `${[
+		"// Generated by transpileGodotShaderWgsl (packages/html/src/webgpu/transpile-wgsl.ts).",
+		structText,
+		bindingLines.join("\n"),
+		consts.length > 0 ? consts.join("\n") : "",
+		polyfills.join("\n\n"),
+		input.helpers.fns.join("\n\n"),
+		VS_MAIN,
+		fsMain
+	].filter((section) => section !== "").join("\n\n")}\n`;
+}
+//#endregion
+export { UnsupportedShaderError, UnsupportedWgslShaderError, analyzeShader, expandGodotShaderIncludes, extractFunction, hasToken, matchBrace, parseShader, promoteIntLiterals, rejectUnsupported, replaceToken, sanitizeReservedIdentifiers, shaderLogic, stripComments, transpileGodotShader, transpileGodotShaderWgsl, unwrapShaderResource, wgslStructLayout };
+
+//# sourceMappingURL=index.js.map