shaders 3.1.463 → 3.2.464

package/dist/core/{LightEdge-C5pR-9-d.js → LightEdge-B3HMbUyU.js}

@@ -1,36 +1,12 @@
-import { Dt as sin, Ft as vec3f, H as mixColorsLinear, Kt as arrayOf, Lt as vec4f, Mt as vec2f, Ot as smoothstep, U as mixColorsVariants, _t as max, cn as i32, ct as clamp, et as typegpu_default, ht as fract, it as abs, lt as cos, m as call, mt as floor, ot as atan2, qt as struct, rt as select, sn as f32, v as floatE, vt as min, xt as pow, yt as mix } from "./edges-CV-BHMpI.js";
-import { C as sdf_exports } from "./device-DKcu50_C.js";
-import { s as TWO_PI$1 } from "./constants-BKlzQFdJ.js";
-import { B as MAX_COLOR_STOPS, V as colorStopsPropConfig, t as animatedTime } from "./porters-j7yWJYy2.js";
-import { l as hash22, y as value12 } from "./noise-eXd1Bfrw.js";
-import { i as shapeEffectBoundingBoxDeclaration, n as sdf3d_exports, t as VOLUMETRIC_FIELD_EXTRA_FIELDS$1 } from "./sdf3d-B8EwGL7R.js";
-import { n as glass_exports } from "./glass-Di_yYrw1.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
-var { sdfSpaceUV } = glass_exports;
-var { ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
-var { createVolumetricFieldComputeNode, resolveShapeFieldSampler } = sdf3d_exports;
-var VOLUMETRIC_FIELD_EXTRA_FIELDS = VOLUMETRIC_FIELD_EXTRA_FIELDS$1;
+import { $n as vec4f, Cn as atan2, En as cos, Fn as min, In as mix, Jn as vec2f, Mn as fract, Nt as mixColorsLinear, Pn as max, Pt as mixColorsVariants, Rn as pow, Tn as clamp, Un as sin, Wn as smoothstep, Zn as vec3f, at as call, bn as select, gr as i32, hr as f32, it as asLocal, jn as floor, lt as floatE, mn as typegpu_default, or as arrayOf, sr as struct, t as defineStd, un as TWO_PI$1, xn as abs } from "./lower-z2vuXP8M.js";
+import { l as hash22, y as value12 } from "./noise-B3Oq1k3_.js";
+import { ct as colorStopsPropConfig, st as MAX_COLOR_STOPS, t as animatedTime } from "./porters-B1UjrM1y.js";
+import { j as shapedSurface } from "./materials-D7QX3H4h.js";
+import { v as shapeEffectBoundingBoxDeclaration } from "./sdf3d-BD5m6HR6.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CoIwF5JU.js";
 var TWO_PI = TWO_PI$1;
-var DEFAULT_SHAPE_CONFIG = JSON.stringify({
-	type: "circleSDF",
-	radius: .35
-});
-var THICKNESS_REF = .35;
-var DEFAULT_STOPS = [
-	{
-		color: "#7b2ff7",
-		position: 0
-	},
-	{
-		color: "#00e0ff",
-		position: .5
-	},
-	{
-		color: "#ff3d81",
-		position: 1
-	}
-];
-const lightEdgeBeat = typegpu_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((animTime) => {
+var BAND_THICKNESS_REF = .35;
+const heartbeatPulse = typegpu_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((animTime) => {
 	"use gpu";
 	const time = __tsover_mul(.18, animTime);
 	const first = pow(abs(sin(__tsover_mul(time, TWO_PI))), 10);
@@ -133,7 +109,7 @@ const lightEdgeBeat = typegpu_default.fn([f32], f32)(/* @__PURE__ */ (($) => (gl
 		"std.clamp": () => clamp
 	}
 }) && $.f)({}));
-const lightEdgeBorder = typegpu_default.fn([
+const edgeGlowBand = typegpu_default.fn([
 	f32,
 	vec2f,
 	vec2f,
@@ -143,12 +119,13 @@ const lightEdgeBorder = typegpu_default.fn([
 	f32,
 	f32,
 	f32,
+	f32,
 	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fieldRaw, sdfUV, viewport, scale, thickness, softness, smokeSize, smokeAmt, animTime, pulse) => {
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fieldRaw, sdfUV, viewport, scale, thickness, softness, smokeSize, smokeAmt, animTime, pulse, beat) => {
 	"use gpu";
 	const t = __tsover_add(__tsover_mul(animTime, 1.2), 131);
-	const th = max(__tsover_mul(__tsover_mul(.5, thickness), THICKNESS_REF), .002);
-	const bd = abs(__tsover_add(__tsover_div(fieldRaw, max(scale, .001)), mix(th, 0, softness)));
+	const th = max(__tsover_mul(__tsover_mul(.5, thickness), BAND_THICKNESS_REF), .002);
+	const bd = abs(__tsover_add(__tsover_div(fieldRaw, max(scale, .001)), mix(th, f32(0), softness)));
 	const borderTh = mix(th, __tsover_mul(3, th), softness);
 	const aa = __tsover_div(2, __tsover_mul(viewport.y, max(scale, .001)));
 	const e0 = min(mix(borderTh, __tsover_mul(borderTh, -1), softness), __tsover_add(borderTh, aa));
@@ -164,7 +141,7 @@ const lightEdgeBorder = typegpu_default.fn([
 	const smokeBand = pow(clamp(__tsover_sub(1, 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, mix(1, lightEdgeBeat(animTime), pulse));
+	smoke = __tsover_mul(smoke, mix(f32(1), beat, pulse));
 	border = clamp(__tsover_add(border, clamp(smoke, 0, 1)), 0, 1);
 	const angle01 = __tsover_div(atan2(__tsover_sub(sdfUV.y, .5), __tsover_sub(sdfUV.x, .5)), TWO_PI);
 	return vec2f(border, angle01);
@@ -212,6 +189,10 @@ const lightEdgeBorder = typegpu_default.fn([
 			{
 				"type": "i",
 				"name": "pulse"
+			},
+			{
+				"type": "i",
+				"name": "beat"
 			}
 		],
 		"body": [0, [
@@ -245,7 +226,7 @@ const lightEdgeBorder = typegpu_default.fn([
 							"thickness"
 						],
 						"*",
-						"THICKNESS_REF"
+						"BAND_THICKNESS_REF"
 					], [5, "0.002"]]
 				]
 			],
@@ -270,7 +251,11 @@ const lightEdgeBorder = typegpu_default.fn([
 						"std.mix",
 						[
 							"th",
-							[5, "0"],
+							[
+								6,
+								"d.f32",
+								[[5, "0"]]
+							],
 							"softness"
 						]
 					]
@@ -705,12 +690,12 @@ const lightEdgeBorder = typegpu_default.fn([
 						6,
 						"std.mix",
 						[
-							[5, "1"],
 							[
 								6,
-								"lightEdgeBeat",
-								["animTime"]
+								"d.f32",
+								[[5, "1"]]
 							],
+							"beat",
 							"pulse"
 						]
 					]
@@ -784,8 +769,9 @@ const lightEdgeBorder = typegpu_default.fn([
 	},
 	externals: {
 		"std.max": () => max,
-		"THICKNESS_REF": () => THICKNESS_REF,
+		"BAND_THICKNESS_REF": () => BAND_THICKNESS_REF,
 		"std.mix": () => mix,
+		"d.f32": () => f32,
 		"std.abs": () => abs,
 		"std.min": () => min,
 		"std.smoothstep": () => smoothstep,
@@ -793,12 +779,12 @@ const lightEdgeBorder = typegpu_default.fn([
 		"std.clamp": () => clamp,
 		"d.vec2f": () => vec2f,
 		"noise.value12": () => value12,
-		"lightEdgeBeat": () => lightEdgeBeat,
 		"std.atan2": () => atan2,
 		"TWO_PI": () => TWO_PI
 	}
 }) && $.f)({}));
-const lightEdgeColorAccum = typegpu_default.fn([
+const orbitSpotsAccum = typegpu_default.fn([
+	f32,
 	f32,
 	f32,
 	f32,
@@ -809,10 +795,9 @@ const lightEdgeColorAccum = typegpu_default.fn([
 	f32,
 	f32,
 	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angle01, border, animTime, spotsF, spotSize, pulse, intensity, softness, seed, colorIdxF) => {
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((angle01, border, animTime, beat, 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 = f32(0);
 	let addAcc = f32(0);
@@ -855,6 +840,10 @@ const lightEdgeColorAccum = typegpu_default.fn([
 				"type": "i",
 				"name": "animTime"
 			},
+			{
+				"type": "i",
+				"name": "beat"
+			},
 			{
 				"type": "i",
 				"name": "spotsF"
@@ -900,15 +889,6 @@ const lightEdgeColorAccum = typegpu_default.fn([
 					[5, "131"]
 				]
 			],
-			[
-				13,
-				"beat",
-				[
-					6,
-					"lightEdgeBeat",
-					["animTime"]
-				]
-			],
 			[
 				13,
 				"intensityEff",
@@ -1508,7 +1488,6 @@ const lightEdgeColorAccum = typegpu_default.fn([
 		]]
 	},
 	externals: {
-		"lightEdgeBeat": () => lightEdgeBeat,
 		"d.f32": () => f32,
 		"std.select": () => select,
 		"noise.hash22": () => hash22,
@@ -1523,16 +1502,16 @@ const lightEdgeColorAccum = typegpu_default.fn([
 		"std.smoothstep": () => smoothstep
 	}
 }) && $.f)({}));
-const LightEdgeAccum = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+const EdgeGlowAccum = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
 	rgb: vec3f,
 	w: f32,
 	ba: f32,
 	ac: vec3f,
 	aa: f32
-}), "LightEdgeAccum");
-const lightEdgeAccumZero = typegpu_default.fn([], LightEdgeAccum)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = (() => {
+}), "EdgeGlowAccum");
+const edgeGlowAccumZero = typegpu_default.fn([], EdgeGlowAccum)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = (() => {
 	"use gpu";
-	return LightEdgeAccum({
+	return EdgeGlowAccum({
 		rgb: vec3f(0, 0, 0),
 		w: f32(0),
 		ba: f32(0),
@@ -1546,7 +1525,7 @@ const lightEdgeAccumZero = typegpu_default.fn([], LightEdgeAccum)(/* @__PURE__ *
 		"params": [],
 		"body": [0, [[10, [
 			6,
-			"LightEdgeAccum",
+			"EdgeGlowAccum",
 			[[104, {
 				"rgb": [
 					6,
@@ -1585,7 +1564,7 @@ const lightEdgeAccumZero = typegpu_default.fn([], LightEdgeAccum)(/* @__PURE__ *
 		]]]]
 	},
 	externals: {
-		"LightEdgeAccum": () => LightEdgeAccum,
+		"EdgeGlowAccum": () => EdgeGlowAccum,
 		"d.vec3f": () => vec3f,
 		"d.f32": () => f32
 	}
@@ -1594,10 +1573,10 @@ var accumFnByMode = /* @__PURE__ */ new Map();
 function makeAccumFn(mode) {
 	const variant = mixColorsVariants[mode] ?? mixColorsLinear;
 	return typegpu_default.fn([
-		LightEdgeAccum,
+		EdgeGlowAccum,
 		vec4f,
 		vec2f
-	], LightEdgeAccum)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st, color, sectors) => {
+	], EdgeGlowAccum)(/* @__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, max(__tsover_add(st.w, wNew), 1e-5));
@@ -1605,7 +1584,7 @@ function makeAccumFn(mode) {
 		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({
+		return EdgeGlowAccum({
 			rgb: mixed.xyz,
 			w: __tsover_add(st.w, wNew),
 			ba,
@@ -1800,7 +1779,7 @@ function makeAccumFn(mode) {
 				],
 				[10, [
 					6,
-					"LightEdgeAccum",
+					"EdgeGlowAccum",
 					[[104, {
 						"rgb": [
 							7,
@@ -1828,11 +1807,11 @@ function makeAccumFn(mode) {
 			"std.max": () => max,
 			"variant": () => variant,
 			"d.vec4f": () => vec4f,
-			"LightEdgeAccum": () => LightEdgeAccum
+			"EdgeGlowAccum": () => EdgeGlowAccum
 		}
-	}) && $.f)({})).$name(`lightEdgeAccumColor_${mode}`);
+	}) && $.f)({})).$name(`edgeGlowAccumColor_${mode}`);
 }
-function lightEdgeAccumColorFor(mode) {
+function edgeGlowAccumColorFor(mode) {
 	let fn = accumFnByMode.get(mode);
 	if (!fn) {
 		fn = makeAccumFn(mode);
@@ -1840,7 +1819,7 @@ function lightEdgeAccumColorFor(mode) {
 	}
 	return fn;
 }
-const lightEdgePickColor = typegpu_default.fn([arrayOf(vec4f, 8), f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colors, idx) => {
+const colorAtIndex = typegpu_default.fn([arrayOf(vec4f, 8), f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((colors, idx) => {
 	"use gpu";
 	const c = colors[i32(idx)];
 	return vec4f(c.x, c.y, c.z, c.w);
@@ -1899,7 +1878,7 @@ const lightEdgePickColor = typegpu_default.fn([arrayOf(vec4f, 8), f32], vec4f)(/
 		"d.vec4f": () => vec4f
 	}
 }) && $.f)({}));
-const lightEdgeCompose = typegpu_default.fn([LightEdgeAccum, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st, bloom) => {
+const edgeGlowCompose = typegpu_default.fn([EdgeGlowAccum, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((st, bloom) => {
 	"use gpu";
 	const k = __tsover_mul(bloom, 4);
 	const accumC = mix(st.rgb.mul(st.ba), st.ac, vec3f(k));
@@ -2046,16 +2025,80 @@ const lightEdgeCompose = typegpu_default.fn([LightEdgeAccum, f32], vec4f)(/* @__
 		"d.vec4f": () => vec4f
 	}
 }) && $.f)({}));
-const componentDefinition = {
+var DEFAULT_SHAPE_CONFIG = JSON.stringify({
+	type: "circleSDF",
+	radius: .35
+});
+var DEFAULT_STOPS = [
+	{
+		color: "#7b2ff7",
+		position: 0
+	},
+	{
+		color: "#00e0ff",
+		position: .5
+	},
+	{
+		color: "#ff3d81",
+		position: 1
+	}
+];
+const componentDefinition = defineStd({
 	name: "LightEdge",
+	role: "shapeEffect",
+	species: "custom",
 	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
-	},
+	...shapedSurface({
+		chord: "firstLobe",
+		stencil: "centre",
+		surface: (frame, params) => {
+			const { uniforms, propValues } = params;
+			const t = animatedTime(params);
+			const beat = asLocal(call(heartbeatPulse, "heartbeatPulse", [t]), "beat");
+			const bAndA = call(edgeGlowBand, "edgeGlowBand", [
+				frame.surf0.member("r"),
+				frame.sdfUV,
+				params.ctx.viewportSize,
+				uniforms.scale,
+				uniforms.thickness,
+				uniforms.softness,
+				uniforms.smokeSize,
+				uniforms.smoke,
+				t,
+				uniforms.pulse,
+				beat
+			]);
+			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 = edgeGlowAccumColorFor(propValues.colorSpace ?? 0);
+			const accumFor = (idx) => call(orbitSpotsAccum, "orbitSpotsAccum", [
+				angle01,
+				border,
+				t,
+				beat,
+				uniforms.spots,
+				uniforms.spotSize,
+				uniforms.pulse,
+				uniforms.intensity,
+				uniforms.softness,
+				uniforms.seed,
+				floatE(idx)
+			]);
+			const colorFor = (idx) => stopCount > 1 ? call(colorAtIndex, "colorAtIndex", [uniforms.colorsArray, floatE(idx)]) : idx === 0 ? uniforms.colorA : uniforms.colorB;
+			let state = call(edgeGlowAccumZero, "edgeGlowAccumZero", []);
+			for (let i = 0; i < colorCount; i++) state = call(accumColorFn, "edgeGlowAccumColor", [
+				state,
+				colorFor(i),
+				accumFor(i)
+			]);
+			return call(edgeGlowCompose, "edgeGlowCompose", [state, uniforms.bloom]);
+		}
+	}),
 	props: {
 		origin: {
 			default: "center",
@@ -2291,60 +2334,7 @@ const componentDefinition = {
 			compileTime: true,
 			description: "Active SDF shape type"
 		}
-	},
-	compute: (params) => {
-		return createVolumetricFieldComputeNode(params, () => params.getCpuValue("shape"), "none", "firstLobe");
-	},
-	fragment: (params) => {
-		const { uniforms, propValues, ctx } = params;
-		const { sampler } = resolveShapeFieldSampler(params);
-		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 };
+export { componentDefinition as n, LightEdge_default as t };

package/dist/core/LightLeak-oEDfnsq5.js

@@ -0,0 +1,154 @@
+import { it as asLocal, r as resolveArg, s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { t as animatedTime } from "./porters-B1UjrM1y.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CoIwF5JU.js";
+import { C as slowDrift, g as heatRamp, i as beamStreaks, n as beamBloom, r as beamFrame, s as dithered, x as screenGlow } from "./light-CJ3dY0iH.js";
+const componentDefinition = defineStd({
+	name: "LightLeak",
+	role: "filter",
+	species: "pointwise",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "Photorealistic film light leak — warm overexposed light bleeding in from a draggable anchor point, with streak bands, chromatic fringing, and slow breathing that evolves over time",
+	usesPointer: false,
+	animatedTime: { speed: "speed" },
+	props: {
+		position: {
+			default: {
+				x: .95,
+				y: .4
+			},
+			transform: transformPosition,
+			description: "Anchor point of the leak — the light beams from here toward the canvas centre",
+			ui: {
+				type: "position",
+				label: "Position",
+				group: "Leak",
+				units: ["%", "px"]
+			}
+		},
+		spread: {
+			default: .55,
+			description: "How far the light bleeds into the frame",
+			ui: {
+				type: ["range", "map"],
+				min: .1,
+				max: 1.5,
+				step: .01,
+				label: "Spread",
+				group: "Leak"
+			}
+		},
+		intensity: {
+			default: .15,
+			description: "Exposure strength of the leak",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Intensity",
+				group: "Leak"
+			}
+		},
+		streaks: {
+			default: .6,
+			description: "Strength of the parallel streak bands further into the frame",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Streaks",
+				group: "Leak"
+			}
+		},
+		colorHot: {
+			default: "#fff3c4",
+			transform: transformColor,
+			description: "Core color where the leak is fully overexposed",
+			ui: {
+				type: "color",
+				label: "Hot Core",
+				group: "Colors"
+			}
+		},
+		colorMid: {
+			default: "#ff7a2f",
+			transform: transformColor,
+			description: "Main body color of the leak",
+			ui: {
+				type: "color",
+				label: "Midtone",
+				group: "Colors"
+			}
+		},
+		colorFringe: {
+			default: "#a63d8f",
+			transform: transformColor,
+			description: "Outer fringe color where the light fades out",
+			ui: {
+				type: "color",
+				label: "Fringe",
+				group: "Colors"
+			}
+		},
+		flicker: {
+			default: .35,
+			description: "Breathing of the leak intensity",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Flicker",
+				group: "Animation"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Speed of the breathing, drift and evolution. 0 freezes the leak.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed — re-rolls the drift and breathing pattern",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Animation"
+			}
+		}
+	},
+	effect: screenGlow((params) => {
+		const t = asLocal(animatedTime(params).mul(.6).add(resolveArg(p("seed"), params).mul(7.9)), "leakClock");
+		const frame = asLocal(beamFrame(p("position"))(params), "leakFrame");
+		const drift = asLocal(slowDrift({
+			seed: p("seed"),
+			flicker: p("flicker")
+		})(t, params), "leakDrift");
+		const bloom = asLocal(beamBloom({ spread: p("spread") })(frame, drift, params), "leakBloom");
+		const streaks = beamStreaks({
+			spread: p("spread"),
+			strength: p("streaks")
+		})(frame, drift, params);
+		const heat = bloom.member("x").mul(1.25).add(bloom.member("y")).add(streaks.mul(.85)).mul(resolveArg(p("intensity"), params)).mul(2.2).mul(drift.member("x"));
+		return heatRamp({
+			hot: p("colorHot"),
+			mid: p("colorMid"),
+			fringe: p("colorFringe")
+		}).taps(dithered(heat, params.ctx.uv, t), params);
+	}),
+	missingChildMessage: "You must pass a child component into the Light Leak shader."
+});
+var LightLeak_default = componentDefinition;
+export { componentDefinition as n, LightLeak_default as t };