shaders 3.2.475 → 4.0.0

package/dist/core/Irradiance-DtC4tqNu.js

@@ -1,4191 +0,0 @@
-import { Ar as vec2u, Br as struct, Cr as sin, Gn as typegpu_default, I as sdf_exports, Jn as textureSampleLevel, Jr as i32, Lr as texture2d, Mr as vec4f, Or as vec2f, Rr as textureStorage2d, Yn as textureStore, Yr as u32, ar as clamp, cr as dot$1, d as glassShellProps, er as select, gr as min, gt as formatFloat, hr as max$1, ht as Expr, jr as vec3f, mr as length, or as cos, pr as fract, q as createGuardedCompute, qn as textureLoad, qr as f32, t as defineStd, vr as normalize$1, wr as smoothstep$1, y as buildAnalyticSdfFn, zn as TAU, zr as arrayOf } from "./lower-DtoDQ7hV.js";
-import { ct as listCountName, ft as listPropConfig, ut as listFieldName } from "./porters-CQwDd2t4.js";
-import { y as createGaussianBlurCompute } from "./blur-CrEChFnm.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-BjsiWqS0.js";
-import { t as isMobileGpuViewport } from "./device-m0ud8-Fn.js";
-import { O as resolveShapeType, k as shapeEffectBoundingBoxDeclaration, r as buildFieldSampleGraphArgs, w as sdf3d_exports } from "./sdf3d-BMqCSSPB.js";
-import { n as glass_exports } from "./glass-DIEus1UY.js";
-import { a as transformColor, c as transformPosition, i as transformBoolean } from "./transformations-CzFmhZww.js";
-import { B as vec2, C as mix, D as pow, E as normalize, H as vec4, I as splat3, P as smoothstep, V as vec3, h as gt, n as add, o as div, s as dot, u as float, w as mul, x as max, y as local, z as sub } from "./math-7PlusTFx.js";
-import { n as emissiveAlpha } from "./compose-DNU_Ut36.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 colored 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 color 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, color 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 };