shaders 2.5.135 → 3.0.437

package/dist/core/Neon-DFuPjkcF.js

@@ -0,0 +1,2591 @@
+import { At as call, Pt as floatE, R as std, T as sdf_exports, cn as __export, d as sdf3d_exports, n as tgpu, on as d } from "./coords-BlwgBpJf.js";
+import { i as sdfSpaceUV, r as offsetUV } from "./glass-DdgMBWkF.js";
+import { a as transformColor, c as transformPosition } from "./transformations-fqzznt4g.js";
+import { t as shapeEffectBoundingBoxDeclaration } from "./shapeEffectBounds-BlxxsYMN.js";
+var neon_exports = /* @__PURE__ */ __export({
+	applyNeonEffect: () => applyNeonEffect$1,
+	neonComposite: () => neonComposite,
+	neonFlicker: () => neonFlicker,
+	neonFlow: () => neonFlow,
+	neonGlow: () => neonGlow,
+	neonSmoothEPS: () => neonSmoothEPS
+});
+var DEG_TO_RAD = .017453292519943295;
+var _LZ = .7;
+var _INV_LIGHT_LEN = 1 / Math.sqrt(1 + _LZ * _LZ);
+var _LZN = _LZ * _INV_LIGHT_LEN;
+var _HZ = _LZN + 1;
+var _INV_H_LEN = 1 / Math.sqrt(_INV_LIGHT_LEN * _INV_LIGHT_LEN + _HZ * _HZ);
+const neonSmoothEPS = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((tubeThickness, cornerSmoothing, volumetric) => {
+	"use gpu";
+	const vol = std.max(tubeThickness, .006);
+	const flat = __tsover_add(.008, __tsover_mul(cornerSmoothing, .03));
+	return std.select(flat, vol, volumetric > .5);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "tubeThickness"
+			},
+			{
+				"type": "i",
+				"name": "cornerSmoothing"
+			},
+			{
+				"type": "i",
+				"name": "volumetric"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"vol",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["tubeThickness", [5, "0.006"]]
+				]
+			],
+			[
+				13,
+				"flat",
+				[
+					1,
+					[5, "0.008"],
+					"+",
+					[
+						1,
+						"cornerSmoothing",
+						"*",
+						[5, "0.03"]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					"flat",
+					"vol",
+					[
+						1,
+						"volumetric",
+						">",
+						[5, "0.5"]
+					]
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+const neonGlow = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdf, glowRadius, glowIntensity) => {
+	"use gpu";
+	const glowR = std.max(glowRadius, .001);
+	const sdfOutside = std.max(sdf, 0);
+	const innerGlow = __tsover_mul(std.exp(__tsover_mul(__tsover_mul(sdfOutside, -1), __tsover_div(12, glowR))), .7);
+	const outerGlow = __tsover_mul(std.exp(__tsover_mul(__tsover_mul(sdfOutside, -1), __tsover_div(4, glowR))), .35);
+	const totalGlow = __tsover_mul(__tsover_add(innerGlow, outerGlow), glowIntensity);
+	const outsideFactor = std.smoothstep(-.003, .003, sdf);
+	return __tsover_mul(totalGlow, outsideFactor);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sdf"
+			},
+			{
+				"type": "i",
+				"name": "glowRadius"
+			},
+			{
+				"type": "i",
+				"name": "glowIntensity"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"glowR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["glowRadius", [5, "0.001"]]
+				]
+			],
+			[
+				13,
+				"sdfOutside",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["sdf", [5, "0"]]
+				]
+			],
+			[
+				13,
+				"innerGlow",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							[
+								1,
+								"sdfOutside",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"*",
+							[
+								1,
+								[5, "12"],
+								"/",
+								"glowR"
+							]
+						]]
+					],
+					"*",
+					[5, "0.7"]
+				]
+			],
+			[
+				13,
+				"outerGlow",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							[
+								1,
+								"sdfOutside",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"*",
+							[
+								1,
+								[5, "4"],
+								"/",
+								"glowR"
+							]
+						]]
+					],
+					"*",
+					[5, "0.35"]
+				]
+			],
+			[
+				13,
+				"totalGlow",
+				[
+					1,
+					[
+						1,
+						"innerGlow",
+						"+",
+						"outerGlow"
+					],
+					"*",
+					"glowIntensity"
+				]
+			],
+			[
+				13,
+				"outsideFactor",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[
+							4,
+							"-",
+							[5, "0.003"]
+						],
+						[5, "0.003"],
+						"sdf"
+					]
+				]
+			],
+			[10, [
+				1,
+				"totalGlow",
+				"*",
+				"outsideFactor"
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+const neonFlicker = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((time, flickerSpeed, flickerAmount) => {
+	"use gpu";
+	const flickerTime = __tsover_mul(time, flickerSpeed);
+	const f1 = std.sin(__tsover_mul(flickerTime, 17.13));
+	const f2 = std.sin(__tsover_mul(flickerTime, 31.71));
+	const f3 = std.sin(__tsover_mul(flickerTime, 47.29));
+	const combined = __tsover_add(__tsover_add(f1, __tsover_mul(f2, .5)), __tsover_mul(f3, .3));
+	const threshold = std.mix(-2, .8, flickerAmount);
+	return std.smoothstep(__tsover_sub(threshold, .1), __tsover_add(threshold, .1), combined);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "time"
+			},
+			{
+				"type": "i",
+				"name": "flickerSpeed"
+			},
+			{
+				"type": "i",
+				"name": "flickerAmount"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"flickerTime",
+				[
+					1,
+					"time",
+					"*",
+					"flickerSpeed"
+				]
+			],
+			[
+				13,
+				"f1",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"flickerTime",
+						"*",
+						[5, "17.13"]
+					]]
+				]
+			],
+			[
+				13,
+				"f2",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"flickerTime",
+						"*",
+						[5, "31.71"]
+					]]
+				]
+			],
+			[
+				13,
+				"f3",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"flickerTime",
+						"*",
+						[5, "47.29"]
+					]]
+				]
+			],
+			[
+				13,
+				"combined",
+				[
+					1,
+					[
+						1,
+						"f1",
+						"+",
+						[
+							1,
+							"f2",
+							"*",
+							[5, "0.5"]
+						]
+					],
+					"+",
+					[
+						1,
+						"f3",
+						"*",
+						[5, "0.3"]
+					]
+				]
+			],
+			[
+				13,
+				"threshold",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							4,
+							"-",
+							[5, "2"]
+						],
+						[5, "0.8"],
+						"flickerAmount"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"smoothstep"
+				],
+				[
+					[
+						1,
+						"threshold",
+						"-",
+						[5, "0.1"]
+					],
+					[
+						1,
+						"threshold",
+						"+",
+						[5, "0.1"]
+					],
+					"combined"
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+const neonFlow = tgpu.fn([
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sdfUV, time, flowSpeed, flowAmount) => {
+	"use gpu";
+	const flowDx = __tsover_sub(sdfUV.x, .5);
+	const flowDy = __tsover_sub(sdfUV.y, .5);
+	const flowAngle = std.atan2(flowDy, flowDx);
+	const flowPhase = __tsover_add(__tsover_mul(flowAngle, 2), __tsover_mul(time, flowSpeed));
+	const flowWave = __tsover_add(__tsover_mul(std.sin(flowPhase), .5), .5);
+	return std.mix(1, flowWave, flowAmount);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sdfUV"
+			},
+			{
+				"type": "i",
+				"name": "time"
+			},
+			{
+				"type": "i",
+				"name": "flowSpeed"
+			},
+			{
+				"type": "i",
+				"name": "flowAmount"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"flowDx",
+				[
+					1,
+					[
+						7,
+						"sdfUV",
+						"x"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"flowDy",
+				[
+					1,
+					[
+						7,
+						"sdfUV",
+						"y"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"flowAngle",
+				[
+					6,
+					[
+						7,
+						"std",
+						"atan2"
+					],
+					["flowDy", "flowDx"]
+				]
+			],
+			[
+				13,
+				"flowPhase",
+				[
+					1,
+					[
+						1,
+						"flowAngle",
+						"*",
+						[5, "2"]
+					],
+					"+",
+					[
+						1,
+						"time",
+						"*",
+						"flowSpeed"
+					]
+				]
+			],
+			[
+				13,
+				"flowWave",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							["flowPhase"]
+						],
+						"*",
+						[5, "0.5"]
+					],
+					"+",
+					[5, "0.5"]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"mix"
+				],
+				[
+					[5, "1"],
+					"flowWave",
+					"flowAmount"
+				]
+			]]
+		]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+const neonComposite = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.vec4f,
+	d.vec4f,
+	d.vec4f,
+	d.f32,
+	d.vec2f,
+	d.f32,
+	d.vec2f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.vec3f,
+	d.vec3f,
+	d.f32,
+	d.vec3f,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((sC, sR, sL, sU, sD, smoothEPS, sdfUV, scale, viewportSize, time, cornerSmoothing, tubeThickness, color, secondaryColor, secondaryBlend, glowColor, intensity, hotCoreIntensity, glowIntensity, glowRadius, lightAngle, specularIntensity, specularSize, flickerSpeed, flickerAmount, flowSpeed, flowAmount, volumetric) => {
+	"use gpu";
+	const sdfCenter = sC.x;
+	const sdfRight = sR.x;
+	const sdfLeft = sL.x;
+	const sdfUp = sU.x;
+	const sdfDown = sD.x;
+	const pxH = __tsover_div(1, viewportSize.y);
+	const glowR = std.max(glowRadius, .001);
+	const softPx = std.max(__tsover_div(pxH, scale), .004);
+	const gradX = __tsover_div(__tsover_sub(sdfRight, sdfLeft), __tsover_mul(smoothEPS, 2));
+	const gradY = __tsover_div(__tsover_sub(sdfUp, sdfDown), __tsover_mul(smoothEPS, 2));
+	const smoothedSdf = __tsover_div(__tsover_add(__tsover_add(__tsover_add(__tsover_add(sdfCenter, sdfRight), sdfLeft), sdfUp), sdfDown), 5);
+	const sdf = std.mix(sdfCenter, smoothedSdf, cornerSmoothing);
+	const gxRaw = std.select(gradX, __tsover_sub(sR.w, sL.w), volumetric > .5);
+	const gyRaw = std.select(gradY, __tsover_sub(sU.w, sD.w), volumetric > .5);
+	const gradLen = std.max(std.sqrt(__tsover_add(__tsover_mul(gxRaw, gxRaw), __tsover_mul(gyRaw, gyRaw))), 1e-4);
+	const gnx = __tsover_div(gxRaw, gradLen);
+	const gny = __tsover_div(gyRaw, gradLen);
+	const depthNorm2D = std.clamp(__tsover_div(__tsover_mul(sdf, -1), std.max(tubeThickness, .001)), 0, 1);
+	const innerMask2D = std.smoothstep(__tsover_add(tubeThickness, softPx), __tsover_sub(tubeThickness, softPx), __tsover_mul(sdf, -1));
+	const lap = __tsover_add(std.abs(__tsover_sub(__tsover_add(sR.w, sL.w), __tsover_mul(sC.w, 2))), std.abs(__tsover_sub(__tsover_add(sU.w, sD.w), __tsover_mul(sC.w, 2))));
+	const slopeMag = __tsover_add(std.abs(gxRaw), std.abs(gyRaw));
+	const crease = __tsover_div(lap, __tsover_add(__tsover_add(lap, __tsover_mul(smoothEPS, .6)), __tsover_mul(slopeMag, .35)));
+	const innerMaskVol = std.smoothstep(.08, .35, crease);
+	const depthNorm = std.select(depthNorm2D, crease, volumetric > .5);
+	const innerMask = std.select(innerMask2D, innerMaskVol, volumetric > .5);
+	const outerMask = std.smoothstep(softPx, __tsover_mul(softPx, -1), sdf);
+	const tubeMask = __tsover_mul(outerMask, innerMask);
+	const t = depthNorm;
+	const cylinderZ = std.sqrt(std.max(__tsover_mul(t, __tsover_sub(2, t)), 0));
+	const cylinderR = __tsover_sub(1, t);
+	const nx = __tsover_mul(gnx, cylinderR);
+	const ny = __tsover_mul(gny, cylinderR);
+	const nz = cylinderZ;
+	const lightRad = __tsover_mul(lightAngle, DEG_TO_RAD);
+	const lx = std.cos(lightRad);
+	const ly = std.sin(lightRad);
+	const lxn = __tsover_mul(lx, _INV_LIGHT_LEN);
+	const lyn = __tsover_mul(ly, _INV_LIGHT_LEN);
+	const lzn = _LZN;
+	const NdotL = __tsover_add(__tsover_add(__tsover_mul(nx, lxn), __tsover_mul(ny, lyn)), __tsover_mul(nz, lzn));
+	const diffuse = std.clamp(NdotL, 0, 1);
+	const NdotH = __tsover_add(__tsover_add(__tsover_mul(nx, __tsover_mul(lxn, _INV_H_LEN)), __tsover_mul(ny, __tsover_mul(lyn, _INV_H_LEN))), __tsover_mul(nz, __tsover_mul(_HZ, _INV_H_LEN)));
+	const shininess = std.exp2(__tsover_sub(8, __tsover_mul(specularSize, 7)));
+	const specular = __tsover_mul(std.pow(std.clamp(NdotH, 0, 1), shininess), specularIntensity);
+	const flowMod = neonFlow(sdfUV, time, flowSpeed, flowAmount);
+	const twoTone = std.mix(secondaryColor, color, diffuse);
+	const baseColor = std.mix(color, twoTone, secondaryBlend);
+	const ambient = .12;
+	const selfEmission = __tsover_mul(cylinderZ, .35);
+	const shadedRgb = baseColor.mul(__tsover_add(__tsover_add(ambient, __tsover_mul(diffuse, .55)), selfEmission));
+	const tubeRgb = d.vec3f(__tsover_add(shadedRgb.x, specular), __tsover_add(shadedRgb.y, specular), __tsover_add(shadedRgb.z, specular));
+	const coreProfile = std.smoothstep(.55, 1, depthNorm);
+	const hotCoreAmt = __tsover_mul(__tsover_mul(coreProfile, hotCoreIntensity), flowMod);
+	const hotCoreCol = std.mix(color, d.vec3f(1, 1, 1), .75);
+	const tubeFlowed = std.mix(tubeRgb, hotCoreCol, hotCoreAmt).mul(std.mix(1, flowMod, .4));
+	const glowMasked = neonGlow(sdf, glowRadius, glowIntensity);
+	const flickerValue = neonFlicker(time, flickerSpeed, flickerAmount);
+	const intensityMul = __tsover_mul(intensity, flickerValue);
+	const finalTubeRgb = tubeFlowed.mul(intensityMul);
+	const finalGlowRgb = glowColor.mul(__tsover_mul(glowMasked, intensityMul));
+	const finalR = std.mix(finalGlowRgb.x, finalTubeRgb.x, tubeMask);
+	const finalG = std.mix(finalGlowRgb.y, finalTubeRgb.y, tubeMask);
+	const finalB = std.mix(finalGlowRgb.z, finalTubeRgb.z, tubeMask);
+	const glowAlpha = std.clamp(__tsover_mul(glowMasked, .6), 0, 1);
+	const finalA = std.max(tubeMask, glowAlpha);
+	const result = d.vec4f(finalR, finalG, finalB, finalA);
+	const threshOut = __tsover_add(__tsover_add(__tsover_mul(glowR, 1.5), softPx), smoothEPS);
+	return std.select(result, d.vec4f(0, 0, 0, 0), sdfCenter > threshOut);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "sC"
+			},
+			{
+				"type": "i",
+				"name": "sR"
+			},
+			{
+				"type": "i",
+				"name": "sL"
+			},
+			{
+				"type": "i",
+				"name": "sU"
+			},
+			{
+				"type": "i",
+				"name": "sD"
+			},
+			{
+				"type": "i",
+				"name": "smoothEPS"
+			},
+			{
+				"type": "i",
+				"name": "sdfUV"
+			},
+			{
+				"type": "i",
+				"name": "scale"
+			},
+			{
+				"type": "i",
+				"name": "viewportSize"
+			},
+			{
+				"type": "i",
+				"name": "time"
+			},
+			{
+				"type": "i",
+				"name": "cornerSmoothing"
+			},
+			{
+				"type": "i",
+				"name": "tubeThickness"
+			},
+			{
+				"type": "i",
+				"name": "color"
+			},
+			{
+				"type": "i",
+				"name": "secondaryColor"
+			},
+			{
+				"type": "i",
+				"name": "secondaryBlend"
+			},
+			{
+				"type": "i",
+				"name": "glowColor"
+			},
+			{
+				"type": "i",
+				"name": "intensity"
+			},
+			{
+				"type": "i",
+				"name": "hotCoreIntensity"
+			},
+			{
+				"type": "i",
+				"name": "glowIntensity"
+			},
+			{
+				"type": "i",
+				"name": "glowRadius"
+			},
+			{
+				"type": "i",
+				"name": "lightAngle"
+			},
+			{
+				"type": "i",
+				"name": "specularIntensity"
+			},
+			{
+				"type": "i",
+				"name": "specularSize"
+			},
+			{
+				"type": "i",
+				"name": "flickerSpeed"
+			},
+			{
+				"type": "i",
+				"name": "flickerAmount"
+			},
+			{
+				"type": "i",
+				"name": "flowSpeed"
+			},
+			{
+				"type": "i",
+				"name": "flowAmount"
+			},
+			{
+				"type": "i",
+				"name": "volumetric"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"sdfCenter",
+				[
+					7,
+					"sC",
+					"x"
+				]
+			],
+			[
+				13,
+				"sdfRight",
+				[
+					7,
+					"sR",
+					"x"
+				]
+			],
+			[
+				13,
+				"sdfLeft",
+				[
+					7,
+					"sL",
+					"x"
+				]
+			],
+			[
+				13,
+				"sdfUp",
+				[
+					7,
+					"sU",
+					"x"
+				]
+			],
+			[
+				13,
+				"sdfDown",
+				[
+					7,
+					"sD",
+					"x"
+				]
+			],
+			[
+				13,
+				"pxH",
+				[
+					1,
+					[5, "1"],
+					"/",
+					[
+						7,
+						"viewportSize",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"glowR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["glowRadius", [5, "0.001"]]
+				]
+			],
+			[
+				13,
+				"softPx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						1,
+						"pxH",
+						"/",
+						"scale"
+					], [5, "0.004"]]
+				]
+			],
+			[
+				13,
+				"gradX",
+				[
+					1,
+					[
+						1,
+						"sdfRight",
+						"-",
+						"sdfLeft"
+					],
+					"/",
+					[
+						1,
+						"smoothEPS",
+						"*",
+						[5, "2"]
+					]
+				]
+			],
+			[
+				13,
+				"gradY",
+				[
+					1,
+					[
+						1,
+						"sdfUp",
+						"-",
+						"sdfDown"
+					],
+					"/",
+					[
+						1,
+						"smoothEPS",
+						"*",
+						[5, "2"]
+					]
+				]
+			],
+			[
+				13,
+				"smoothedSdf",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"sdfCenter",
+									"+",
+									"sdfRight"
+								],
+								"+",
+								"sdfLeft"
+							],
+							"+",
+							"sdfUp"
+						],
+						"+",
+						"sdfDown"
+					],
+					"/",
+					[5, "5"]
+				]
+			],
+			[
+				13,
+				"sdf",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"sdfCenter",
+						"smoothedSdf",
+						"cornerSmoothing"
+					]
+				]
+			],
+			[
+				13,
+				"gxRaw",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"gradX",
+						[
+							1,
+							[
+								7,
+								"sR",
+								"w"
+							],
+							"-",
+							[
+								7,
+								"sL",
+								"w"
+							]
+						],
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"gyRaw",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"gradY",
+						[
+							1,
+							[
+								7,
+								"sU",
+								"w"
+							],
+							"-",
+							[
+								7,
+								"sD",
+								"w"
+							]
+						],
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"gradLen",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"sqrt"
+						],
+						[[
+							1,
+							[
+								1,
+								"gxRaw",
+								"*",
+								"gxRaw"
+							],
+							"+",
+							[
+								1,
+								"gyRaw",
+								"*",
+								"gyRaw"
+							]
+						]]
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"gnx",
+				[
+					1,
+					"gxRaw",
+					"/",
+					"gradLen"
+				]
+			],
+			[
+				13,
+				"gny",
+				[
+					1,
+					"gyRaw",
+					"/",
+					"gradLen"
+				]
+			],
+			[
+				13,
+				"depthNorm2D",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"sdf",
+								"*",
+								[
+									4,
+									"-",
+									[5, "1"]
+								]
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								["tubeThickness", [5, "0.001"]]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"innerMask2D",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[
+							1,
+							"tubeThickness",
+							"+",
+							"softPx"
+						],
+						[
+							1,
+							"tubeThickness",
+							"-",
+							"softPx"
+						],
+						[
+							1,
+							"sdf",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"lap",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"abs"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									7,
+									"sR",
+									"w"
+								],
+								"+",
+								[
+									7,
+									"sL",
+									"w"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"sC",
+									"w"
+								],
+								"*",
+								[5, "2"]
+							]
+						]]
+					],
+					"+",
+					[
+						6,
+						[
+							7,
+							"std",
+							"abs"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									7,
+									"sU",
+									"w"
+								],
+								"+",
+								[
+									7,
+									"sD",
+									"w"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"sC",
+									"w"
+								],
+								"*",
+								[5, "2"]
+							]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"slopeMag",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"abs"
+						],
+						["gxRaw"]
+					],
+					"+",
+					[
+						6,
+						[
+							7,
+							"std",
+							"abs"
+						],
+						["gyRaw"]
+					]
+				]
+			],
+			[
+				13,
+				"crease",
+				[
+					1,
+					"lap",
+					"/",
+					[
+						1,
+						[
+							1,
+							"lap",
+							"+",
+							[
+								1,
+								"smoothEPS",
+								"*",
+								[5, "0.6"]
+							]
+						],
+						"+",
+						[
+							1,
+							"slopeMag",
+							"*",
+							[5, "0.35"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"innerMaskVol",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[5, "0.08"],
+						[5, "0.35"],
+						"crease"
+					]
+				]
+			],
+			[
+				13,
+				"depthNorm",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"depthNorm2D",
+						"crease",
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"innerMask",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"innerMask2D",
+						"innerMaskVol",
+						[
+							1,
+							"volumetric",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"outerMask",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						"softPx",
+						[
+							1,
+							"softPx",
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						],
+						"sdf"
+					]
+				]
+			],
+			[
+				13,
+				"tubeMask",
+				[
+					1,
+					"outerMask",
+					"*",
+					"innerMask"
+				]
+			],
+			[
+				13,
+				"t",
+				"depthNorm"
+			],
+			[
+				13,
+				"cylinderZ",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sqrt"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							"t",
+							"*",
+							[
+								1,
+								[5, "2"],
+								"-",
+								"t"
+							]
+						], [5, "0"]]
+					]]
+				]
+			],
+			[
+				13,
+				"cylinderR",
+				[
+					1,
+					[5, "1"],
+					"-",
+					"t"
+				]
+			],
+			[
+				13,
+				"nx",
+				[
+					1,
+					"gnx",
+					"*",
+					"cylinderR"
+				]
+			],
+			[
+				13,
+				"ny",
+				[
+					1,
+					"gny",
+					"*",
+					"cylinderR"
+				]
+			],
+			[
+				13,
+				"nz",
+				"cylinderZ"
+			],
+			[
+				13,
+				"lightRad",
+				[
+					1,
+					"lightAngle",
+					"*",
+					"DEG_TO_RAD"
+				]
+			],
+			[
+				13,
+				"lx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					["lightRad"]
+				]
+			],
+			[
+				13,
+				"ly",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					["lightRad"]
+				]
+			],
+			[
+				13,
+				"lxn",
+				[
+					1,
+					"lx",
+					"*",
+					"_INV_LIGHT_LEN"
+				]
+			],
+			[
+				13,
+				"lyn",
+				[
+					1,
+					"ly",
+					"*",
+					"_INV_LIGHT_LEN"
+				]
+			],
+			[
+				13,
+				"lzn",
+				"_LZN"
+			],
+			[
+				13,
+				"NdotL",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"nx",
+							"*",
+							"lxn"
+						],
+						"+",
+						[
+							1,
+							"ny",
+							"*",
+							"lyn"
+						]
+					],
+					"+",
+					[
+						1,
+						"nz",
+						"*",
+						"lzn"
+					]
+				]
+			],
+			[
+				13,
+				"diffuse",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"NdotL",
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"NdotH",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"nx",
+							"*",
+							[
+								1,
+								"lxn",
+								"*",
+								"_INV_H_LEN"
+							]
+						],
+						"+",
+						[
+							1,
+							"ny",
+							"*",
+							[
+								1,
+								"lyn",
+								"*",
+								"_INV_H_LEN"
+							]
+						]
+					],
+					"+",
+					[
+						1,
+						"nz",
+						"*",
+						[
+							1,
+							"_HZ",
+							"*",
+							"_INV_H_LEN"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"shininess",
+				[
+					6,
+					[
+						7,
+						"std",
+						"exp2"
+					],
+					[[
+						1,
+						[5, "8"],
+						"-",
+						[
+							1,
+							"specularSize",
+							"*",
+							[5, "7"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"specular",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"pow"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"NdotH",
+								[5, "0"],
+								[5, "1"]
+							]
+						], "shininess"]
+					],
+					"*",
+					"specularIntensity"
+				]
+			],
+			[
+				13,
+				"flowMod",
+				[
+					6,
+					"neonFlow",
+					[
+						"sdfUV",
+						"time",
+						"flowSpeed",
+						"flowAmount"
+					]
+				]
+			],
+			[
+				13,
+				"twoTone",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"secondaryColor",
+						"color",
+						"diffuse"
+					]
+				]
+			],
+			[
+				13,
+				"baseColor",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"color",
+						"twoTone",
+						"secondaryBlend"
+					]
+				]
+			],
+			[
+				13,
+				"ambient",
+				[5, "0.12"]
+			],
+			[
+				13,
+				"selfEmission",
+				[
+					1,
+					"cylinderZ",
+					"*",
+					[5, "0.35"]
+				]
+			],
+			[
+				13,
+				"shadedRgb",
+				[
+					6,
+					[
+						7,
+						"baseColor",
+						"mul"
+					],
+					[[
+						1,
+						[
+							1,
+							"ambient",
+							"+",
+							[
+								1,
+								"diffuse",
+								"*",
+								[5, "0.55"]
+							]
+						],
+						"+",
+						"selfEmission"
+					]]
+				]
+			],
+			[
+				13,
+				"tubeRgb",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"shadedRgb",
+								"x"
+							],
+							"+",
+							"specular"
+						],
+						[
+							1,
+							[
+								7,
+								"shadedRgb",
+								"y"
+							],
+							"+",
+							"specular"
+						],
+						[
+							1,
+							[
+								7,
+								"shadedRgb",
+								"z"
+							],
+							"+",
+							"specular"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"coreProfile",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[5, "0.55"],
+						[5, "1"],
+						"depthNorm"
+					]
+				]
+			],
+			[
+				13,
+				"hotCoreAmt",
+				[
+					1,
+					[
+						1,
+						"coreProfile",
+						"*",
+						"hotCoreIntensity"
+					],
+					"*",
+					"flowMod"
+				]
+			],
+			[
+				13,
+				"hotCoreCol",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"color",
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[5, "1"],
+								[5, "1"],
+								[5, "1"]
+							]
+						],
+						[5, "0.75"]
+					]
+				]
+			],
+			[
+				13,
+				"tubeWithCore",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"tubeRgb",
+						"hotCoreCol",
+						"hotCoreAmt"
+					]
+				]
+			],
+			[
+				13,
+				"tubeFlowed",
+				[
+					6,
+					[
+						7,
+						"tubeWithCore",
+						"mul"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							[5, "1"],
+							"flowMod",
+							[5, "0.4"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"glowMasked",
+				[
+					6,
+					"neonGlow",
+					[
+						"sdf",
+						"glowRadius",
+						"glowIntensity"
+					]
+				]
+			],
+			[
+				13,
+				"flickerValue",
+				[
+					6,
+					"neonFlicker",
+					[
+						"time",
+						"flickerSpeed",
+						"flickerAmount"
+					]
+				]
+			],
+			[
+				13,
+				"intensityMul",
+				[
+					1,
+					"intensity",
+					"*",
+					"flickerValue"
+				]
+			],
+			[
+				13,
+				"finalTubeRgb",
+				[
+					6,
+					[
+						7,
+						"tubeFlowed",
+						"mul"
+					],
+					["intensityMul"]
+				]
+			],
+			[
+				13,
+				"finalGlowRgb",
+				[
+					6,
+					[
+						7,
+						"glowColor",
+						"mul"
+					],
+					[[
+						1,
+						"glowMasked",
+						"*",
+						"intensityMul"
+					]]
+				]
+			],
+			[
+				13,
+				"finalR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							7,
+							"finalGlowRgb",
+							"x"
+						],
+						[
+							7,
+							"finalTubeRgb",
+							"x"
+						],
+						"tubeMask"
+					]
+				]
+			],
+			[
+				13,
+				"finalG",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							7,
+							"finalGlowRgb",
+							"y"
+						],
+						[
+							7,
+							"finalTubeRgb",
+							"y"
+						],
+						"tubeMask"
+					]
+				]
+			],
+			[
+				13,
+				"finalB",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							7,
+							"finalGlowRgb",
+							"z"
+						],
+						[
+							7,
+							"finalTubeRgb",
+							"z"
+						],
+						"tubeMask"
+					]
+				]
+			],
+			[
+				13,
+				"glowAlpha",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							"glowMasked",
+							"*",
+							[5, "0.6"]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"finalA",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["tubeMask", "glowAlpha"]
+				]
+			],
+			[
+				13,
+				"result",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"finalR",
+						"finalG",
+						"finalB",
+						"finalA"
+					]
+				]
+			],
+			[
+				13,
+				"threshOut",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"glowR",
+							"*",
+							[5, "1.5"]
+						],
+						"+",
+						"softPx"
+					],
+					"+",
+					"smoothEPS"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					"result",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[5, "0"],
+							[5, "0"],
+							[5, "0"],
+							[5, "0"]
+						]
+					],
+					[
+						1,
+						"sdfCenter",
+						">",
+						"threshOut"
+					]
+				]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"DEG_TO_RAD",
+			"_INV_LIGHT_LEN",
+			"_LZN",
+			"_INV_H_LEN",
+			"_HZ",
+			"neonFlow",
+			"d",
+			"neonGlow",
+			"neonFlicker"
+		]
+	},
+	externals: () => ({
+		std,
+		DEG_TO_RAD,
+		_INV_LIGHT_LEN,
+		_LZN,
+		_INV_H_LEN,
+		_HZ,
+		neonFlow,
+		d,
+		neonGlow,
+		neonFlicker
+	})
+}) && $.f)({}));
+function applyNeonEffect$1(params, sdfSampler, time, options) {
+	const { uniforms, ctx } = params;
+	const gradSampler = options?.gradSampler ?? sdfSampler;
+	const volFlag = floatE(options?.volumetric ? 1 : 0);
+	const sdfUV = call(sdfSpaceUV, "sdfSpaceUV", [
+		uniforms.center,
+		uniforms.scale,
+		uniforms.rotation,
+		ctx.uv,
+		ctx.aspect
+	]);
+	const smoothEPS = call(neonSmoothEPS, "neonSmoothEPS", [
+		uniforms.tubeThickness,
+		uniforms.cornerSmoothing,
+		volFlag
+	]);
+	const negEPS = smoothEPS.mul(-1);
+	return call(neonComposite, "neonComposite", [
+		sdfSampler(sdfUV),
+		gradSampler(call(offsetUV, "offsetUV", [
+			sdfUV,
+			smoothEPS,
+			floatE(0)
+		])),
+		gradSampler(call(offsetUV, "offsetUV", [
+			sdfUV,
+			negEPS,
+			floatE(0)
+		])),
+		gradSampler(call(offsetUV, "offsetUV", [
+			sdfUV,
+			floatE(0),
+			smoothEPS
+		])),
+		gradSampler(call(offsetUV, "offsetUV", [
+			sdfUV,
+			floatE(0),
+			negEPS
+		])),
+		smoothEPS,
+		sdfUV,
+		uniforms.scale,
+		ctx.viewportSize,
+		time,
+		uniforms.cornerSmoothing,
+		uniforms.tubeThickness,
+		uniforms.color.member("rgb"),
+		uniforms.secondaryColor.member("rgb"),
+		uniforms.secondaryBlend,
+		uniforms.glowColor.member("rgb"),
+		uniforms.intensity,
+		uniforms.hotCoreIntensity,
+		uniforms.glowIntensity,
+		uniforms.glowRadius,
+		uniforms.lightAngle,
+		uniforms.specularIntensity,
+		uniforms.specularSize,
+		uniforms.flickerSpeed,
+		uniforms.flickerAmount,
+		uniforms.flowSpeed,
+		uniforms.flowAmount,
+		volFlag
+	]);
+}
+var { applyNeonEffect } = neon_exports;
+var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
+var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType } = sdf3d_exports;
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .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";
+}
+const componentDefinition = {
+	name: "Neon",
+	boundingBoxDeclaration: shapeEffectBoundingBoxDeclaration,
+	category: "Shape Effects",
+	description: "Photorealistic neon tube / 3D pipe effect driven by a custom shape",
+	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 neon shape",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Position",
+				units: ["%", "px"]
+			}
+		},
+		scale: {
+			default: 1,
+			description: "Scale of the neon shape (1 = default size)",
+			ui: {
+				type: "range",
+				min: .1,
+				max: 3,
+				step: .01,
+				label: "Scale",
+				group: "Position"
+			}
+		},
+		rotation: {
+			default: 0,
+			description: "Rotation of the neon shape in degrees",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Rotation",
+				group: "Position"
+			}
+		},
+		color: {
+			default: "#00ddff",
+			transform: transformColor,
+			description: "Primary neon tube color",
+			ui: {
+				type: "color",
+				label: "Tube Color",
+				group: "Colors"
+			}
+		},
+		secondaryColor: {
+			default: "#ff00aa",
+			transform: transformColor,
+			description: "Shadow-side color for a two-tone / dual-lit pipe look",
+			ui: {
+				type: "color",
+				label: "Secondary Color",
+				group: "Colors"
+			}
+		},
+		secondaryBlend: {
+			default: .5,
+			description: "Blend between mono (0) and two-tone (1) tube coloring",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Blend",
+				group: "Colors"
+			}
+		},
+		glowColor: {
+			default: "#00ddff",
+			transform: transformColor,
+			description: "Color of the outer glow / bloom",
+			ui: {
+				type: "color",
+				label: "Glow Color",
+				group: "Colors"
+			}
+		},
+		tubeThickness: {
+			default: .2,
+			transform: (v) => v * .05,
+			description: "How far inward from the boundary the tube extends. Low = thin neon outline, high = thick 3D pipe",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Tube Thickness",
+				group: "Tube"
+			}
+		},
+		intensity: {
+			default: 1.5,
+			description: "Overall brightness multiplier",
+			ui: {
+				type: "range",
+				min: .5,
+				max: 4,
+				step: .01,
+				label: "Intensity",
+				group: "Tube"
+			}
+		},
+		hotCoreIntensity: {
+			default: .6,
+			description: "Bright white-hot center line — the gas discharge glow inside the tube",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Hot Core",
+				group: "Tube"
+			}
+		},
+		glowIntensity: {
+			default: .6,
+			description: "Outer glow / bloom strength",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Glow Intensity",
+				group: "Glow"
+			}
+		},
+		glowRadius: {
+			default: .25,
+			description: "How far the glow extends beyond the tube",
+			ui: {
+				type: "range",
+				min: .01,
+				max: 1,
+				step: .01,
+				label: "Glow Radius",
+				group: "Glow"
+			}
+		},
+		lightAngle: {
+			default: 300,
+			description: "Directional light angle in degrees — controls 3D shading on the tube",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 360,
+				step: 1,
+				label: "Light Angle",
+				group: "Lighting"
+			}
+		},
+		specularIntensity: {
+			default: .5,
+			description: "Specular highlight brightness on the tube surface",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 2,
+				step: .01,
+				label: "Specular",
+				group: "Lighting"
+			}
+		},
+		specularSize: {
+			default: .5,
+			description: "Specular highlight size — 0 = tight pinpoint, 1 = broad sheen",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Specular Size",
+				group: "Lighting"
+			}
+		},
+		cornerSmoothing: {
+			default: .15,
+			description: "Rounds sharp corners to mimic how real glass tubes curve at bends",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Corner Smoothing",
+				group: "Tube"
+			}
+		},
+		flickerSpeed: {
+			default: 0,
+			description: "Flicker animation speed — 0 = off, higher = faster sporadic on/off",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Speed",
+				group: "Flicker"
+			}
+		},
+		flickerAmount: {
+			default: .2,
+			description: "How often the neon flickers off — 0 = always on, 1 = frequent outages",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Amount",
+				group: "Flicker"
+			}
+		},
+		flowSpeed: {
+			default: 0,
+			description: "Flow animation speed — 0 = off, light rotates through the tube",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 5,
+				step: .1,
+				label: "Speed",
+				group: "Flow"
+			}
+		},
+		flowAmount: {
+			default: .3,
+			description: "Strength of the flowing brightness variation — 0 = uniform, 1 = dramatic",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Amount",
+				group: "Flow"
+			}
+		},
+		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 — when non-empty, activates SVG mode and triggers a shader recompile"
+		},
+		shapeType: {
+			default: "",
+			compileTime: true,
+			description: "Active SDF shape type — triggers recompile when shape is switched. When empty, derived from shape JSON at mount time."
+		}
+	},
+	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;
+		const fieldTex = computeOutputs?.volumetricFieldTexture;
+		if (fieldTex) {
+			const s = buildVolumetricFieldSampler(fieldTex, {
+				originX: uniforms._vfOriginX,
+				originY: uniforms._vfOriginY,
+				spanX: uniforms._vfSpanX,
+				spanY: uniforms._vfSpanY,
+				activeResF: uniforms._vfActiveRes,
+				rBound: uniforms._vfRBound
+			});
+			return applyNeonEffect(params, s.volumetricFieldSampler, ctx.time, {
+				volumetric: true,
+				gradSampler: s.volumetricFieldSamplerFast
+			});
+		}
+		const shapeSdfUrl = propValues.shapeSdfUrl || "";
+		const shapeType = propValues.shapeType || "";
+		if (shapeSdfUrl) return applyNeonEffect(params, createSvgSdfSampler(params, shapeSdfUrl), ctx.time, { volumetric: isVolumetricShapeType(shapeType) });
+		const st = resolveShapeType(shapeType, getCpuValue("shape"));
+		return applyNeonEffect(params, createAnalyticSdfSampler(st, driveAnalyticSubProps(params, () => getCpuValue("shape"))), ctx.time, { volumetric: is3dShapeType(st) });
+	}
+};
+var Neon_default = componentDefinition;
+export { componentDefinition as n, Neon_default as t };