shaders 2.5.135 → 3.0.437

package/dist/core/LightEdge-CvV9PYbe.js

@@ -0,0 +1,2700 @@
+import { At as call, Pt as floatE, Q as hash22, Qt as mixColorsVariants, R as std, T as sdf_exports, Zt as mixColorsLinear, d as sdf3d_exports, lt as value12, n as tgpu, on as d, rt as noise_exports, u as VOLUMETRIC_FIELD_EXTRA_FIELDS$1 } from "./coords-BlwgBpJf.js";
+import { n as glass_exports } from "./glass-DdgMBWkF.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-fqzznt4g.js";
+import { m as colorStopsPropConfig, p as MAX_COLOR_STOPS, t as animatedTime } from "./porters-CoaznI7i.js";
+import { t as shapeEffectBoundingBoxDeclaration } from "./shapeEffectBounds-BlxxsYMN.js";
+var { sdfSpaceUV } = glass_exports;
+var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
+var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler } = sdf3d_exports;
+var VOLUMETRIC_FIELD_EXTRA_FIELDS = VOLUMETRIC_FIELD_EXTRA_FIELDS$1;
+var TWO_PI = 6.283185307179586;
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+var THICKNESS_REF = .35;
+function resolveShapeType(shapeType, shape) {
+	if (shapeType) return shapeType;
+	if (shape && typeof shape === "object") return shape.type || "circleSDF";
+	if (typeof shape === "string") try {
+		return JSON.parse(shape).type || "circleSDF";
+	} catch {
+		return "circleSDF";
+	}
+	return "circleSDF";
+}
+var DEFAULT_STOPS = [
+	{
+		color: "#7b2ff7",
+		position: 0
+	},
+	{
+		color: "#00e0ff",
+		position: .5
+	},
+	{
+		color: "#ff3d81",
+		position: 1
+	}
+];
+const lightEdgeBeat = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((animTime) => {
+	"use gpu";
+	const time = __tsover_mul(.18, animTime);
+	const first = std.pow(std.abs(std.sin(__tsover_mul(time, TWO_PI))), 10);
+	const second = std.pow(std.abs(std.sin(__tsover_mul(__tsover_sub(time, .15), TWO_PI))), 10);
+	return std.clamp(__tsover_add(first, __tsover_mul(.6, second)), 0, 1);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "animTime"
+		}],
+		"body": [0, [
+			[
+				13,
+				"time",
+				[
+					1,
+					[5, "0.18"],
+					"*",
+					"animTime"
+				]
+			],
+			[
+				13,
+				"first",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"abs"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							[[
+								1,
+								"time",
+								"*",
+								"TWO_PI"
+							]]
+						]]
+					], [5, "10"]]
+				]
+			],
+			[
+				13,
+				"second",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"abs"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							[[
+								1,
+								[
+									1,
+									"time",
+									"-",
+									[5, "0.15"]
+								],
+								"*",
+								"TWO_PI"
+							]]
+						]]
+					], [5, "10"]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"clamp"
+				],
+				[
+					[
+						1,
+						"first",
+						"+",
+						[
+							1,
+							[5, "0.6"],
+							"*",
+							"second"
+						]
+					],
+					[5, "0"],
+					[5, "1"]
+				]
+			]]
+		]],
+		"externalNames": ["std", "TWO_PI"]
+	},
+	externals: () => ({
+		std,
+		TWO_PI
+	})
+}) && $.f)({}));
+const lightEdgeBorder = tgpu.fn([
+	d.f32,
+	d.vec2f,
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fieldRaw, sdfUV, viewport, scale, thickness, softness, smokeSize, smokeAmt, animTime, pulse) => {
+	"use gpu";
+	const t = __tsover_add(__tsover_mul(animTime, 1.2), 131);
+	const th = std.max(__tsover_mul(__tsover_mul(.5, thickness), THICKNESS_REF), .002);
+	const f = __tsover_add(__tsover_div(fieldRaw, std.max(scale, .001)), std.mix(th, 0, softness));
+	const bd = std.abs(f);
+	const borderTh = std.mix(th, __tsover_mul(3, th), softness);
+	const aa = __tsover_div(2, __tsover_mul(viewport.y, std.max(scale, .001)));
+	const e0 = std.min(std.mix(borderTh, __tsover_mul(borderTh, -1), softness), __tsover_add(borderTh, aa));
+	const e1 = std.max(std.mix(borderTh, __tsover_mul(borderTh, -1), softness), __tsover_add(borderTh, aa));
+	let border = __tsover_sub(1, std.smoothstep(e0, e1, bd));
+	border = std.pow(std.clamp(border, 0, 1), __tsover_add(1, softness));
+	const suv = d.vec2f(__tsover_sub(sdfUV.x, .5), __tsover_sub(sdfUV.y, .5)).mul(__tsover_add(.5, __tsover_mul(2.5, smokeSize)));
+	const drift = __tsover_mul(.5, t);
+	const n1 = value12(d.vec2f(__tsover_add(__tsover_mul(suv.x, 2.7), drift), __tsover_add(__tsover_mul(suv.y, 2.7), drift)));
+	const n2 = value12(d.vec2f(__tsover_sub(__tsover_mul(suv.x, 3.4), drift), __tsover_sub(__tsover_mul(suv.y, 3.4), drift)));
+	let smoke = __tsover_sub(std.clamp(__tsover_mul(3, n1), 0, 1), n2);
+	const smokeTh = std.clamp(__tsover_add(th, .2), .1, .4);
+	const smokeBand = std.pow(std.clamp(__tsover_sub(1, std.smoothstep(__tsover_mul(smokeTh, -1), __tsover_add(smokeTh, aa), bd)), 0, 1), 2);
+	smoke = __tsover_mul(smoke, smokeBand);
+	smoke = __tsover_mul(__tsover_mul(__tsover_mul(30, smoke), smoke), __tsover_mul(__tsover_mul(.5, smokeAmt), smokeAmt));
+	smoke = __tsover_mul(smoke, std.mix(1, lightEdgeBeat(animTime), pulse));
+	border = std.clamp(__tsover_add(border, std.clamp(smoke, 0, 1)), 0, 1);
+	const angle01 = __tsover_div(std.atan2(__tsover_sub(sdfUV.y, .5), __tsover_sub(sdfUV.x, .5)), TWO_PI);
+	return d.vec2f(border, angle01);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "fieldRaw"
+			},
+			{
+				"type": "i",
+				"name": "sdfUV"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "scale"
+			},
+			{
+				"type": "i",
+				"name": "thickness"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "smokeSize"
+			},
+			{
+				"type": "i",
+				"name": "smokeAmt"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			},
+			{
+				"type": "i",
+				"name": "pulse"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"t",
+				[
+					1,
+					[
+						1,
+						"animTime",
+						"*",
+						[5, "1.2"]
+					],
+					"+",
+					[5, "131"]
+				]
+			],
+			[
+				13,
+				"th",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						[
+							1,
+							[5, "0.5"],
+							"*",
+							"thickness"
+						],
+						"*",
+						"THICKNESS_REF"
+					], [5, "0.002"]]
+				]
+			],
+			[
+				13,
+				"f",
+				[
+					1,
+					[
+						1,
+						"fieldRaw",
+						"/",
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							["scale", [5, "0.001"]]
+						]
+					],
+					"+",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							"th",
+							[5, "0"],
+							"softness"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"bd",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					["f"]
+				]
+			],
+			[
+				13,
+				"borderTh",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"th",
+						[
+							1,
+							[5, "3"],
+							"*",
+							"th"
+						],
+						"softness"
+					]
+				]
+			],
+			[
+				13,
+				"aa",
+				[
+					1,
+					[5, "2"],
+					"/",
+					[
+						1,
+						[
+							7,
+							"viewport",
+							"y"
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							["scale", [5, "0.001"]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"e0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"min"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							"borderTh",
+							[
+								1,
+								"borderTh",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"softness"
+						]
+					], [
+						1,
+						"borderTh",
+						"+",
+						"aa"
+					]]
+				]
+			],
+			[
+				13,
+				"e1",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							"borderTh",
+							[
+								1,
+								"borderTh",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"softness"
+						]
+					], [
+						1,
+						"borderTh",
+						"+",
+						"aa"
+					]]
+				]
+			],
+			[
+				12,
+				"border",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						6,
+						[
+							7,
+							"std",
+							"smoothstep"
+						],
+						[
+							"e0",
+							"e1",
+							"bd"
+						]
+					]
+				]
+			],
+			[
+				2,
+				"border",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							"border",
+							[5, "0"],
+							[5, "1"]
+						]
+					], [
+						1,
+						[5, "1"],
+						"+",
+						"softness"
+					]]
+				]
+			],
+			[
+				13,
+				"suv",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								1,
+								[
+									7,
+									"sdfUV",
+									"x"
+								],
+								"-",
+								[5, "0.5"]
+							], [
+								1,
+								[
+									7,
+									"sdfUV",
+									"y"
+								],
+								"-",
+								[5, "0.5"]
+							]]
+						],
+						"mul"
+					],
+					[[
+						1,
+						[5, "0.5"],
+						"+",
+						[
+							1,
+							[5, "2.5"],
+							"*",
+							"smokeSize"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"drift",
+				[
+					1,
+					[5, "0.5"],
+					"*",
+					"t"
+				]
+			],
+			[
+				13,
+				"n1",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"value12"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									7,
+									"suv",
+									"x"
+								],
+								"*",
+								[5, "2.7"]
+							],
+							"+",
+							"drift"
+						], [
+							1,
+							[
+								1,
+								[
+									7,
+									"suv",
+									"y"
+								],
+								"*",
+								[5, "2.7"]
+							],
+							"+",
+							"drift"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"n2",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"value12"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									7,
+									"suv",
+									"x"
+								],
+								"*",
+								[5, "3.4"]
+							],
+							"-",
+							"drift"
+						], [
+							1,
+							[
+								1,
+								[
+									7,
+									"suv",
+									"y"
+								],
+								"*",
+								[5, "3.4"]
+							],
+							"-",
+							"drift"
+						]]
+					]]
+				]
+			],
+			[
+				12,
+				"smoke",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								[5, "3"],
+								"*",
+								"n1"
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					],
+					"-",
+					"n2"
+				]
+			],
+			[
+				13,
+				"smokeTh",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"th",
+							"+",
+							[5, "0.2"]
+						],
+						[5, "0.1"],
+						[5, "0.4"]
+					]
+				]
+			],
+			[
+				13,
+				"smokeBand",
+				[
+					6,
+					[
+						7,
+						"std",
+						"pow"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								[5, "1"],
+								"-",
+								[
+									6,
+									[
+										7,
+										"std",
+										"smoothstep"
+									],
+									[
+										[
+											1,
+											"smokeTh",
+											"*",
+											[
+												4,
+												"-",
+												[5, "1"]
+											]
+										],
+										[
+											1,
+											"smokeTh",
+											"+",
+											"aa"
+										],
+										"bd"
+									]
+								]
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					], [5, "2"]]
+				]
+			],
+			[
+				2,
+				"smoke",
+				"=",
+				[
+					1,
+					"smoke",
+					"*",
+					"smokeBand"
+				]
+			],
+			[
+				2,
+				"smoke",
+				"=",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[5, "30"],
+							"*",
+							"smoke"
+						],
+						"*",
+						"smoke"
+					],
+					"*",
+					[
+						1,
+						[
+							1,
+							[5, "0.5"],
+							"*",
+							"smokeAmt"
+						],
+						"*",
+						"smokeAmt"
+					]
+				]
+			],
+			[
+				2,
+				"smoke",
+				"=",
+				[
+					1,
+					"smoke",
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[5, "1"],
+							[
+								6,
+								"lightEdgeBeat",
+								["animTime"]
+							],
+							"pulse"
+						]
+					]
+				]
+			],
+			[
+				2,
+				"border",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"border",
+							"+",
+							[
+								6,
+								[
+									7,
+									"std",
+									"clamp"
+								],
+								[
+									"smoke",
+									[5, "0"],
+									[5, "1"]
+								]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"angle01",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"atan2"
+						],
+						[[
+							1,
+							[
+								7,
+								"sdfUV",
+								"y"
+							],
+							"-",
+							[5, "0.5"]
+						], [
+							1,
+							[
+								7,
+								"sdfUV",
+								"x"
+							],
+							"-",
+							[5, "0.5"]
+						]]
+					],
+					"/",
+					"TWO_PI"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				["border", "angle01"]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"THICKNESS_REF",
+			"d",
+			"noise",
+			"lightEdgeBeat",
+			"TWO_PI"
+		]
+	},
+	externals: () => ({
+		std,
+		THICKNESS_REF,
+		d,
+		noise: noise_exports,
+		lightEdgeBeat,
+		TWO_PI
+	})
+}) && $.f)({}));
+const lightEdgeColorAccum = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angle01, border, animTime, spotsF, spotSize, pulse, intensity, softness, seed, colorIdxF) => {
+	"use gpu";
+	const t = __tsover_add(__tsover_mul(animTime, 1.2), 131);
+	const beat = lightEdgeBeat(animTime);
+	const intensityEff = __tsover_add(1, __tsover_mul(__tsover_add(1, __tsover_mul(4, softness)), intensity));
+	let overAcc = d.f32(0);
+	let addAcc = d.f32(0);
+	for (let s = 0; s < 5; s++) {
+		const sF = d.f32(s);
+		const gate = std.select(d.f32(0), d.f32(1), sF < spotsF);
+		const randVal = hash22(d.vec2f(__tsover_add(__tsover_add(__tsover_mul(sF, 10), 2), __tsover_mul(seed, 7.31)), __tsover_add(__tsover_add(40, colorIdxF), __tsover_mul(seed, 3.17))));
+		const speedFactor = __tsover_add(.1, __tsover_mul(.15, std.abs(__tsover_mul(std.sin(__tsover_mul(sF, __tsover_add(2, colorIdxF))), std.cos(__tsover_mul(sF, __tsover_add(2, __tsover_mul(2.5, colorIdxF))))))));
+		const dir = std.select(d.f32(1), d.f32(-1), randVal.y < .5);
+		const sTime = __tsover_mul(__tsover_add(__tsover_mul(speedFactor, t), __tsover_mul(randVal.x, 3)), dir);
+		const evenCond = std.abs(__tsover_sub(colorIdxF, __tsover_mul(2, std.floor(__tsover_mul(colorIdxF, .5))))) < .5;
+		const sinVal = std.sin(__tsover_add(t, __tsover_mul(sF, __tsover_sub(5, __tsover_mul(1.5, colorIdxF)))));
+		const cosVal = std.cos(__tsover_add(t, __tsover_mul(sF, __tsover_add(3, __tsover_mul(1.3, colorIdxF)))));
+		let mask = __tsover_add(.5, __tsover_mul(.5, std.select(cosVal, sinVal, evenCond)));
+		const pWeight = std.clamp(__tsover_sub(__tsover_mul(2, pulse), randVal.x), 0, 1);
+		mask = std.mix(mask, beat, pWeight);
+		const atg = std.fract(__tsover_add(angle01, sTime));
+		let ss = __tsover_add(__tsover_add(.05, __tsover_mul(__tsover_mul(.6, spotSize), spotSize)), __tsover_mul(.05, randVal.x));
+		ss = std.mix(ss, .1, pWeight);
+		let sector = __tsover_mul(std.smoothstep(__tsover_sub(.5, ss), .5, atg), __tsover_sub(1, std.smoothstep(.5, __tsover_add(.5, ss), atg)));
+		sector = __tsover_mul(std.clamp(__tsover_mul(__tsover_mul(__tsover_mul(sector, mask), border), intensityEff), 0, 1), gate);
+		overAcc = __tsover_add(overAcc, __tsover_mul(__tsover_sub(1, overAcc), sector));
+		addAcc = __tsover_add(addAcc, sector);
+	}
+	return d.vec2f(overAcc, addAcc);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "angle01"
+			},
+			{
+				"type": "i",
+				"name": "border"
+			},
+			{
+				"type": "i",
+				"name": "animTime"
+			},
+			{
+				"type": "i",
+				"name": "spotsF"
+			},
+			{
+				"type": "i",
+				"name": "spotSize"
+			},
+			{
+				"type": "i",
+				"name": "pulse"
+			},
+			{
+				"type": "i",
+				"name": "intensity"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "seed"
+			},
+			{
+				"type": "i",
+				"name": "colorIdxF"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"t",
+				[
+					1,
+					[
+						1,
+						"animTime",
+						"*",
+						[5, "1.2"]
+					],
+					"+",
+					[5, "131"]
+				]
+			],
+			[
+				13,
+				"beat",
+				[
+					6,
+					"lightEdgeBeat",
+					["animTime"]
+				]
+			],
+			[
+				13,
+				"intensityEff",
+				[
+					1,
+					[5, "1"],
+					"+",
+					[
+						1,
+						[
+							1,
+							[5, "1"],
+							"+",
+							[
+								1,
+								[5, "4"],
+								"*",
+								"softness"
+							]
+						],
+						"*",
+						"intensity"
+					]
+				]
+			],
+			[
+				12,
+				"overAcc",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				12,
+				"addAcc",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"s",
+					[5, "0"]
+				],
+				[
+					1,
+					"s",
+					"<",
+					[5, "5"]
+				],
+				[
+					102,
+					"++",
+					"s"
+				],
+				[0, [
+					[
+						13,
+						"sF",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["s"]
+						]
+					],
+					[
+						13,
+						"gate",
+						[
+							6,
+							[
+								7,
+								"std",
+								"select"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "1"]]
+								],
+								[
+									1,
+									"sF",
+									"<",
+									"spotsF"
+								]
+							]
+						]
+					],
+					[
+						13,
+						"randVal",
+						[
+							6,
+							[
+								7,
+								"noise",
+								"hash22"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											1,
+											"sF",
+											"*",
+											[5, "10"]
+										],
+										"+",
+										[5, "2"]
+									],
+									"+",
+									[
+										1,
+										"seed",
+										"*",
+										[5, "7.31"]
+									]
+								], [
+									1,
+									[
+										1,
+										[5, "40"],
+										"+",
+										"colorIdxF"
+									],
+									"+",
+									[
+										1,
+										"seed",
+										"*",
+										[5, "3.17"]
+									]
+								]]
+							]]
+						]
+					],
+					[
+						13,
+						"speedFactor",
+						[
+							1,
+							[5, "0.1"],
+							"+",
+							[
+								1,
+								[5, "0.15"],
+								"*",
+								[
+									6,
+									[
+										7,
+										"std",
+										"abs"
+									],
+									[[
+										1,
+										[
+											6,
+											[
+												7,
+												"std",
+												"sin"
+											],
+											[[
+												1,
+												"sF",
+												"*",
+												[
+													1,
+													[5, "2"],
+													"+",
+													"colorIdxF"
+												]
+											]]
+										],
+										"*",
+										[
+											6,
+											[
+												7,
+												"std",
+												"cos"
+											],
+											[[
+												1,
+												"sF",
+												"*",
+												[
+													1,
+													[5, "2"],
+													"+",
+													[
+														1,
+														[5, "2.5"],
+														"*",
+														"colorIdxF"
+													]
+												]
+											]]
+										]
+									]]
+								]
+							]
+						]
+					],
+					[
+						13,
+						"dir",
+						[
+							6,
+							[
+								7,
+								"std",
+								"select"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "1"]]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[
+										4,
+										"-",
+										[5, "1"]
+									]]
+								],
+								[
+									1,
+									[
+										7,
+										"randVal",
+										"y"
+									],
+									"<",
+									[5, "0.5"]
+								]
+							]
+						]
+					],
+					[
+						13,
+						"sTime",
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"speedFactor",
+									"*",
+									"t"
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"randVal",
+										"x"
+									],
+									"*",
+									[5, "3"]
+								]
+							],
+							"*",
+							"dir"
+						]
+					],
+					[
+						13,
+						"evenCond",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"abs"
+								],
+								[[
+									1,
+									"colorIdxF",
+									"-",
+									[
+										1,
+										[5, "2"],
+										"*",
+										[
+											6,
+											[
+												7,
+												"std",
+												"floor"
+											],
+											[[
+												1,
+												"colorIdxF",
+												"*",
+												[5, "0.5"]
+											]]
+										]
+									]
+								]]
+							],
+							"<",
+							[5, "0.5"]
+						]
+					],
+					[
+						13,
+						"sinVal",
+						[
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							[[
+								1,
+								"t",
+								"+",
+								[
+									1,
+									"sF",
+									"*",
+									[
+										1,
+										[5, "5"],
+										"-",
+										[
+											1,
+											[5, "1.5"],
+											"*",
+											"colorIdxF"
+										]
+									]
+								]
+							]]
+						]
+					],
+					[
+						13,
+						"cosVal",
+						[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							[[
+								1,
+								"t",
+								"+",
+								[
+									1,
+									"sF",
+									"*",
+									[
+										1,
+										[5, "3"],
+										"+",
+										[
+											1,
+											[5, "1.3"],
+											"*",
+											"colorIdxF"
+										]
+									]
+								]
+							]]
+						]
+					],
+					[
+						12,
+						"mask",
+						[
+							1,
+							[5, "0.5"],
+							"+",
+							[
+								1,
+								[5, "0.5"],
+								"*",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										"cosVal",
+										"sinVal",
+										"evenCond"
+									]
+								]
+							]
+						]
+					],
+					[
+						13,
+						"pWeight",
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								[
+									1,
+									[
+										1,
+										[5, "2"],
+										"*",
+										"pulse"
+									],
+									"-",
+									[
+										7,
+										"randVal",
+										"x"
+									]
+								],
+								[5, "0"],
+								[5, "1"]
+							]
+						]
+					],
+					[
+						2,
+						"mask",
+						"=",
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								"mask",
+								"beat",
+								"pWeight"
+							]
+						]
+					],
+					[
+						13,
+						"atg",
+						[
+							6,
+							[
+								7,
+								"std",
+								"fract"
+							],
+							[[
+								1,
+								"angle01",
+								"+",
+								"sTime"
+							]]
+						]
+					],
+					[
+						12,
+						"ss",
+						[
+							1,
+							[
+								1,
+								[5, "0.05"],
+								"+",
+								[
+									1,
+									[
+										1,
+										[5, "0.6"],
+										"*",
+										"spotSize"
+									],
+									"*",
+									"spotSize"
+								]
+							],
+							"+",
+							[
+								1,
+								[5, "0.05"],
+								"*",
+								[
+									7,
+									"randVal",
+									"x"
+								]
+							]
+						]
+					],
+					[
+						2,
+						"ss",
+						"=",
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								"ss",
+								[5, "0.1"],
+								"pWeight"
+							]
+						]
+					],
+					[
+						12,
+						"sector",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"smoothstep"
+								],
+								[
+									[
+										1,
+										[5, "0.5"],
+										"-",
+										"ss"
+									],
+									[5, "0.5"],
+									"atg"
+								]
+							],
+							"*",
+							[
+								1,
+								[5, "1"],
+								"-",
+								[
+									6,
+									[
+										7,
+										"std",
+										"smoothstep"
+									],
+									[
+										[5, "0.5"],
+										[
+											1,
+											[5, "0.5"],
+											"+",
+											"ss"
+										],
+										"atg"
+									]
+								]
+							]
+						]
+					],
+					[
+						2,
+						"sector",
+						"=",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"clamp"
+								],
+								[
+									[
+										1,
+										[
+											1,
+											[
+												1,
+												"sector",
+												"*",
+												"mask"
+											],
+											"*",
+											"border"
+										],
+										"*",
+										"intensityEff"
+									],
+									[5, "0"],
+									[5, "1"]
+								]
+							],
+							"*",
+							"gate"
+						]
+					],
+					[
+						2,
+						"overAcc",
+						"=",
+						[
+							1,
+							"overAcc",
+							"+",
+							[
+								1,
+								[
+									1,
+									[5, "1"],
+									"-",
+									"overAcc"
+								],
+								"*",
+								"sector"
+							]
+						]
+					],
+					[
+						2,
+						"addAcc",
+						"=",
+						[
+							1,
+							"addAcc",
+							"+",
+							"sector"
+						]
+					]
+				]]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				["overAcc", "addAcc"]
+			]]
+		]],
+		"externalNames": [
+			"lightEdgeBeat",
+			"d",
+			"std",
+			"noise"
+		]
+	},
+	externals: () => ({
+		lightEdgeBeat,
+		d,
+		std,
+		noise: noise_exports
+	})
+}) && $.f)({}));
+const LightEdgeAccum = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	rgb: d.vec3f,
+	w: d.f32,
+	ba: d.f32,
+	ac: d.vec3f,
+	aa: d.f32
+}), "LightEdgeAccum");
+const lightEdgeAccumZero = tgpu.fn([], LightEdgeAccum)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = (() => {
+	"use gpu";
+	return LightEdgeAccum({
+		rgb: d.vec3f(0, 0, 0),
+		w: d.f32(0),
+		ba: d.f32(0),
+		ac: d.vec3f(0, 0, 0),
+		aa: d.f32(0)
+	});
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [],
+		"body": [0, [[10, [
+			6,
+			"LightEdgeAccum",
+			[[104, {
+				"rgb": [
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "0"]
+					]
+				],
+				"w": [
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				],
+				"ba": [
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				],
+				"ac": [
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[5, "0"],
+						[5, "0"],
+						[5, "0"]
+					]
+				],
+				"aa": [
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			}]]
+		]]]],
+		"externalNames": ["LightEdgeAccum", "d"]
+	},
+	externals: () => ({
+		LightEdgeAccum,
+		d
+	})
+}) && $.f)({}));
+var accumFnByMode = /* @__PURE__ */ new Map();
+function makeAccumFn(mode) {
+	const variant = mixColorsVariants[mode] ?? mixColorsLinear;
+	return tgpu.fn([
+		LightEdgeAccum,
+		d.vec4f,
+		d.vec2f
+	], LightEdgeAccum)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st, color, sectors) => {
+		"use gpu";
+		const wNew = __tsover_mul(color.w, sectors.x);
+		const t = __tsover_div(wNew, std.max(__tsover_add(st.w, wNew), 1e-5));
+		const mixed = variant(d.vec4f(st.rgb, 1), d.vec4f(color.xyz, 1), t);
+		const ba = __tsover_add(st.ba, __tsover_mul(__tsover_sub(1, st.ba), wNew));
+		const ac = st.ac.add(color.xyz.mul(__tsover_mul(color.w, sectors.y)));
+		const aa = __tsover_add(st.aa, __tsover_mul(color.w, sectors.y));
+		return LightEdgeAccum({
+			rgb: mixed.xyz,
+			w: __tsover_add(st.w, wNew),
+			ba,
+			ac,
+			aa
+		});
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "st"
+				},
+				{
+					"type": "i",
+					"name": "color"
+				},
+				{
+					"type": "i",
+					"name": "sectors"
+				}
+			],
+			"body": [0, [
+				[
+					13,
+					"wNew",
+					[
+						1,
+						[
+							7,
+							"color",
+							"w"
+						],
+						"*",
+						[
+							7,
+							"sectors",
+							"x"
+						]
+					]
+				],
+				[
+					13,
+					"t",
+					[
+						1,
+						"wNew",
+						"/",
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							[[
+								1,
+								[
+									7,
+									"st",
+									"w"
+								],
+								"+",
+								"wNew"
+							], [5, "0.00001"]]
+						]
+					]
+				],
+				[
+					13,
+					"mixed",
+					[
+						6,
+						"variant",
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec4f"
+								],
+								[[
+									7,
+									"st",
+									"rgb"
+								], [5, "1"]]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec4f"
+								],
+								[[
+									7,
+									"color",
+									"xyz"
+								], [5, "1"]]
+							],
+							"t"
+						]
+					]
+				],
+				[
+					13,
+					"ba",
+					[
+						1,
+						[
+							7,
+							"st",
+							"ba"
+						],
+						"+",
+						[
+							1,
+							[
+								1,
+								[5, "1"],
+								"-",
+								[
+									7,
+									"st",
+									"ba"
+								]
+							],
+							"*",
+							"wNew"
+						]
+					]
+				],
+				[
+					13,
+					"ac",
+					[
+						6,
+						[
+							7,
+							[
+								7,
+								"st",
+								"ac"
+							],
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								[
+									7,
+									"color",
+									"xyz"
+								],
+								"mul"
+							],
+							[[
+								1,
+								[
+									7,
+									"color",
+									"w"
+								],
+								"*",
+								[
+									7,
+									"sectors",
+									"y"
+								]
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"aa",
+					[
+						1,
+						[
+							7,
+							"st",
+							"aa"
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"color",
+								"w"
+							],
+							"*",
+							[
+								7,
+								"sectors",
+								"y"
+							]
+						]
+					]
+				],
+				[10, [
+					6,
+					"LightEdgeAccum",
+					[[104, {
+						"rgb": [
+							7,
+							"mixed",
+							"xyz"
+						],
+						"w": [
+							1,
+							[
+								7,
+								"st",
+								"w"
+							],
+							"+",
+							"wNew"
+						],
+						"ba": "ba",
+						"ac": "ac",
+						"aa": "aa"
+					}]]
+				]]
+			]],
+			"externalNames": [
+				"std",
+				"variant",
+				"d",
+				"LightEdgeAccum"
+			]
+		},
+		externals: () => ({
+			std,
+			variant,
+			d,
+			LightEdgeAccum
+		})
+	}) && $.f)({})).$name(`lightEdgeAccumColor_${mode}`);
+}
+function lightEdgeAccumColorFor(mode) {
+	let fn = accumFnByMode.get(mode);
+	if (!fn) {
+		fn = makeAccumFn(mode);
+		accumFnByMode.set(mode, fn);
+	}
+	return fn;
+}
+const lightEdgePickColor = tgpu.fn([d.arrayOf(d.vec4f, 8), d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colors, idx) => {
+	"use gpu";
+	const c = colors[d.i32(idx)];
+	return d.vec4f(c.x, c.y, c.z, c.w);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "colors"
+		}, {
+			"type": "i",
+			"name": "idx"
+		}],
+		"body": [0, [[
+			13,
+			"c",
+			[
+				8,
+				"colors",
+				[
+					6,
+					[
+						7,
+						"d",
+						"i32"
+					],
+					["idx"]
+				]
+			]
+		], [10, [
+			6,
+			[
+				7,
+				"d",
+				"vec4f"
+			],
+			[
+				[
+					7,
+					"c",
+					"x"
+				],
+				[
+					7,
+					"c",
+					"y"
+				],
+				[
+					7,
+					"c",
+					"z"
+				],
+				[
+					7,
+					"c",
+					"w"
+				]
+			]
+		]]]],
+		"externalNames": ["d"]
+	},
+	externals: () => ({ d })
+}) && $.f)({}));
+const lightEdgeCompose = tgpu.fn([LightEdgeAccum, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st, bloom) => {
+	"use gpu";
+	const k = __tsover_mul(bloom, 4);
+	const blendPremult = st.rgb.mul(st.ba);
+	const accumC = std.mix(blendPremult, st.ac, d.vec3f(k));
+	const accumA = std.clamp(std.mix(st.ba, st.aa, k), 0, 1);
+	const straight = std.clamp(accumC.div(std.max(accumA, 1e-4)), d.vec3f(0), d.vec3f(1));
+	return d.vec4f(straight, accumA);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "st"
+		}, {
+			"type": "i",
+			"name": "bloom"
+		}],
+		"body": [0, [
+			[
+				13,
+				"k",
+				[
+					1,
+					"bloom",
+					"*",
+					[5, "4"]
+				]
+			],
+			[
+				13,
+				"blendPremult",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"st",
+							"rgb"
+						],
+						"mul"
+					],
+					[[
+						7,
+						"st",
+						"ba"
+					]]
+				]
+			],
+			[
+				13,
+				"accumC",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"blendPremult",
+						[
+							7,
+							"st",
+							"ac"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							["k"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"accumA",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"st",
+									"ba"
+								],
+								[
+									7,
+									"st",
+									"aa"
+								],
+								"k"
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"straight",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"accumC",
+								"div"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								["accumA", [5, "0.0001"]]
+							]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[[5, "1"]]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				["straight", "accumA"]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const componentDefinition = {
+	name: "LightEdge",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Glowing, pulsing light racing around the edge of any 2D, SVG, or 3D shape. Powered by Paper Shaders.",
+	animatedTime: { speed: "speed" },
+	extraFields: {
+		...VOLUMETRIC_FIELD_EXTRA_FIELDS,
+		...ANALYTIC_SDF_EXTRA_FIELDS
+	},
+	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"
+			}
+		},
+		colorA: {
+			default: "#7b2ff7",
+			transform: transformColor,
+			description: "First border light color (used when no gradient stops are set)",
+			ui: {
+				type: "color",
+				label: "Color A",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#00e0ff",
+			transform: transformColor,
+			description: "Second border light color (used when no gradient stops are set)",
+			ui: {
+				type: "color",
+				label: "Color B",
+				group: "Colors"
+			}
+		},
+		stops: {
+			...colorStopsPropConfig(),
+			default: DEFAULT_STOPS
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space overlapping lights blend in",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		},
+		thickness: {
+			default: .25,
+			description: "Width of the border band",
+			ui: {
+				type: ["range", "map"],
+				min: .01,
+				max: 1,
+				step: .01,
+				label: "Thickness",
+				group: "Border"
+			}
+		},
+		softness: {
+			default: .5,
+			description: "Edge softness — 0 = crisp band, 1 = wide smooth gradient",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Softness",
+				group: "Border"
+			}
+		},
+		intensity: {
+			default: .6,
+			description: "Brightness of the individual light spots",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Intensity",
+				group: "Light"
+			}
+		},
+		bloom: {
+			default: .3,
+			description: "How additively overlapping lights pile up — high values overdrive to white",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Bloom",
+				group: "Light"
+			}
+		},
+		spots: {
+			default: 3,
+			description: "Number of light spots orbiting per color",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 5,
+				step: 1,
+				label: "Spots",
+				group: "Light"
+			}
+		},
+		spotSize: {
+			default: .5,
+			description: "Angular size of each light spot",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Spot Size",
+				group: "Light"
+			}
+		},
+		pulse: {
+			default: 0,
+			description: "Heartbeat pulsing — synchronizes the lights to a double-beat rhythm",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Pulse",
+				group: "Animation"
+			}
+		},
+		smoke: {
+			default: .3,
+			description: "Noisy luminous smoke drifting along the border",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Smoke",
+				group: "Smoke"
+			}
+		},
+		smokeSize: {
+			default: .5,
+			description: "Scale of the smoke billows",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Smoke Size",
+				group: "Smoke"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Animation speed. 0 pauses.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed — re-rolls spot speeds, directions and phases",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Animation"
+			}
+		},
+		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"
+		}
+	},
+	compute: (params) => {
+		const vf = createVolumetricFieldComputeNode(params, () => params.getCpuValue("shape"), "none");
+		return vf ? {
+			outputs: vf.outputs,
+			getComputeNodes: (fp) => vf.getComputeNodes(fp)
+		} : null;
+	},
+	fragment: (params) => {
+		const { computeOutputs, uniforms, propValues, ctx, getCpuValue } = params;
+		let sampler;
+		const fieldTex = computeOutputs?.volumetricFieldTexture;
+		if (fieldTex) sampler = buildVolumetricFieldSampler(fieldTex, {
+			originX: uniforms._vfOriginX,
+			originY: uniforms._vfOriginY,
+			spanX: uniforms._vfSpanX,
+			spanY: uniforms._vfSpanY,
+			activeResF: uniforms._vfActiveRes,
+			rBound: uniforms._vfRBound
+		}).volumetricFieldSampler;
+		else {
+			const shapeSdfUrl = propValues.shapeSdfUrl || "";
+			if (shapeSdfUrl) sampler = createSvgSdfSampler(params, shapeSdfUrl);
+			else sampler = createAnalyticSdfSampler(resolveShapeType(propValues.shapeType || "", getCpuValue("shape")), driveAnalyticSubProps(params, () => getCpuValue("shape")));
+		}
+		const sdfUV = call(sdfSpaceUV, "sdfSpaceUV", [
+			uniforms.center,
+			uniforms.scale,
+			uniforms.rotation,
+			ctx.uv,
+			ctx.aspect
+		]);
+		const surf0 = sampler(sdfUV);
+		const t = animatedTime(params);
+		const bAndA = call(lightEdgeBorder, "lightEdgeBorder", [
+			surf0.member("r"),
+			sdfUV,
+			ctx.viewportSize,
+			uniforms.scale,
+			uniforms.thickness,
+			uniforms.softness,
+			uniforms.smokeSize,
+			uniforms.smoke,
+			t,
+			uniforms.pulse
+		]);
+		const border = bAndA.member("x");
+		const angle01 = bAndA.member("y");
+		const stopCount = propValues.stopCount ?? 0;
+		const colorCount = stopCount > 1 ? Math.min(stopCount, 8) : 2;
+		const accumColorFn = lightEdgeAccumColorFor(propValues.colorSpace ?? 0);
+		const accumFor = (idx) => call(lightEdgeColorAccum, "lightEdgeColorAccum", [
+			angle01,
+			border,
+			t,
+			uniforms.spots,
+			uniforms.spotSize,
+			uniforms.pulse,
+			uniforms.intensity,
+			uniforms.softness,
+			uniforms.seed,
+			floatE(idx)
+		]);
+		const colorFor = (idx) => stopCount > 1 ? call(lightEdgePickColor, "lightEdgePickColor", [uniforms.colorsArray, floatE(idx)]) : idx === 0 ? uniforms.colorA : uniforms.colorB;
+		let state = call(lightEdgeAccumZero, "lightEdgeAccumZero", []);
+		for (let i = 0; i < colorCount; i++) state = call(accumColorFn, "lightEdgeAccumColor", [
+			state,
+			colorFor(i),
+			accumFor(i)
+		]);
+		return call(lightEdgeCompose, "lightEdgeCompose", [state, uniforms.bloom]);
+	}
+};
+var LightEdge_default = componentDefinition;
+export { lightEdgeAccumZero as a, lightEdgeColorAccum as c, lightEdgeAccumColorFor as i, lightEdgeCompose as l, LightEdge_default as n, lightEdgeBeat as o, componentDefinition as r, lightEdgeBorder as s, LightEdgeAccum as t, lightEdgePickColor as u };