shaders 3.2.464 → 3.2.465

package/dist/core/Irradiance-DT3bdyrR.js

@@ -0,0 +1,4191 @@
+import { $n as clamp, Ar as texture2d, Br as f32, Cr as vec2u, G as createGuardedCompute, Hn as textureSampleLevel, Hr as u32, Jn as select, Mr as arrayOf, Nr as struct, P as sdf_exports, Pn as TAU, Tr as vec4f, Un as textureStore, Vn as textureLoad, Vr as i32, _r as smoothstep$1, cr as max$1, d as glassShellProps, dr as normalize$1, er as cos, gr as sin, jr as textureStorage2d, lr as min, mt as formatFloat, nr as dot$1, or as fract, pt as Expr, sr as length, t as defineStd, v as buildAnalyticSdfFn, wr as vec3f, xr as vec2f, zn as typegpu_default } from "./lower-DSk_KxOY.js";
+import { ct as listCountName, ft as listPropConfig, ut as listFieldName } from "./porters-j4QbEOqj.js";
+import { y as createGaussianBlurCompute } from "./blur-BwjlF0Uk.js";
+import { A as placementPoint, F as shapedSurface, R as silhouette, S as lambert, T as nearestEdge, V as surfaceField, f as geometricNormal, g as guarded, i as continuedField, j as pointLightFrom, l as fieldSlope, s as exposureTone, v as insideShape, y as inverseSquare } from "./materials-Dhq8lDKb.js";
+import { t as isMobileGpuViewport } from "./device-m0ud8-Fn.js";
+import { m as sdf3d_exports, n as buildFieldSampleGraphArgs, v as resolveShapeType, y as shapeEffectBoundingBoxDeclaration } from "./sdf3d-DQ55w9nI.js";
+import { n as glass_exports } from "./glass-CtWl8jzT.js";
+import { a as transformColor, c as transformPosition, i as transformBoolean } from "./transformations-COlfAEsk.js";
+import { B as vec4, C as mul, E as pow, L as sub, M as smoothstep, P as splat3, R as vec2, S as mix, T as normalize, b as max, h as gt, n as add, o as div, s as dot, u as float, y as local, z as vec3 } from "./math-DCQU6EQz.js";
+import { n as emissiveAlpha } from "./compose-prsdG9f_.js";
+var { sdfSpaceUV } = glass_exports;
+const IRRADIANCE_FORMAT = "rgba16float";
+const IrradianceParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	center: vec2f,
+	lightPos: arrayOf(vec4f, 8),
+	lightColor: arrayOf(vec4f, 8),
+	lightCount: f32,
+	scale: f32,
+	rotation: f32,
+	aspect: f32,
+	reach: f32,
+	wrap: f32,
+	lightRange: f32,
+	shadowSoftness: f32,
+	eps: f32,
+	res: f32,
+	frame: f32,
+	rays: f32,
+	saRadius: f32,
+	saSides: f32,
+	saRounding: f32,
+	saInnerRatio: f32,
+	saRotation: f32,
+	saHeight: f32,
+	saOffset: f32,
+	saAperture: f32,
+	vfOriginX: f32,
+	vfOriginY: f32,
+	vfSpanX: f32,
+	vfSpanY: f32,
+	vfActiveRes: f32,
+	vfRBound: f32
+}), "IrradianceParams");
+var outEntry = { storageTexture: textureStorage2d(IRRADIANCE_FORMAT, "write-only") };
+const irradianceAnalyticLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	params: { uniform: IrradianceParams },
+	outTex: outEntry
+}), "irradianceAnalyticLayout");
+const irradianceSvgLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	params: { uniform: IrradianceParams },
+	outTex: outEntry,
+	sdfSource: { texture: texture2d(f32) },
+	samp: { sampler: "filtering" }
+}), "irradianceSvgLayout");
+const irradianceFieldLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	params: { uniform: IrradianceParams },
+	outTex: outEntry,
+	silhouetteTex: { texture: texture2d(f32) },
+	samp: { sampler: "filtering" }
+}), "irradianceFieldLayout");
+var FAR = 1e3;
+var sane = typegpu_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((v) => {
+	"use gpu";
+	return max$1(min(v, FAR), __tsover_mul(FAR, -1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "v"
+		}],
+		"body": [0, [[10, [
+			6,
+			"std.max",
+			[[
+				6,
+				"std.min",
+				["v", "FAR"]
+			], [
+				1,
+				"FAR",
+				"*",
+				[
+					4,
+					"-",
+					[5, "1"]
+				]
+			]]
+		]]]]
+	},
+	externals: {
+		"std.max": () => max$1,
+		"std.min": () => min,
+		"FAR": () => FAR
+	}
+}) && $.f)({})).$name("irradianceSane");
+var beyondSquare = typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
+	"use gpu";
+	const c = clamp(uv, vec2f(0, 0), vec2f(1, 1));
+	return length(uv.sub(c));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uv"
+		}],
+		"body": [0, [[
+			13,
+			"c",
+			[
+				6,
+				"std.clamp",
+				[
+					"uv",
+					[
+						6,
+						"d.vec2f",
+						[[5, "0"], [5, "0"]]
+					],
+					[
+						6,
+						"d.vec2f",
+						[[5, "1"], [5, "1"]]
+					]
+				]
+			]
+		], [10, [
+			6,
+			"std.length",
+			[[
+				6,
+				[
+					7,
+					"uv",
+					"sub"
+				],
+				["c"]
+			]]
+		]]]]
+	},
+	externals: {
+		"std.clamp": () => clamp,
+		"d.vec2f": () => vec2f,
+		"std.length": () => length
+	}
+}) && $.f)({})).$name("irradianceBeyondSquare");
+function analyticField(shapeType) {
+	const sdfFn = buildAnalyticSdfFn(shapeType);
+	return typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
+		"use gpu";
+		const p = irradianceAnalyticLayout.$.params;
+		return sdfFn(uv, p.saRadius, p.saSides, p.saRounding, p.saInnerRatio, p.saRotation, p.saHeight, p.saOffset, p.saAperture).x;
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "uv"
+			}],
+			"body": [0, [[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"irradianceAnalyticLayout",
+						"$"
+					],
+					"params"
+				]
+			], [10, [
+				7,
+				[
+					6,
+					"sdfFn",
+					[
+						"uv",
+						[
+							7,
+							"p",
+							"saRadius"
+						],
+						[
+							7,
+							"p",
+							"saSides"
+						],
+						[
+							7,
+							"p",
+							"saRounding"
+						],
+						[
+							7,
+							"p",
+							"saInnerRatio"
+						],
+						[
+							7,
+							"p",
+							"saRotation"
+						],
+						[
+							7,
+							"p",
+							"saHeight"
+						],
+						[
+							7,
+							"p",
+							"saOffset"
+						],
+						[
+							7,
+							"p",
+							"saAperture"
+						]
+					]
+				],
+				"x"
+			]]]]
+		},
+		externals: {
+			"irradianceAnalyticLayout": () => irradianceAnalyticLayout,
+			"sdfFn": () => sdfFn
+		}
+	}) && $.f)({})).$name("irradianceAnalyticField");
+}
+const svgField = typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
+	"use gpu";
+	const border = textureSampleLevel(irradianceSvgLayout.$.sdfSource, irradianceSvgLayout.$.samp, uv, f32(0)).x;
+	const beyond = beyondSquare(uv);
+	return sane(select(border, max$1(beyond, __tsover_sub(border, beyond)), beyond > 0));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uv"
+		}],
+		"body": [0, [
+			[
+				13,
+				"border",
+				[
+					7,
+					[
+						6,
+						"std.textureSampleLevel",
+						[
+							[
+								7,
+								[
+									7,
+									"irradianceSvgLayout",
+									"$"
+								],
+								"sdfSource"
+							],
+							[
+								7,
+								[
+									7,
+									"irradianceSvgLayout",
+									"$"
+								],
+								"samp"
+							],
+							"uv",
+							[
+								6,
+								"d.f32",
+								[[5, "0"]]
+							]
+						]
+					],
+					"x"
+				]
+			],
+			[
+				13,
+				"beyond",
+				[
+					6,
+					"beyondSquare",
+					["uv"]
+				]
+			],
+			[10, [
+				6,
+				"sane",
+				[[
+					6,
+					"std.select",
+					[
+						"border",
+						[
+							6,
+							"std.max",
+							["beyond", [
+								1,
+								"border",
+								"-",
+								"beyond"
+							]]
+						],
+						[
+							1,
+							"beyond",
+							">",
+							[5, "0"]
+						]
+					]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"std.textureSampleLevel": () => textureSampleLevel,
+		"irradianceSvgLayout": () => irradianceSvgLayout,
+		"d.f32": () => f32,
+		"beyondSquare": () => beyondSquare,
+		"sane": () => sane,
+		"std.select": () => select,
+		"std.max": () => max$1
+	}
+}) && $.f)({})).$name("irradianceSvgField");
+const volumetricField = typegpu_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
+	"use gpu";
+	const p = irradianceFieldLayout.$.params;
+	const cx = clamp(uv.x, p.vfOriginX, __tsover_add(p.vfOriginX, p.vfSpanX));
+	const cy = clamp(uv.y, p.vfOriginY, __tsover_add(p.vfOriginY, p.vfSpanY));
+	const outside = length(vec2f(__tsover_sub(uv.x, cx), __tsover_sub(uv.y, cy)));
+	const circle = __tsover_sub(length(vec2f(__tsover_sub(uv.x, .5), __tsover_sub(uv.y, .5))), p.vfRBound);
+	const tuv = vec2f(__tsover_div(__tsover_sub(cx, p.vfOriginX), p.vfSpanX), __tsover_div(__tsover_sub(cy, p.vfOriginY), p.vfSpanY));
+	const sil = textureSampleLevel(irradianceFieldLayout.$.silhouetteTex, irradianceFieldLayout.$.samp, tuv, f32(0));
+	const inDomain = __tsover_mul(sil.z, sil.w);
+	return sane(select(inDomain, max$1(max$1(outside, circle), __tsover_sub(inDomain, outside)), outside > 0));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uv"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"irradianceFieldLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"cx",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							7,
+							"uv",
+							"x"
+						],
+						[
+							7,
+							"p",
+							"vfOriginX"
+						],
+						[
+							1,
+							[
+								7,
+								"p",
+								"vfOriginX"
+							],
+							"+",
+							[
+								7,
+								"p",
+								"vfSpanX"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"cy",
+				[
+					6,
+					"std.clamp",
+					[
+						[
+							7,
+							"uv",
+							"y"
+						],
+						[
+							7,
+							"p",
+							"vfOriginY"
+						],
+						[
+							1,
+							[
+								7,
+								"p",
+								"vfOriginY"
+							],
+							"+",
+							[
+								7,
+								"p",
+								"vfSpanY"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"outside",
+				[
+					6,
+					"std.length",
+					[[
+						6,
+						"d.vec2f",
+						[[
+							1,
+							[
+								7,
+								"uv",
+								"x"
+							],
+							"-",
+							"cx"
+						], [
+							1,
+							[
+								7,
+								"uv",
+								"y"
+							],
+							"-",
+							"cy"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"circle",
+				[
+					1,
+					[
+						6,
+						"std.length",
+						[[
+							6,
+							"d.vec2f",
+							[[
+								1,
+								[
+									7,
+									"uv",
+									"x"
+								],
+								"-",
+								[5, "0.5"]
+							], [
+								1,
+								[
+									7,
+									"uv",
+									"y"
+								],
+								"-",
+								[5, "0.5"]
+							]]
+						]]
+					],
+					"-",
+					[
+						7,
+						"p",
+						"vfRBound"
+					]
+				]
+			],
+			[
+				13,
+				"tuv",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							1,
+							"cx",
+							"-",
+							[
+								7,
+								"p",
+								"vfOriginX"
+							]
+						],
+						"/",
+						[
+							7,
+							"p",
+							"vfSpanX"
+						]
+					], [
+						1,
+						[
+							1,
+							"cy",
+							"-",
+							[
+								7,
+								"p",
+								"vfOriginY"
+							]
+						],
+						"/",
+						[
+							7,
+							"p",
+							"vfSpanY"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"sil",
+				[
+					6,
+					"std.textureSampleLevel",
+					[
+						[
+							7,
+							[
+								7,
+								"irradianceFieldLayout",
+								"$"
+							],
+							"silhouetteTex"
+						],
+						[
+							7,
+							[
+								7,
+								"irradianceFieldLayout",
+								"$"
+							],
+							"samp"
+						],
+						"tuv",
+						[
+							6,
+							"d.f32",
+							[[5, "0"]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"inDomain",
+				[
+					1,
+					[
+						7,
+						"sil",
+						"z"
+					],
+					"*",
+					[
+						7,
+						"sil",
+						"w"
+					]
+				]
+			],
+			[
+				13,
+				"beyond",
+				[
+					6,
+					"std.max",
+					[[
+						6,
+						"std.max",
+						["outside", "circle"]
+					], [
+						1,
+						"inDomain",
+						"-",
+						"outside"
+					]]
+				]
+			],
+			[10, [
+				6,
+				"sane",
+				[[
+					6,
+					"std.select",
+					[
+						"inDomain",
+						"beyond",
+						[
+							1,
+							"outside",
+							">",
+							[5, "0"]
+						]
+					]
+				]]
+			]]
+		]]
+	},
+	externals: {
+		"irradianceFieldLayout": () => irradianceFieldLayout,
+		"std.clamp": () => clamp,
+		"std.length": () => length,
+		"d.vec2f": () => vec2f,
+		"std.textureSampleLevel": () => textureSampleLevel,
+		"d.f32": () => f32,
+		"std.max": () => max$1,
+		"sane": () => sane,
+		"std.select": () => select
+	}
+}) && $.f)({})).$name("irradianceVolumetricField");
+const SilhouetteParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	vfOriginX: f32,
+	vfOriginY: f32,
+	vfSpanX: f32,
+	vfSpanY: f32,
+	vfActiveRes: f32,
+	vfRBound: f32,
+	res: f32,
+	step: f32
+}), "SilhouetteParams");
+const silhouetteSeedLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	params: { uniform: SilhouetteParams },
+	fieldTex: {
+		texture: texture2d(f32),
+		sampleType: "unfilterable-float"
+	},
+	out: outEntry
+}), "silhouetteSeedLayout");
+const silhouetteStepLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	params: { uniform: SilhouetteParams },
+	src: { texture: texture2d(f32) },
+	out: outEntry
+}), "silhouetteStepLayout");
+var { fieldSampleFastArg } = buildFieldSampleGraphArgs();
+var silhouetteInside = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((tx, ty) => {
+	"use gpu";
+	const p = silhouetteSeedLayout.$.params;
+	const v = fieldSampleFastArg(vec2f(__tsover_add(p.vfOriginX, __tsover_mul(__tsover_div(__tsover_add(tx, .5), p.res), p.vfSpanX)), __tsover_add(p.vfOriginY, __tsover_mul(__tsover_div(__tsover_add(ty, .5), p.res), p.vfSpanY))), silhouetteSeedLayout.$.fieldTex, p.vfOriginX, p.vfOriginY, p.vfSpanX, p.vfSpanY, p.vfActiveRes, p.vfRBound).x;
+	return select(f32(1), f32(-1), v < 0);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "tx"
+		}, {
+			"type": "i",
+			"name": "ty"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"silhouetteSeedLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"uv",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"p",
+							"vfOriginX"
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"tx",
+									"+",
+									[5, "0.5"]
+								],
+								"/",
+								[
+									7,
+									"p",
+									"res"
+								]
+							],
+							"*",
+							[
+								7,
+								"p",
+								"vfSpanX"
+							]
+						]
+					], [
+						1,
+						[
+							7,
+							"p",
+							"vfOriginY"
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"ty",
+									"+",
+									[5, "0.5"]
+								],
+								"/",
+								[
+									7,
+									"p",
+									"res"
+								]
+							],
+							"*",
+							[
+								7,
+								"p",
+								"vfSpanY"
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"v",
+				[
+					7,
+					[
+						6,
+						"fieldSampleFastArg",
+						[
+							"uv",
+							[
+								7,
+								[
+									7,
+									"silhouetteSeedLayout",
+									"$"
+								],
+								"fieldTex"
+							],
+							[
+								7,
+								"p",
+								"vfOriginX"
+							],
+							[
+								7,
+								"p",
+								"vfOriginY"
+							],
+							[
+								7,
+								"p",
+								"vfSpanX"
+							],
+							[
+								7,
+								"p",
+								"vfSpanY"
+							],
+							[
+								7,
+								"p",
+								"vfActiveRes"
+							],
+							[
+								7,
+								"p",
+								"vfRBound"
+							]
+						]
+					],
+					"x"
+				]
+			],
+			[10, [
+				6,
+				"std.select",
+				[
+					[
+						6,
+						"d.f32",
+						[[5, "1"]]
+					],
+					[
+						6,
+						"d.f32",
+						[[
+							4,
+							"-",
+							[5, "1"]
+						]]
+					],
+					[
+						1,
+						"v",
+						"<",
+						[5, "0"]
+					]
+				]
+			]]
+		]]
+	},
+	externals: {
+		"silhouetteSeedLayout": () => silhouetteSeedLayout,
+		"d.vec2f": () => vec2f,
+		"fieldSampleFastArg": () => fieldSampleFastArg,
+		"std.select": () => select,
+		"d.f32": () => f32
+	}
+}) && $.f)({})).$name("silhouetteInside");
+const silhouetteSeedKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = silhouetteSeedLayout.$.params;
+	const fx = f32(cx);
+	const fy = f32(cy);
+	const s0 = silhouetteInside(fx, fy);
+	const maxT = __tsover_sub(p.res, 1);
+	const sL = silhouetteInside(max$1(__tsover_sub(fx, 1), 0), fy);
+	const sR = silhouetteInside(min(__tsover_add(fx, 1), maxT), fy);
+	const sD = silhouetteInside(fx, max$1(__tsover_sub(fy, 1), 0));
+	const sU = silhouetteInside(fx, min(__tsover_add(fy, 1), maxT));
+	const boundary = sL !== s0 || sR !== s0 || sD !== s0 || sU !== s0;
+	const sx = __tsover_add(p.vfOriginX, __tsover_mul(__tsover_div(__tsover_add(fx, .5), p.res), p.vfSpanX));
+	const sy = __tsover_add(p.vfOriginY, __tsover_mul(__tsover_div(__tsover_add(fy, .5), p.res), p.vfSpanY));
+	const seed = select(vec4f(-1, -1, 6e4, s0), vec4f(sx, sy, 0, s0), boundary);
+	textureStore(silhouetteSeedLayout.$.out, vec2u(cx, cy), seed);
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"silhouetteSeedLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"fx",
+				[
+					6,
+					"d.f32",
+					["cx"]
+				]
+			],
+			[
+				13,
+				"fy",
+				[
+					6,
+					"d.f32",
+					["cy"]
+				]
+			],
+			[
+				13,
+				"s0",
+				[
+					6,
+					"silhouetteInside",
+					["fx", "fy"]
+				]
+			],
+			[
+				13,
+				"maxT",
+				[
+					1,
+					[
+						7,
+						"p",
+						"res"
+					],
+					"-",
+					[5, "1"]
+				]
+			],
+			[
+				13,
+				"sL",
+				[
+					6,
+					"silhouetteInside",
+					[[
+						6,
+						"std.max",
+						[[
+							1,
+							"fx",
+							"-",
+							[5, "1"]
+						], [5, "0"]]
+					], "fy"]
+				]
+			],
+			[
+				13,
+				"sR",
+				[
+					6,
+					"silhouetteInside",
+					[[
+						6,
+						"std.min",
+						[[
+							1,
+							"fx",
+							"+",
+							[5, "1"]
+						], "maxT"]
+					], "fy"]
+				]
+			],
+			[
+				13,
+				"sD",
+				[
+					6,
+					"silhouetteInside",
+					["fx", [
+						6,
+						"std.max",
+						[[
+							1,
+							"fy",
+							"-",
+							[5, "1"]
+						], [5, "0"]]
+					]]
+				]
+			],
+			[
+				13,
+				"sU",
+				[
+					6,
+					"silhouetteInside",
+					["fx", [
+						6,
+						"std.min",
+						[[
+							1,
+							"fy",
+							"+",
+							[5, "1"]
+						], "maxT"]
+					]]
+				]
+			],
+			[
+				13,
+				"boundary",
+				[
+					3,
+					[
+						3,
+						[
+							3,
+							[
+								1,
+								"sL",
+								"!==",
+								"s0"
+							],
+							"||",
+							[
+								1,
+								"sR",
+								"!==",
+								"s0"
+							]
+						],
+						"||",
+						[
+							1,
+							"sD",
+							"!==",
+							"s0"
+						]
+					],
+					"||",
+					[
+						1,
+						"sU",
+						"!==",
+						"s0"
+					]
+				]
+			],
+			[
+				13,
+				"sx",
+				[
+					1,
+					[
+						7,
+						"p",
+						"vfOriginX"
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"fx",
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							[
+								7,
+								"p",
+								"res"
+							]
+						],
+						"*",
+						[
+							7,
+							"p",
+							"vfSpanX"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"sy",
+				[
+					1,
+					[
+						7,
+						"p",
+						"vfOriginY"
+					],
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"fy",
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							[
+								7,
+								"p",
+								"res"
+							]
+						],
+						"*",
+						[
+							7,
+							"p",
+							"vfSpanY"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"seed",
+				[
+					6,
+					"std.select",
+					[
+						[
+							6,
+							"d.vec4f",
+							[
+								[
+									4,
+									"-",
+									[5, "1"]
+								],
+								[
+									4,
+									"-",
+									[5, "1"]
+								],
+								[5, "60000"],
+								"s0"
+							]
+						],
+						[
+							6,
+							"d.vec4f",
+							[
+								"sx",
+								"sy",
+								[5, "0"],
+								"s0"
+							]
+						],
+						"boundary"
+					]
+				]
+			],
+			[
+				6,
+				"std.textureStore",
+				[
+					[
+						7,
+						[
+							7,
+							"silhouetteSeedLayout",
+							"$"
+						],
+						"out"
+					],
+					[
+						6,
+						"d.vec2u",
+						["cx", "cy"]
+					],
+					"seed"
+				]
+			]
+		]]
+	},
+	externals: {
+		"silhouetteSeedLayout": () => silhouetteSeedLayout,
+		"d.f32": () => f32,
+		"silhouetteInside": () => silhouetteInside,
+		"std.max": () => max$1,
+		"std.min": () => min,
+		"std.select": () => select,
+		"d.vec4f": () => vec4f,
+		"std.textureStore": () => textureStore,
+		"d.vec2u": () => vec2u
+	}
+}) && $.f)({})).$name("silhouetteSeed");
+const silhouetteStepKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const p = silhouetteStepLayout.$.params;
+	const tx = f32(cx);
+	const ty = f32(cy);
+	const here = vec2f(__tsover_add(p.vfOriginX, __tsover_mul(__tsover_div(__tsover_add(tx, .5), p.res), p.vfSpanX)), __tsover_add(p.vfOriginY, __tsover_mul(__tsover_div(__tsover_add(ty, .5), p.res), p.vfSpanY)));
+	const self = textureLoad(silhouetteStepLayout.$.src, vec2u(cx, cy), 0);
+	let best = vec4f(self);
+	const maxT = __tsover_sub(p.res, 1);
+	for (let j = -1; j <= 1; j++) for (let i = -1; i <= 1; i++) {
+		const nx = clamp(__tsover_add(tx, __tsover_mul(f32(i), p.step)), 0, maxT);
+		const ny = clamp(__tsover_add(ty, __tsover_mul(f32(j), p.step)), 0, maxT);
+		const n = textureLoad(silhouetteStepLayout.$.src, vec2u(u32(nx), u32(ny)), 0);
+		if (n.x >= 0) {
+			const dist = length(n.xy.sub(here));
+			if (dist < best.z) best = vec4f(n.x, n.y, dist, best.w);
+		}
+	}
+	textureStore(silhouetteStepLayout.$.out, vec2u(cx, cy), vec4f(best.x, best.y, best.z, self.w));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"p",
+				[
+					7,
+					[
+						7,
+						"silhouetteStepLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"tx",
+				[
+					6,
+					"d.f32",
+					["cx"]
+				]
+			],
+			[
+				13,
+				"ty",
+				[
+					6,
+					"d.f32",
+					["cy"]
+				]
+			],
+			[
+				13,
+				"here",
+				[
+					6,
+					"d.vec2f",
+					[[
+						1,
+						[
+							7,
+							"p",
+							"vfOriginX"
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"tx",
+									"+",
+									[5, "0.5"]
+								],
+								"/",
+								[
+									7,
+									"p",
+									"res"
+								]
+							],
+							"*",
+							[
+								7,
+								"p",
+								"vfSpanX"
+							]
+						]
+					], [
+						1,
+						[
+							7,
+							"p",
+							"vfOriginY"
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"ty",
+									"+",
+									[5, "0.5"]
+								],
+								"/",
+								[
+									7,
+									"p",
+									"res"
+								]
+							],
+							"*",
+							[
+								7,
+								"p",
+								"vfSpanY"
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"self",
+				[
+					6,
+					"std.textureLoad",
+					[
+						[
+							7,
+							[
+								7,
+								"silhouetteStepLayout",
+								"$"
+							],
+							"src"
+						],
+						[
+							6,
+							"d.vec2u",
+							["cx", "cy"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				12,
+				"best",
+				[
+					6,
+					"d.vec4f",
+					["self"]
+				]
+			],
+			[
+				13,
+				"maxT",
+				[
+					1,
+					[
+						7,
+						"p",
+						"res"
+					],
+					"-",
+					[5, "1"]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"j",
+					[
+						4,
+						"-",
+						[5, "1"]
+					]
+				],
+				[
+					1,
+					"j",
+					"<=",
+					[5, "1"]
+				],
+				[
+					102,
+					"++",
+					"j"
+				],
+				[0, [[
+					14,
+					[
+						12,
+						"i",
+						[
+							4,
+							"-",
+							[5, "1"]
+						]
+					],
+					[
+						1,
+						"i",
+						"<=",
+						[5, "1"]
+					],
+					[
+						102,
+						"++",
+						"i"
+					],
+					[0, [
+						[
+							13,
+							"nx",
+							[
+								6,
+								"std.clamp",
+								[
+									[
+										1,
+										"tx",
+										"+",
+										[
+											1,
+											[
+												6,
+												"d.f32",
+												["i"]
+											],
+											"*",
+											[
+												7,
+												"p",
+												"step"
+											]
+										]
+									],
+									[5, "0"],
+									"maxT"
+								]
+							]
+						],
+						[
+							13,
+							"ny",
+							[
+								6,
+								"std.clamp",
+								[
+									[
+										1,
+										"ty",
+										"+",
+										[
+											1,
+											[
+												6,
+												"d.f32",
+												["j"]
+											],
+											"*",
+											[
+												7,
+												"p",
+												"step"
+											]
+										]
+									],
+									[5, "0"],
+									"maxT"
+								]
+							]
+						],
+						[
+							13,
+							"n",
+							[
+								6,
+								"std.textureLoad",
+								[
+									[
+										7,
+										[
+											7,
+											"silhouetteStepLayout",
+											"$"
+										],
+										"src"
+									],
+									[
+										6,
+										"d.vec2u",
+										[[
+											6,
+											"d.u32",
+											["nx"]
+										], [
+											6,
+											"d.u32",
+											["ny"]
+										]]
+									],
+									[5, "0"]
+								]
+							]
+						],
+						[
+							11,
+							[
+								1,
+								[
+									7,
+									"n",
+									"x"
+								],
+								">=",
+								[5, "0"]
+							],
+							[0, [[
+								13,
+								"dist",
+								[
+									6,
+									"std.length",
+									[[
+										6,
+										[
+											7,
+											[
+												7,
+												"n",
+												"xy"
+											],
+											"sub"
+										],
+										["here"]
+									]]
+								]
+							], [
+								11,
+								[
+									1,
+									"dist",
+									"<",
+									[
+										7,
+										"best",
+										"z"
+									]
+								],
+								[0, [[
+									2,
+									"best",
+									"=",
+									[
+										6,
+										"d.vec4f",
+										[
+											[
+												7,
+												"n",
+												"x"
+											],
+											[
+												7,
+												"n",
+												"y"
+											],
+											"dist",
+											[
+												7,
+												"best",
+												"w"
+											]
+										]
+									]
+								]]]
+							]]]
+						]
+					]]
+				]]]
+			],
+			[
+				6,
+				"std.textureStore",
+				[
+					[
+						7,
+						[
+							7,
+							"silhouetteStepLayout",
+							"$"
+						],
+						"out"
+					],
+					[
+						6,
+						"d.vec2u",
+						["cx", "cy"]
+					],
+					[
+						6,
+						"d.vec4f",
+						[
+							[
+								7,
+								"best",
+								"x"
+							],
+							[
+								7,
+								"best",
+								"y"
+							],
+							[
+								7,
+								"best",
+								"z"
+							],
+							[
+								7,
+								"self",
+								"w"
+							]
+						]
+					]
+				]
+			]
+		]]
+	},
+	externals: {
+		"silhouetteStepLayout": () => silhouetteStepLayout,
+		"d.f32": () => f32,
+		"d.vec2f": () => vec2f,
+		"std.textureLoad": () => textureLoad,
+		"d.vec2u": () => vec2u,
+		"d.vec4f": () => vec4f,
+		"std.clamp": () => clamp,
+		"d.u32": () => u32,
+		"std.length": () => length,
+		"std.textureStore": () => textureStore
+	}
+}) && $.f)({})).$name("silhouetteStep");
+function buildIrradianceKernel(layout, fieldAt, opts) {
+	const { steps, shadowSteps, namePrefix } = opts;
+	const RAY_SPAN = 3;
+	const shadows = shadowSteps > 0;
+	const shadowLoop = Math.max(shadowSteps, 1);
+	const lay = layout;
+	const visibility = typegpu_default.fn([
+		vec2f,
+		vec2f,
+		f32,
+		f32
+	], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((from, toward, eps, soft) => {
+		"use gpu";
+		const seg = toward.sub(from);
+		const len = length(seg);
+		const dir = seg.div(max$1(len, 1e-4));
+		let vis = f32(1);
+		let t = __tsover_mul(eps, 2);
+		for (let k = 0; k < shadowLoop; k++) {
+			if (t >= len) break;
+			const dd = fieldAt(from.add(dir.mul(t)));
+			vis = min(vis, clamp(__tsover_div(dd, max$1(__tsover_mul(t, soft), eps)), 0, 1));
+			if (vis <= 0) break;
+			t = __tsover_add(t, max$1(dd, eps));
+		}
+		return vis;
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "from"
+				},
+				{
+					"type": "i",
+					"name": "toward"
+				},
+				{
+					"type": "i",
+					"name": "eps"
+				},
+				{
+					"type": "i",
+					"name": "soft"
+				}
+			],
+			"body": [0, [
+				[
+					13,
+					"seg",
+					[
+						6,
+						[
+							7,
+							"toward",
+							"sub"
+						],
+						["from"]
+					]
+				],
+				[
+					13,
+					"len",
+					[
+						6,
+						"std.length",
+						["seg"]
+					]
+				],
+				[
+					13,
+					"dir",
+					[
+						6,
+						[
+							7,
+							"seg",
+							"div"
+						],
+						[[
+							6,
+							"std.max",
+							["len", [5, "0.0001"]]
+						]]
+					]
+				],
+				[
+					12,
+					"vis",
+					[
+						6,
+						"d.f32",
+						[[5, "1"]]
+					]
+				],
+				[
+					12,
+					"t",
+					[
+						1,
+						"eps",
+						"*",
+						[5, "2"]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"k",
+						[5, "0"]
+					],
+					[
+						1,
+						"k",
+						"<",
+						"shadowLoop"
+					],
+					[
+						102,
+						"++",
+						"k"
+					],
+					[0, [
+						[
+							11,
+							[
+								1,
+								"t",
+								">=",
+								"len"
+							],
+							[0, [[17]]]
+						],
+						[
+							13,
+							"dd",
+							[
+								6,
+								"fieldAt",
+								[[
+									6,
+									[
+										7,
+										"from",
+										"add"
+									],
+									[[
+										6,
+										[
+											7,
+											"dir",
+											"mul"
+										],
+										["t"]
+									]]
+								]]
+							]
+						],
+						[
+							2,
+							"vis",
+							"=",
+							[
+								6,
+								"std.min",
+								["vis", [
+									6,
+									"std.clamp",
+									[
+										[
+											1,
+											"dd",
+											"/",
+											[
+												6,
+												"std.max",
+												[[
+													1,
+													"t",
+													"*",
+													"soft"
+												], "eps"]
+											]
+										],
+										[5, "0"],
+										[5, "1"]
+									]
+								]]
+							]
+						],
+						[
+							11,
+							[
+								1,
+								"vis",
+								"<=",
+								[5, "0"]
+							],
+							[0, [[17]]]
+						],
+						[
+							2,
+							"t",
+							"+=",
+							[
+								6,
+								"std.max",
+								["dd", "eps"]
+							]
+						]
+					]]
+				],
+				[10, "vis"]
+			]]
+		},
+		externals: {
+			"std.length": () => length,
+			"std.max": () => max$1,
+			"d.f32": () => f32,
+			"shadowLoop": () => shadowLoop,
+			"fieldAt": () => fieldAt,
+			"std.min": () => min,
+			"std.clamp": () => clamp
+		}
+	}) && $.f)({})).$name(`${namePrefix}Visibility`);
+	return typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		const p = lay.$.params;
+		const eps = p.eps;
+		const uv = vec2f(__tsover_div(__tsover_add(f32(cx), .5), p.res), __tsover_div(__tsover_add(f32(cy), .5), p.res));
+		const sdfUV = sdfSpaceUV(p.center, p.scale, p.rotation, uv, p.aspect);
+		const d0 = fieldAt(sdfUV);
+		if (d0 < __tsover_mul(eps, -1)) {
+			textureStore(lay.$.outTex, vec2u(cx, cy), vec4f(0, 0, 0, 0));
+			return;
+		}
+		let o = vec2f(sdfUV);
+		if (d0 < __tsover_mul(eps, 2)) {
+			const gx = __tsover_sub(fieldAt(sdfUV.add(vec2f(eps, 0))), d0);
+			const gy = __tsover_sub(fieldAt(sdfUV.add(vec2f(0, eps))), d0);
+			const g = normalize$1(vec2f(gx, __tsover_add(gy, 1e-6)));
+			o = sdfUV.add(g.mul(__tsover_sub(__tsover_mul(eps, 2), d0)));
+		}
+		const start = max$1(fieldAt(o), eps);
+		const tMax = __tsover_add(start, RAY_SPAN);
+		const ign = fract(__tsover_mul(52.9829189, fract(__tsover_add(__tsover_mul(f32(cx), .06711056), __tsover_mul(f32(cy), .00583715)))));
+		const u = fract(__tsover_add(ign, __tsover_mul(p.frame, .6180339887)));
+		const rays = i32(p.rays);
+		const rayStep = __tsover_div(TAU, p.rays);
+		const lightCount = i32(p.lightCount);
+		let acc = vec3f(0, 0, 0);
+		for (let i = 0; i < rays; i++) {
+			const ang = __tsover_mul(__tsover_add(f32(i), u), rayStep);
+			const dir = vec2f(cos(ang), sin(ang));
+			let t = start;
+			let hitD = f32(1);
+			for (let s = 0; s < steps; s++) {
+				const dd = fieldAt(o.add(dir.mul(t)));
+				if (dd < eps) {
+					hitD = dd;
+					break;
+				}
+				t = __tsover_add(t, max$1(dd, eps));
+				if (t > tMax) break;
+			}
+			if (hitD < eps) {
+				const pos = o.add(dir.mul(t));
+				const nx = __tsover_sub(fieldAt(pos.add(vec2f(eps, 0))), hitD);
+				const ny = __tsover_sub(fieldAt(pos.add(vec2f(0, eps))), hitD);
+				const n = normalize$1(vec2f(nx, __tsover_add(ny, 1e-6)));
+				const hitP = pos.sub(n.mul(max$1(hitD, 0)));
+				const shadowFrom = hitP.add(n.mul(__tsover_mul(eps, 2)));
+				for (let l = 0; l < lightCount; l++) {
+					const lp = p.lightPos[l];
+					const lc = p.lightColor[l];
+					const lightUV = lp.xy;
+					const toL = lightUV.sub(hitP);
+					const dist = length(toL);
+					const dirL = toL.div(max$1(dist, 1e-4));
+					const facing = clamp(__tsover_div(__tsover_add(dot$1(n, dirL), p.wrap), __tsover_add(1, p.wrap)), 0, 1);
+					if (facing > 0) {
+						const r = __tsover_div(dist, p.lightRange);
+						let struck = __tsover_div(facing, __tsover_add(1, __tsover_mul(r, r)));
+						if (shadows) struck = __tsover_mul(struck, visibility(shadowFrom, lightUV, eps, p.shadowSoftness));
+						acc = acc.add(lc.xyz.mul(__tsover_mul(struck, lc.w)));
+					}
+				}
+			}
+		}
+		const fade = __tsover_sub(1, smoothstep$1(__tsover_mul(p.reach, .25), p.reach, max$1(d0, 0)));
+		const m = clamp(__tsover_add(__tsover_div(d0, eps), 1), 0, 1);
+		const irr = min(max$1(acc.div(p.rays), vec3f(0, 0, 0)), vec3f(FAR, FAR, FAR));
+		textureStore(lay.$.outTex, vec2u(cx, cy), vec4f(irr.mul(__tsover_mul(fade, m)), m));
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [
+				[
+					13,
+					"p",
+					[
+						7,
+						[
+							7,
+							"lay",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"eps",
+					[
+						7,
+						"p",
+						"eps"
+					]
+				],
+				[
+					13,
+					"uv",
+					[
+						6,
+						"d.vec2f",
+						[[
+							1,
+							[
+								1,
+								[
+									6,
+									"d.f32",
+									["cx"]
+								],
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							[
+								7,
+								"p",
+								"res"
+							]
+						], [
+							1,
+							[
+								1,
+								[
+									6,
+									"d.f32",
+									["cy"]
+								],
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							[
+								7,
+								"p",
+								"res"
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"sdfUV",
+					[
+						6,
+						"sdfSpaceUV",
+						[
+							[
+								7,
+								"p",
+								"center"
+							],
+							[
+								7,
+								"p",
+								"scale"
+							],
+							[
+								7,
+								"p",
+								"rotation"
+							],
+							"uv",
+							[
+								7,
+								"p",
+								"aspect"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"d0",
+					[
+						6,
+						"fieldAt",
+						["sdfUV"]
+					]
+				],
+				[
+					11,
+					[
+						1,
+						"d0",
+						"<",
+						[
+							1,
+							"eps",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					],
+					[0, [[
+						6,
+						"std.textureStore",
+						[
+							[
+								7,
+								[
+									7,
+									"lay",
+									"$"
+								],
+								"outTex"
+							],
+							[
+								6,
+								"d.vec2u",
+								["cx", "cy"]
+							],
+							[
+								6,
+								"d.vec4f",
+								[
+									[5, "0"],
+									[5, "0"],
+									[5, "0"],
+									[5, "0"]
+								]
+							]
+						]
+					], [10]]]
+				],
+				[
+					12,
+					"o",
+					[
+						6,
+						"d.vec2f",
+						["sdfUV"]
+					]
+				],
+				[
+					11,
+					[
+						1,
+						"d0",
+						"<",
+						[
+							1,
+							"eps",
+							"*",
+							[5, "2"]
+						]
+					],
+					[0, [
+						[
+							13,
+							"gx",
+							[
+								1,
+								[
+									6,
+									"fieldAt",
+									[[
+										6,
+										[
+											7,
+											"sdfUV",
+											"add"
+										],
+										[[
+											6,
+											"d.vec2f",
+											["eps", [5, "0"]]
+										]]
+									]]
+								],
+								"-",
+								"d0"
+							]
+						],
+						[
+							13,
+							"gy",
+							[
+								1,
+								[
+									6,
+									"fieldAt",
+									[[
+										6,
+										[
+											7,
+											"sdfUV",
+											"add"
+										],
+										[[
+											6,
+											"d.vec2f",
+											[[5, "0"], "eps"]
+										]]
+									]]
+								],
+								"-",
+								"d0"
+							]
+						],
+						[
+							13,
+							"g",
+							[
+								6,
+								"std.normalize",
+								[[
+									6,
+									"d.vec2f",
+									["gx", [
+										1,
+										"gy",
+										"+",
+										[5, "0.000001"]
+									]]
+								]]
+							]
+						],
+						[
+							2,
+							"o",
+							"=",
+							[
+								6,
+								[
+									7,
+									"sdfUV",
+									"add"
+								],
+								[[
+									6,
+									[
+										7,
+										"g",
+										"mul"
+									],
+									[[
+										1,
+										[
+											1,
+											"eps",
+											"*",
+											[5, "2"]
+										],
+										"-",
+										"d0"
+									]]
+								]]
+							]
+						]
+					]]
+				],
+				[
+					13,
+					"start",
+					[
+						6,
+						"std.max",
+						[[
+							6,
+							"fieldAt",
+							["o"]
+						], "eps"]
+					]
+				],
+				[
+					13,
+					"tMax",
+					[
+						1,
+						"start",
+						"+",
+						"RAY_SPAN"
+					]
+				],
+				[
+					13,
+					"ign",
+					[
+						6,
+						"std.fract",
+						[[
+							1,
+							[5, "52.9829189"],
+							"*",
+							[
+								6,
+								"std.fract",
+								[[
+									1,
+									[
+										1,
+										[
+											6,
+											"d.f32",
+											["cx"]
+										],
+										"*",
+										[5, "0.06711056"]
+									],
+									"+",
+									[
+										1,
+										[
+											6,
+											"d.f32",
+											["cy"]
+										],
+										"*",
+										[5, "0.00583715"]
+									]
+								]]
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"u",
+					[
+						6,
+						"std.fract",
+						[[
+							1,
+							"ign",
+							"+",
+							[
+								1,
+								[
+									7,
+									"p",
+									"frame"
+								],
+								"*",
+								[5, "0.6180339887"]
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"rays",
+					[
+						6,
+						"d.i32",
+						[[
+							7,
+							"p",
+							"rays"
+						]]
+					]
+				],
+				[
+					13,
+					"rayStep",
+					[
+						1,
+						"TAU",
+						"/",
+						[
+							7,
+							"p",
+							"rays"
+						]
+					]
+				],
+				[
+					13,
+					"lightCount",
+					[
+						6,
+						"d.i32",
+						[[
+							7,
+							"p",
+							"lightCount"
+						]]
+					]
+				],
+				[
+					12,
+					"acc",
+					[
+						6,
+						"d.vec3f",
+						[
+							[5, "0"],
+							[5, "0"],
+							[5, "0"]
+						]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"i",
+						[5, "0"]
+					],
+					[
+						1,
+						"i",
+						"<",
+						"rays"
+					],
+					[
+						102,
+						"++",
+						"i"
+					],
+					[0, [
+						[
+							13,
+							"ang",
+							[
+								1,
+								[
+									1,
+									[
+										6,
+										"d.f32",
+										["i"]
+									],
+									"+",
+									"u"
+								],
+								"*",
+								"rayStep"
+							]
+						],
+						[
+							13,
+							"dir",
+							[
+								6,
+								"d.vec2f",
+								[[
+									6,
+									"std.cos",
+									["ang"]
+								], [
+									6,
+									"std.sin",
+									["ang"]
+								]]
+							]
+						],
+						[
+							12,
+							"t",
+							"start"
+						],
+						[
+							12,
+							"hitD",
+							[
+								6,
+								"d.f32",
+								[[5, "1"]]
+							]
+						],
+						[
+							14,
+							[
+								12,
+								"s",
+								[5, "0"]
+							],
+							[
+								1,
+								"s",
+								"<",
+								"steps"
+							],
+							[
+								102,
+								"++",
+								"s"
+							],
+							[0, [
+								[
+									13,
+									"dd",
+									[
+										6,
+										"fieldAt",
+										[[
+											6,
+											[
+												7,
+												"o",
+												"add"
+											],
+											[[
+												6,
+												[
+													7,
+													"dir",
+													"mul"
+												],
+												["t"]
+											]]
+										]]
+									]
+								],
+								[
+									11,
+									[
+										1,
+										"dd",
+										"<",
+										"eps"
+									],
+									[0, [[
+										2,
+										"hitD",
+										"=",
+										"dd"
+									], [17]]]
+								],
+								[
+									2,
+									"t",
+									"+=",
+									[
+										6,
+										"std.max",
+										["dd", "eps"]
+									]
+								],
+								[
+									11,
+									[
+										1,
+										"t",
+										">",
+										"tMax"
+									],
+									[0, [[17]]]
+								]
+							]]
+						],
+						[
+							11,
+							[
+								1,
+								"hitD",
+								"<",
+								"eps"
+							],
+							[0, [
+								[
+									13,
+									"pos",
+									[
+										6,
+										[
+											7,
+											"o",
+											"add"
+										],
+										[[
+											6,
+											[
+												7,
+												"dir",
+												"mul"
+											],
+											["t"]
+										]]
+									]
+								],
+								[
+									13,
+									"nx",
+									[
+										1,
+										[
+											6,
+											"fieldAt",
+											[[
+												6,
+												[
+													7,
+													"pos",
+													"add"
+												],
+												[[
+													6,
+													"d.vec2f",
+													["eps", [5, "0"]]
+												]]
+											]]
+										],
+										"-",
+										"hitD"
+									]
+								],
+								[
+									13,
+									"ny",
+									[
+										1,
+										[
+											6,
+											"fieldAt",
+											[[
+												6,
+												[
+													7,
+													"pos",
+													"add"
+												],
+												[[
+													6,
+													"d.vec2f",
+													[[5, "0"], "eps"]
+												]]
+											]]
+										],
+										"-",
+										"hitD"
+									]
+								],
+								[
+									13,
+									"n",
+									[
+										6,
+										"std.normalize",
+										[[
+											6,
+											"d.vec2f",
+											["nx", [
+												1,
+												"ny",
+												"+",
+												[5, "0.000001"]
+											]]
+										]]
+									]
+								],
+								[
+									13,
+									"hitP",
+									[
+										6,
+										[
+											7,
+											"pos",
+											"sub"
+										],
+										[[
+											6,
+											[
+												7,
+												"n",
+												"mul"
+											],
+											[[
+												6,
+												"std.max",
+												["hitD", [5, "0"]]
+											]]
+										]]
+									]
+								],
+								[
+									13,
+									"shadowFrom",
+									[
+										6,
+										[
+											7,
+											"hitP",
+											"add"
+										],
+										[[
+											6,
+											[
+												7,
+												"n",
+												"mul"
+											],
+											[[
+												1,
+												"eps",
+												"*",
+												[5, "2"]
+											]]
+										]]
+									]
+								],
+								[
+									14,
+									[
+										12,
+										"l",
+										[5, "0"]
+									],
+									[
+										1,
+										"l",
+										"<",
+										"lightCount"
+									],
+									[
+										102,
+										"++",
+										"l"
+									],
+									[0, [
+										[
+											13,
+											"lp",
+											[
+												8,
+												[
+													7,
+													"p",
+													"lightPos"
+												],
+												"l"
+											]
+										],
+										[
+											13,
+											"lc",
+											[
+												8,
+												[
+													7,
+													"p",
+													"lightColor"
+												],
+												"l"
+											]
+										],
+										[
+											13,
+											"lightUV",
+											[
+												7,
+												"lp",
+												"xy"
+											]
+										],
+										[
+											13,
+											"toL",
+											[
+												6,
+												[
+													7,
+													"lightUV",
+													"sub"
+												],
+												["hitP"]
+											]
+										],
+										[
+											13,
+											"dist",
+											[
+												6,
+												"std.length",
+												["toL"]
+											]
+										],
+										[
+											13,
+											"dirL",
+											[
+												6,
+												[
+													7,
+													"toL",
+													"div"
+												],
+												[[
+													6,
+													"std.max",
+													["dist", [5, "0.0001"]]
+												]]
+											]
+										],
+										[
+											13,
+											"facing",
+											[
+												6,
+												"std.clamp",
+												[
+													[
+														1,
+														[
+															1,
+															[
+																6,
+																"std.dot",
+																["n", "dirL"]
+															],
+															"+",
+															[
+																7,
+																"p",
+																"wrap"
+															]
+														],
+														"/",
+														[
+															1,
+															[5, "1"],
+															"+",
+															[
+																7,
+																"p",
+																"wrap"
+															]
+														]
+													],
+													[5, "0"],
+													[5, "1"]
+												]
+											]
+										],
+										[
+											11,
+											[
+												1,
+												"facing",
+												">",
+												[5, "0"]
+											],
+											[0, [
+												[
+													13,
+													"r",
+													[
+														1,
+														"dist",
+														"/",
+														[
+															7,
+															"p",
+															"lightRange"
+														]
+													]
+												],
+												[
+													12,
+													"struck",
+													[
+														1,
+														"facing",
+														"/",
+														[
+															1,
+															[5, "1"],
+															"+",
+															[
+																1,
+																"r",
+																"*",
+																"r"
+															]
+														]
+													]
+												],
+												[
+													11,
+													"shadows",
+													[0, [[
+														2,
+														"struck",
+														"=",
+														[
+															1,
+															"struck",
+															"*",
+															[
+																6,
+																"visibility",
+																[
+																	"shadowFrom",
+																	"lightUV",
+																	"eps",
+																	[
+																		7,
+																		"p",
+																		"shadowSoftness"
+																	]
+																]
+															]
+														]
+													]]]
+												],
+												[
+													2,
+													"acc",
+													"=",
+													[
+														6,
+														[
+															7,
+															"acc",
+															"add"
+														],
+														[[
+															6,
+															[
+																7,
+																[
+																	7,
+																	"lc",
+																	"xyz"
+																],
+																"mul"
+															],
+															[[
+																1,
+																"struck",
+																"*",
+																[
+																	7,
+																	"lc",
+																	"w"
+																]
+															]]
+														]]
+													]
+												]
+											]]
+										]
+									]]
+								]
+							]]
+						]
+					]]
+				],
+				[
+					13,
+					"fade",
+					[
+						1,
+						[5, "1"],
+						"-",
+						[
+							6,
+							"std.smoothstep",
+							[
+								[
+									1,
+									[
+										7,
+										"p",
+										"reach"
+									],
+									"*",
+									[5, "0.25"]
+								],
+								[
+									7,
+									"p",
+									"reach"
+								],
+								[
+									6,
+									"std.max",
+									["d0", [5, "0"]]
+								]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"m",
+					[
+						6,
+						"std.clamp",
+						[
+							[
+								1,
+								[
+									1,
+									"d0",
+									"/",
+									"eps"
+								],
+								"+",
+								[5, "1"]
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				],
+				[
+					13,
+					"irr",
+					[
+						6,
+						"std.min",
+						[[
+							6,
+							"std.max",
+							[[
+								6,
+								[
+									7,
+									"acc",
+									"div"
+								],
+								[[
+									7,
+									"p",
+									"rays"
+								]]
+							], [
+								6,
+								"d.vec3f",
+								[
+									[5, "0"],
+									[5, "0"],
+									[5, "0"]
+								]
+							]]
+						], [
+							6,
+							"d.vec3f",
+							[
+								"FAR",
+								"FAR",
+								"FAR"
+							]
+						]]
+					]
+				],
+				[
+					6,
+					"std.textureStore",
+					[
+						[
+							7,
+							[
+								7,
+								"lay",
+								"$"
+							],
+							"outTex"
+						],
+						[
+							6,
+							"d.vec2u",
+							["cx", "cy"]
+						],
+						[
+							6,
+							"d.vec4f",
+							[[
+								6,
+								[
+									7,
+									"irr",
+									"mul"
+								],
+								[[
+									1,
+									"fade",
+									"*",
+									"m"
+								]]
+							], "m"]
+						]
+					]
+				]
+			]]
+		},
+		externals: {
+			"lay": () => lay,
+			"d.vec2f": () => vec2f,
+			"d.f32": () => f32,
+			"sdfSpaceUV": () => sdfSpaceUV,
+			"fieldAt": () => fieldAt,
+			"std.textureStore": () => textureStore,
+			"d.vec2u": () => vec2u,
+			"d.vec4f": () => vec4f,
+			"std.normalize": () => normalize$1,
+			"std.max": () => max$1,
+			"RAY_SPAN": () => RAY_SPAN,
+			"std.fract": () => fract,
+			"d.i32": () => i32,
+			"TAU": () => TAU,
+			"d.vec3f": () => vec3f,
+			"std.cos": () => cos,
+			"std.sin": () => sin,
+			"steps": () => steps,
+			"std.length": () => length,
+			"std.clamp": () => clamp,
+			"std.dot": () => dot$1,
+			"shadows": () => shadows,
+			"visibility": () => visibility,
+			"std.smoothstep": () => smoothstep$1,
+			"std.min": () => min,
+			"FAR": () => FAR
+		}
+	}) && $.f)({})).$name(`${namePrefix}Gather`);
+}
+function createIrradiancePass(root, kernel, opts) {
+	return createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		"use gpu";
+		kernel(cx, cy);
+	}), {
+		v: 2,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "cx"
+			}, {
+				"type": "i",
+				"name": "cy"
+			}],
+			"body": [0, [[
+				6,
+				"kernel",
+				["cx", "cy"]
+			]]]
+		},
+		externals: { "kernel": () => kernel }
+	}) && $.f)({}), {
+		size: [opts.res, opts.res],
+		bindGroup: opts.bindGroup
+	});
+}
+const AccumulateParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({ weight: f32 }), "AccumulateParams");
+const accumulateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	sample: { texture: texture2d(f32) },
+	prev: { texture: texture2d(f32) },
+	out: outEntry,
+	params: { uniform: AccumulateParams }
+}), "accumulateLayout");
+const accumulateKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const at = vec2u(cx, cy);
+	const s = textureLoad(accumulateLayout.$.sample, at, 0);
+	const prev = textureLoad(accumulateLayout.$.prev, at, 0);
+	const w = accumulateLayout.$.params.weight;
+	textureStore(accumulateLayout.$.out, at, select(prev.add(s.sub(prev).mul(w)), s, w >= 1));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"at",
+				[
+					6,
+					"d.vec2u",
+					["cx", "cy"]
+				]
+			],
+			[
+				13,
+				"s",
+				[
+					6,
+					"std.textureLoad",
+					[
+						[
+							7,
+							[
+								7,
+								"accumulateLayout",
+								"$"
+							],
+							"sample"
+						],
+						"at",
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"prev",
+				[
+					6,
+					"std.textureLoad",
+					[
+						[
+							7,
+							[
+								7,
+								"accumulateLayout",
+								"$"
+							],
+							"prev"
+						],
+						"at",
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"w",
+				[
+					7,
+					[
+						7,
+						[
+							7,
+							"accumulateLayout",
+							"$"
+						],
+						"params"
+					],
+					"weight"
+				]
+			],
+			[
+				6,
+				"std.textureStore",
+				[
+					[
+						7,
+						[
+							7,
+							"accumulateLayout",
+							"$"
+						],
+						"out"
+					],
+					"at",
+					[
+						6,
+						"std.select",
+						[
+							[
+								6,
+								[
+									7,
+									"prev",
+									"add"
+								],
+								[[
+									6,
+									[
+										7,
+										[
+											6,
+											[
+												7,
+												"s",
+												"sub"
+											],
+											["prev"]
+										],
+										"mul"
+									],
+									["w"]
+								]]
+							],
+							"s",
+							[
+								1,
+								"w",
+								">=",
+								[5, "1"]
+							]
+						]
+					]
+				]
+			]
+		]]
+	},
+	externals: {
+		"d.vec2u": () => vec2u,
+		"std.textureLoad": () => textureLoad,
+		"accumulateLayout": () => accumulateLayout,
+		"std.textureStore": () => textureStore,
+		"std.select": () => select
+	}
+}) && $.f)({})).$name("irradianceAccumulate");
+const copyLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
+	src: { texture: texture2d(f32) },
+	out: outEntry
+}), "copyLayout");
+const copyKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const at = vec2u(cx, cy);
+	textureStore(copyLayout.$.out, at, textureLoad(copyLayout.$.src, at, 0));
+}), {
+	v: 2,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [[
+			13,
+			"at",
+			[
+				6,
+				"d.vec2u",
+				["cx", "cy"]
+			]
+		], [
+			6,
+			"std.textureStore",
+			[
+				[
+					7,
+					[
+						7,
+						"copyLayout",
+						"$"
+					],
+					"out"
+				],
+				"at",
+				[
+					6,
+					"std.textureLoad",
+					[
+						[
+							7,
+							[
+								7,
+								"copyLayout",
+								"$"
+							],
+							"src"
+						],
+						"at",
+						[5, "0"]
+					]
+				]
+			]
+		]]]
+	},
+	externals: {
+		"d.vec2u": () => vec2u,
+		"std.textureStore": () => textureStore,
+		"copyLayout": () => copyLayout,
+		"std.textureLoad": () => textureLoad
+	}
+}) && $.f)({})).$name("irradianceCopy");
+var radianceCounter = 0;
+var raw$1 = (name) => new Expr(() => name);
+var num = (v, ctx) => typeof v === "number" ? formatFloat(v) : v._emit(ctx);
+function scopedInto(ctx, into) {
+	return {
+		external: (v, h) => ctx.external(v, h),
+		statement: (w) => into.push(w),
+		freshLocal: (h) => ctx.freshLocal(h),
+		memo: (k, f) => ctx.memo(k, f)
+	};
+}
+function shadowVisibility(spec) {
+	const id = radianceCounter++;
+	const hint = spec.hint ?? "visibility";
+	return new Expr((ctx) => ctx.memo(`shadow:${id}`, () => {
+		const vis = ctx.freshLocal(hint);
+		const from = ctx.freshLocal("shFrom");
+		const seg = ctx.freshLocal("shSeg");
+		const len = ctx.freshLocal("shLen");
+		const dir = ctx.freshLocal("shDir");
+		const eps = ctx.freshLocal("shEps");
+		const soft = ctx.freshLocal("shSoft");
+		const t = ctx.freshLocal("shT");
+		const pos = ctx.freshLocal("shPos");
+		const dd = ctx.freshLocal("shD");
+		const k = ctx.freshLocal("shStep");
+		ctx.statement(`let ${from} = ${spec.from._emit(ctx)};`);
+		ctx.statement(`let ${seg} = ${spec.toward._emit(ctx)} - ${from};`);
+		ctx.statement(`let ${len} = length(${seg});`);
+		ctx.statement(`let ${dir} = ${seg} / max(${len}, 0.0001);`);
+		ctx.statement(`let ${eps} = ${num(spec.surfaceEps, ctx)};`);
+		ctx.statement(`let ${soft} = ${num(spec.softness ?? 0, ctx)};`);
+		ctx.statement(`var ${vis} = 1.0;`);
+		const marchStmts = [];
+		const fieldAtPos = spec.field(raw$1(pos))._emit(scopedInto(ctx, marchStmts));
+		ctx.statement([
+			`{`,
+			`  var ${t} = ${eps} * 2.0;`,
+			`  for (var ${k} = 0u; ${k} < ${spec.steps}u; ${k}++) {`,
+			`    if (${t} >= ${len}) { break; }`,
+			`    let ${pos} = ${from} + ${dir} * ${t};`,
+			...marchStmts.map((w) => `    ${w}`),
+			`    let ${dd} = ${fieldAtPos};`,
+			`    ${vis} = min(${vis}, clamp(${dd} / max(${t} * ${soft}, ${eps}), 0.0, 1.0));`,
+			`    if (${vis} <= 0.0) { break; }`,
+			`    ${t} += max(${dd}, ${eps});`,
+			`  }`,
+			`}`
+		].join("\n"));
+		return vis;
+	}));
+}
+var DENOISE_RADIUS = 3;
+var DENOISE_HALF_KERNEL = 6;
+var WARMUP_FRAMES = 3;
+var { createSdfDataTexture, analyticSubPropValues, parseShapeConfigValue } = sdf_exports;
+var { createVolumetricFieldComputeNode } = sdf3d_exports;
+function toPlacement(center, scale, rotationDeg, aspect, stored) {
+	const dxAc = (stored.x - center.x) * aspect;
+	const dy = 1 - stored.y - (1 - center.y);
+	const r = rotationDeg * Math.PI / 180;
+	const c = Math.cos(r);
+	const s = Math.sin(r);
+	const sc = Math.max(scale, .001);
+	return {
+		x: (dxAc * c + dy * s) / sc + .5,
+		y: (dy * c - dxAc * s) / sc + .5
+	};
+}
+function lightLanes(items, fields, placement) {
+	const list = (Array.isArray(items) ? items : []).slice(0, 8);
+	const pos = [];
+	const color = [];
+	for (let i = 0; i < 8; i++) {
+		const item = list[i];
+		const stored = item?.[fields.position] ?? {
+			x: .5,
+			y: .5
+		};
+		const p = toPlacement(placement.center, placement.scale, placement.rotation, placement.aspect, stored);
+		const c = item?.[fields.color] ?? [
+			1,
+			1,
+			1,
+			1
+		];
+		const intensity = typeof item?.[fields.intensity] === "number" ? item[fields.intensity] : 0;
+		pos.push(item ? [
+			p.x,
+			p.y,
+			0,
+			0
+		] : [
+			0,
+			0,
+			0,
+			0
+		]);
+		color.push(item ? [
+			c[0],
+			c[1],
+			c[2],
+			intensity
+		] : [
+			0,
+			0,
+			0,
+			0
+		]);
+	}
+	return {
+		pos,
+		color,
+		count: list.length
+	};
+}
+function irradianceField(spec) {
+	const outputKey = spec.outputKey ?? "irradianceTexture";
+	const namePrefix = spec.namePrefix ?? "irradiance";
+	const kernelOpts = {
+		steps: spec.steps ?? 32,
+		shadowSteps: spec.shadowSteps ?? 12,
+		namePrefix
+	};
+	const res = spec.resolution;
+	const compute = (params) => {
+		const { gpu, getCpuValue, registerComputeTexture, onCleanup, onResize } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const shapeSdfUrl = getCpuValue("shapeSdfUrl") || "";
+		const shapeType = resolveShapeType(getCpuValue("shapeType") || "", getCpuValue("shape"));
+		const vf = createVolumetricFieldComputeNode(params, () => getCpuValue("shape"), "none", "span");
+		const mkTex = () => {
+			const t = root.createTexture({
+				size: [res, res],
+				format: IRRADIANCE_FORMAT
+			}).$usage("storage", "sampled");
+			onCleanup(() => t.destroy());
+			return t;
+		};
+		const outTex = mkTex();
+		const meanTex = mkTex();
+		const prevTex = mkTex();
+		const denoise = createGaussianBlurCompute(root, meanTex, res, res, onCleanup, DENOISE_HALF_KERNEL, res, res);
+		denoise.updateRadius(DENOISE_RADIUS);
+		const outputTexture = registerComputeTexture(denoise.outputTexture);
+		const paramsU = root.createUniform(IrradianceParams);
+		const accumU = root.createUniform(AccumulateParams);
+		const accumulate$1 = createIrradiancePass(root, accumulateKernel, {
+			res,
+			bindGroup: root.createBindGroup(accumulateLayout, {
+				sample: outTex,
+				prev: prevTex,
+				out: meanTex,
+				params: accumU.buffer
+			})
+		});
+		const keepMean = createIrradiancePass(root, copyKernel, {
+			res,
+			bindGroup: root.createBindGroup(copyLayout, {
+				src: meanTex,
+				out: prevTex
+			})
+		});
+		let pass;
+		let fieldVersion = () => 0;
+		let silhouette$1 = null;
+		if (vf) {
+			const jfaA = mkTex();
+			const jfaB = mkTex();
+			const silU = root.createUniform(SilhouetteParams);
+			const seedPass = createIrradiancePass(root, silhouetteSeedKernel, {
+				res,
+				bindGroup: root.createBindGroup(silhouetteSeedLayout, {
+					params: silU.buffer,
+					fieldTex: vf.fieldTexture,
+					out: jfaA
+				})
+			});
+			const stepAB = createIrradiancePass(root, silhouetteStepKernel, {
+				res,
+				bindGroup: root.createBindGroup(silhouetteStepLayout, {
+					params: silU.buffer,
+					src: jfaA,
+					out: jfaB
+				})
+			});
+			const stepBA = createIrradiancePass(root, silhouetteStepKernel, {
+				res,
+				bindGroup: root.createBindGroup(silhouetteStepLayout, {
+					params: silU.buffer,
+					src: jfaB,
+					out: jfaA
+				})
+			});
+			const jumps = [];
+			for (let step = Math.ceil(res / 2); step >= 1; step = Math.floor(step / 2)) {
+				jumps.push(step);
+				if (step === 1) break;
+			}
+			const finalTex = jumps.length % 2 === 1 ? jfaB : jfaA;
+			silhouette$1 = { steps: (domain) => {
+				const nodes = [];
+				const base = {
+					vfOriginX: domain.originX,
+					vfOriginY: domain.originY,
+					vfSpanX: domain.spanX,
+					vfSpanY: domain.spanY,
+					vfActiveRes: domain.activeRes,
+					vfRBound: domain.rBound,
+					res
+				};
+				nodes.push(() => silU.write({
+					...base,
+					step: 0
+				}), seedPass);
+				jumps.forEach((step, i) => {
+					nodes.push(() => silU.write({
+						...base,
+						step
+					}), i % 2 === 0 ? stepAB : stepBA);
+				});
+				return nodes;
+			} };
+			const samp = root.createSampler({
+				magFilter: "linear",
+				minFilter: "linear",
+				addressModeU: "clamp-to-edge",
+				addressModeV: "clamp-to-edge"
+			});
+			pass = createIrradiancePass(root, buildIrradianceKernel(irradianceFieldLayout, volumetricField, kernelOpts), {
+				res,
+				bindGroup: root.createBindGroup(irradianceFieldLayout, {
+					params: paramsU.buffer,
+					outTex,
+					silhouetteTex: finalTex,
+					samp
+				})
+			});
+		} else if (shapeSdfUrl) {
+			const sdfTex = createSdfDataTexture(params, shapeSdfUrl);
+			fieldVersion = () => sdfTex.getVersion();
+			const samp = root.createSampler({
+				magFilter: "linear",
+				minFilter: "linear",
+				addressModeU: "clamp-to-edge",
+				addressModeV: "clamp-to-edge"
+			});
+			pass = createIrradiancePass(root, buildIrradianceKernel(irradianceSvgLayout, svgField, kernelOpts), {
+				res,
+				bindGroup: root.createBindGroup(irradianceSvgLayout, {
+					params: paramsU.buffer,
+					outTex,
+					sdfSource: sdfTex.texture.texture,
+					samp
+				})
+			});
+		} else pass = createIrradiancePass(root, buildIrradianceKernel(irradianceAnalyticLayout, analyticField(shapeType), kernelOpts), {
+			res,
+			bindGroup: root.createBindGroup(irradianceAnalyticLayout, {
+				params: paramsU.buffer,
+				outTex
+			})
+		});
+		let width = Math.max(1, params.dimensions.width);
+		let height = Math.max(1, params.dimensions.height);
+		onResize(({ width: w, height: h }) => {
+			width = Math.max(1, w);
+			height = Math.max(1, h);
+		});
+		const num$1 = (key, fallback) => {
+			const v = getCpuValue(key);
+			return typeof v === "number" ? v : fallback;
+		};
+		const pos = (key) => {
+			const v = getCpuValue(key);
+			return {
+				x: typeof v?.x === "number" ? v.x : .5,
+				y: typeof v?.y === "number" ? v.y : .5
+			};
+		};
+		let lastKey = "";
+		let silhouetteReady = false;
+		let frame = 0;
+		let warmup = WARMUP_FRAMES;
+		let samples = 0;
+		let changedLastFrame = false;
+		return {
+			outputs: {
+				[outputKey]: outputTexture,
+				...vf?.outputs ?? {}
+			},
+			getComputeNodes: (frameParams) => {
+				const pre = vf?.getComputeNodes(frameParams) ?? null;
+				let silhouettePasses = [];
+				if (silhouette$1 && (pre || !silhouetteReady)) {
+					const dom$1 = vf.getFieldDomain();
+					silhouettePasses = silhouette$1.steps(dom$1);
+					silhouetteReady = true;
+				}
+				const center = pos("center");
+				const scale = num$1("scale", 1);
+				const rotation = num$1("rotation", 0);
+				const lights = lightLanes(getCpuValue(spec.lights.prop), spec.lights, {
+					center,
+					scale,
+					rotation,
+					aspect: width / height
+				});
+				const sub$1 = analyticSubPropValues(parseShapeConfigValue(getCpuValue("shape")));
+				const dom = vf?.getFieldDomain();
+				const values = {
+					center: [center.x, center.y],
+					lightPos: lights.pos,
+					lightColor: lights.color,
+					lightCount: lights.count,
+					scale,
+					rotation,
+					aspect: width / height,
+					reach: num$1(spec.reach, 3),
+					wrap: num$1(spec.wrap, 0),
+					lightRange: num$1(spec.lightRange, 1),
+					shadowSoftness: num$1(spec.shadowSoftness, 0),
+					eps: 1 / res / Math.max(scale, .001),
+					res,
+					saRadius: sub$1.radius,
+					saSides: sub$1.sides,
+					saRounding: sub$1.rounding,
+					saInnerRatio: sub$1.innerRatio,
+					saRotation: sub$1.rotation,
+					saHeight: sub$1.height,
+					saOffset: sub$1.offset,
+					saAperture: sub$1.aperture,
+					vfOriginX: dom?.originX ?? 0,
+					vfOriginY: dom?.originY ?? 0,
+					vfSpanX: dom?.spanX ?? 1,
+					vfSpanY: dom?.spanY ?? 1,
+					vfActiveRes: dom?.activeRes ?? 1,
+					vfRBound: dom?.rBound ?? .6,
+					fieldVersion: fieldVersion()
+				};
+				const key = JSON.stringify(values);
+				const warming = warmup > 0;
+				if (warming) warmup--;
+				const changed = key !== lastKey || Boolean(pre) || silhouettePasses.length > 0 || warming;
+				let rays;
+				if (changed) {
+					lastKey = key;
+					frame = 0;
+					samples = 0;
+					rays = changedLastFrame ? spec.rays.motion : spec.rays.burst;
+				} else if (frame > spec.rays.refineFrames) {
+					changedLastFrame = false;
+					return null;
+				} else rays = spec.rays.refine;
+				changedLastFrame = changed;
+				const sampleIndex = frame++;
+				const weight = rays / (samples + rays);
+				samples += rays;
+				const nodes = pre ? [...pre, ...silhouettePasses] : [...silhouettePasses];
+				nodes.push(() => {
+					const { fieldVersion: _version,...abi } = values;
+					paramsU.write({
+						...abi,
+						frame: sampleIndex,
+						rays,
+						center: vec2f(values.center[0], values.center[1]),
+						lightPos: values.lightPos.map((l) => vec4f(l[0], l[1], l[2], l[3])),
+						lightColor: values.lightColor.map((l) => vec4f(l[0], l[1], l[2], l[3]))
+					});
+					accumU.write({ weight });
+				});
+				nodes.push(pass, accumulate$1, keepMean, ...denoise.computeSteps);
+				return nodes;
+			}
+		};
+	};
+	const sample = (params) => {
+		const tex = params.computeOutputs?.[outputKey];
+		if (!tex) return void 0;
+		const s = local(tex.sampleLevel(params.ctx.uv), "irrTex");
+		return div(s.member("rgb"), max(s.member("a"), .001));
+	};
+	return {
+		compute,
+		sample
+	};
+}
+var listCounter = 0;
+var raw = (name) => new Expr(() => name);
+function listOf(params, prop) {
+	const lane = (field, i) => {
+		const arr = params.uniforms[listFieldName(prop, field)];
+		if (!arr) throw new Error(`std: list '${prop}' has no field '${field}'`);
+		return new Expr((ctx) => `${arr._emit(ctx)}[${i._emit(ctx)}]`);
+	};
+	const count = params.uniforms[listCountName(prop)];
+	if (!count) throw new Error(`std: '${prop}' is not a list prop`);
+	return {
+		count,
+		at: (i) => ({
+			position: (field) => lane(field, i).member("xy"),
+			color: (field) => lane(field, i),
+			number: (field) => lane(field, i).member("x")
+		})
+	};
+}
+function accumulate(list, body, opts = {}) {
+	const id = listCounter++;
+	const zero = opts.zero === "vec3f" ? "vec3f(0.0)" : "0.0";
+	const hint = opts.hint ?? "sum";
+	return new Expr((ctx) => ctx.memo(`accumulate:${id}`, () => {
+		for (const dep of opts.deps ?? []) dep._emit(ctx);
+		const acc = ctx.freshLocal(hint);
+		const i = ctx.freshLocal("item");
+		const countText = list.count._emit(ctx);
+		const stmts = [];
+		const term = body(raw(i))._emit({
+			external: (v, h) => ctx.external(v, h),
+			statement: (w) => stmts.push(w),
+			freshLocal: (h) => ctx.freshLocal(h),
+			memo: (k, f) => ctx.memo(k, f)
+		});
+		ctx.statement(`var ${acc} = ${zero};`);
+		ctx.statement([
+			`for (var ${i} = 0u; ${i} < u32(${countText}); ${i}++) {`,
+			...stmts.map((w) => `  ${w}`),
+			`  ${acc} += ${term};`,
+			`}`
+		].join("\n"));
+		return acc;
+	}));
+}
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+var DEFAULT_LIGHTS = [{
+	position: {
+		x: .3,
+		y: .3
+	},
+	color: "#ffb347",
+	intensity: 3
+}, {
+	position: {
+		x: .72,
+		y: .7
+	},
+	color: "#7a5cff",
+	intensity: 2
+}];
+var MAX_LIGHTS = 6;
+var RAYS = {
+	burst: 128,
+	motion: 64,
+	refine: 32,
+	refineFrames: 12
+};
+var MOBILE_RAY_DIVISOR = 2;
+var MARCH_STEPS = 32;
+var SHADOW_STEPS = 12;
+var FIELD_RES = 512;
+var FIELD_RES_MOBILE = 320;
+var CORE_WIDTH_PX = 2.5;
+var STENCIL_EPS = .01;
+var BODY_AMBIENT = .3;
+var GLINT_EXPONENT = 60;
+var GLINT_GAIN = .6;
+function gatherSettings(propValues) {
+	const shadowsRaw = propValues.shadows;
+	const shadows = typeof shadowsRaw === "number" ? shadowsRaw > 0 : shadowsRaw !== false;
+	const mobile = isMobileGpuViewport();
+	const div$1 = mobile ? MOBILE_RAY_DIVISOR : 1;
+	return {
+		rays: {
+			burst: RAYS.burst / div$1,
+			motion: RAYS.motion / div$1,
+			refine: RAYS.refine / div$1,
+			refineFrames: RAYS.refineFrames
+		},
+		shadowSteps: shadows ? SHADOW_STEPS : 0,
+		resolution: mobile ? FIELD_RES_MOBILE : FIELD_RES
+	};
+}
+var GATHER_PROPS = {
+	lights: {
+		prop: "lights",
+		position: "position",
+		color: "color",
+		intensity: "intensity"
+	},
+	reach: "reach",
+	wrap: "wrap",
+	lightRange: "lightRange",
+	shadowSoftness: "shadowSoftness",
+	steps: MARCH_STEPS
+};
+var spine = shapedSurface({
+	stencil: "centre",
+	centreTap: "fast",
+	surface: (frame, params) => {
+		const { uniforms: u, propValues } = params;
+		const { shadowSteps } = gatherSettings(propValues);
+		const shadows = shadowSteps > 0;
+		const field = surfaceField(frame, params);
+		const stencilled = (hint) => ({
+			...field,
+			s0: local(frame.sampler(frame.sdfUV), `${hint}S0`),
+			sX: local(frame.gradSampler(add(frame.sdfUV, vec2(STENCIL_EPS, 0))), `${hint}X`),
+			sY: local(frame.gradSampler(add(frame.sdfUV, vec2(0, STENCIL_EPS))), `${hint}Y`)
+		});
+		const px = local(div(field.pxH, max(u.scale, .001)), "pxUV");
+		const far = continuedField(frame, field, params);
+		const lights = listOf(params, "lights");
+		const lightAt = (i) => {
+			const item = lights.at(i);
+			return {
+				uv: placementPoint(params, item.position("position"), "lightUV"),
+				rgb: mul(item.color("color").member("rgb"), item.number("intensity"))
+			};
+		};
+		const irradiance = irradianceField({
+			...gatherSettings(propValues),
+			...GATHER_PROPS
+		}).sample(params) ?? splat3(0);
+		const rim = local(sub(1, smoothstep(0, mul(px, CORE_WIDTH_PX), far.sdf)), "rim");
+		const rimLight = () => {
+			const edge = nearestEdge(frame.sdfUV, far.sdf, add(fieldSlope(stencilled("rim"), STENCIL_EPS), far.outward));
+			return accumulate(lights, (i) => {
+				const light = lightAt(i);
+				const onEdge = pointLightFrom({
+					position: light.uv,
+					height: u.lightHeight
+				}, edge.point, "rimLight");
+				let struck = mul(lambert(edge.normal, onEdge.toLight, { wrap: u.wrap }), inverseSquare(onEdge.distance, u.lightRange));
+				if (shadows) struck = mul(struck, shadowVisibility({
+					from: add(edge.point, mul(edge.normal, mul(px, 2))),
+					toward: light.uv,
+					field: far.at,
+					steps: SHADOW_STEPS,
+					surfaceEps: px,
+					softness: u.shadowSoftness,
+					hint: "rimVisibility"
+				}));
+				return mul(light.rgb, struck);
+			}, {
+				zero: "vec3f",
+				hint: "rimSum",
+				deps: [edge.point, edge.normal]
+			});
+		};
+		const glow = emissiveAlpha(exposureTone(add(irradiance, guarded(gt(rim, 0), mul(rimLight(), mul(rim, u.core)), splat3(0), "emitter", [px]))), "glow");
+		const shadeBody = () => {
+			const n = geometricNormal(frame, stencilled("body"), {
+				bevelWidth: u.bevelWidth,
+				bevelShape: float(0),
+				eps: STENCIL_EPS
+			});
+			const lit = accumulate(lights, (i) => {
+				const light = lightAt(i);
+				const onBody = pointLightFrom({
+					position: light.uv,
+					height: u.lightHeight
+				}, frame.sdfUV, "bodyLight");
+				const bodyLit = local(mul(inverseSquare(onBody.distance, u.lightRange), u.bodyLight), "bodyLit");
+				const glint = mul(pow(max(dot(n, normalize(add(onBody.L, vec3(0, 0, -1)))), 0), GLINT_EXPONENT), GLINT_GAIN);
+				return add(mul(u.bodyColor.member("rgb"), mul(lambert(n, onBody.L), bodyLit)), mul(light.rgb, mul(glint, bodyLit)));
+			}, {
+				zero: "vec3f",
+				hint: "bodySum",
+				deps: [n]
+			});
+			return exposureTone(add(mul(u.bodyColor.member("rgb"), BODY_AMBIENT), lit));
+		};
+		const body = guarded(insideShape(field.sdf, px), shadeBody(), splat3(0), "body", []);
+		const cov = local(silhouette({
+			...field,
+			pxH: px
+		}, u.edgeSoftness), "cov");
+		return vec4(mix(glow.member("rgb"), body, cov), mix(glow.member("a"), 1, cov));
+	}
+});
+const componentDefinition = defineStd({
+	name: "Irradiance",
+	role: "shapeEffect",
+	species: "custom",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Photorealistic light spilling around the edge of any 2D, SVG, or 3D shape — any number of movable coloured point lights strike the silhouette and the lit edges irradiate their surroundings, gathered in a compute pass with real cast shadows, mixing where they meet and burning to white at the rim",
+	props: {
+		origin: {
+			default: "center",
+			description: "Reference edge the center position is measured from (center default). Lets you pin the shape relative to a corner or the canvas centre.",
+			ui: {
+				type: "origin",
+				label: "Origin",
+				group: "Position"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "Center position of the shape",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the shape (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		rotation: {
+			default: 0,
+			description: "Rotation of the shape in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Rotation",
+				group: "Position"
+			}
+		},
+		lights: listPropConfig({
+			maxItems: MAX_LIGHTS,
+			minItems: 1,
+			itemLabel: "Light",
+			item: {
+				position: {
+					kind: "position",
+					default: {
+						x: .3,
+						y: .3
+					},
+					label: "Position",
+					description: "Where this light sits — the edges facing it are struck and spill light outward. Map it to the mouse to carry the light around the shape."
+				},
+				color: {
+					kind: "color",
+					default: "#ffb347",
+					label: "Color",
+					description: "The colour this light casts"
+				},
+				intensity: {
+					kind: "number",
+					default: 3,
+					label: "Intensity",
+					min: 0,
+					max: 8,
+					step: .01,
+					description: "Brightness of this light — past ~2 the rim it strikes overexposes to white"
+				}
+			}
+		}, {
+			default: DEFAULT_LIGHTS,
+			description: "The point lights striking the shape — each with its own position, colour and brightness",
+			label: "Lights",
+			group: "Lights"
+		}),
+		lightHeight: {
+			default: .5,
+			description: "Height of the lights above the shape plane, relative to the shape — low lights graze the body, high lights flood it evenly",
+			ui: {
+				type: ["range", "map"],
+				min: .05,
+				max: 3,
+				step: .01,
+				label: "Light Height",
+				group: "Light"
+			}
+		},
+		lightRange: {
+			default: 1.2,
+			description: "Reach of each light — the distance at which it has fallen to half strength, relative to the shape",
+			ui: {
+				type: ["range", "map"],
+				min: .1,
+				max: 4,
+				step: .01,
+				label: "Range",
+				group: "Light"
+			}
+		},
+		reach: {
+			default: 3,
+			description: "How far from the shape the spilled light is gathered, relative to the shape — the glow fades out toward this distance",
+			ui: {
+				type: ["range", "map"],
+				min: .5,
+				max: 8,
+				step: .01,
+				label: "Reach",
+				group: "Glow"
+			}
+		},
+		core: {
+			default: 1,
+			description: "The lit edge seen directly — the white-hot line along the rim where the lights strike",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Core",
+				group: "Glow"
+			}
+		},
+		wrap: {
+			default: .1,
+			description: "How far light wraps around edges that face away from it — 0 leaves the far side dark",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Wrap",
+				group: "Glow"
+			}
+		},
+		shadows: {
+			default: true,
+			compileTime: true,
+			transform: transformBoolean,
+			description: "Cast shadows — the body blocks each light from edges it stands in front of (keeps holes and concave pockets dark)",
+			ui: {
+				type: "checkbox",
+				label: "Shadows",
+				group: "Glow"
+			}
+		},
+		shadowSoftness: {
+			default: .15,
+			description: "Penumbra width of the cast shadows — 0 is razor sharp",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Shadow Softness",
+				group: "Glow"
+			}
+		},
+		bodyColor: {
+			default: "#000000",
+			transform: transformColor,
+			description: "Color of the shape itself — black for a pure occluder, lighter to see the lights land on its form",
+			ui: {
+				type: "color",
+				label: "Body Color",
+				group: "Body"
+			}
+		},
+		bodyLight: {
+			default: .6,
+			description: "How much the lights illuminate the body — the bevel of a flat shape or the form of a 3D one",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Body Light",
+				group: "Body"
+			}
+		},
+		bevelWidth: {
+			default: .01,
+			description: "Width of the rounded edge a flat shape catches the light on, relative to the shape",
+			ui: {
+				type: ["range", "map"],
+				min: .005,
+				max: .2,
+				step: .001,
+				label: "Bevel Width",
+				group: "Body"
+			}
+		},
+		...glassShellProps({ edgeSoftness: { ui: { group: "Body" } } }),
+		shape: {
+			default: DEFAULT_SHAPE_CONFIG,
+			description: "Serialized shape configuration (JSON)",
+			ui: {
+				type: "shape",
+				label: "Shape",
+				group: "Shape"
+			}
+		},
+		shapeSdfUrl: {
+			default: "",
+			compileTime: true,
+			description: "URL to a pre-generated SDF .bin file"
+		},
+		shapeType: {
+			default: "",
+			compileTime: true,
+			description: "Active SDF shape type"
+		}
+	},
+	...spine,
+	compute: (params) => irradianceField({
+		...gatherSettings(params.propValues),
+		...GATHER_PROPS
+	}).compute(params)
+});
+var Irradiance_default = componentDefinition;
+export { componentDefinition as n, Irradiance_default as t };