shaders 3.0.442 → 3.0.443

package/dist/core/TimeTrail-CPiSo5Of.js

@@ -0,0 +1,2847 @@
+import { Bt as call, J as std, Rt as ZERO, Wt as floatE, X as createGuardedCompute, bn as d, gn as rgbToHsl, in as colorMixing_exports, n as tgpu, on as hslToRgb, rn as unpremultiplyAlpha, tn as blendModes } from "./coords-0A7CojvN.js";
+import { a as transformColor } from "./transformations-P50Uo_Ju.js";
+var STATE_RES = 768;
+var STATE_FORMAT = "rgba16float";
+var DIFFUSE_TEXELS = 2.5;
+var DRIFT_SCALE = .5;
+var RAINBOW_RATE = .35;
+var TrailParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	persistence: d.f32,
+	diffusion: d.f32,
+	driftX: d.f32,
+	driftY: d.f32,
+	dt: d.f32,
+	zoom: d.f32,
+	hueRate: d.f32,
+	blendMode: d.f32,
+	motionMode: d.f32,
+	motionThreshold: d.f32
+}), "TrailParams");
+var trailLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	src: { texture: d.texture2d(d.f32) },
+	prev: { texture: d.texture2d(d.f32) },
+	next: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
+	display: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
+	prevLive: { texture: d.texture2d(d.f32) },
+	prevLiveOut: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
+	params: { uniform: TrailParams }
+}), "trailLayout");
+const timeTrailSampleHistory = tgpu.fn([d.f32, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uvx, uvy) => {
+	"use gpu";
+	const res = d.f32(STATE_RES);
+	const maxT = __tsover_sub(res, 1);
+	const su = __tsover_sub(__tsover_mul(std.clamp(uvx, d.f32(0), d.f32(1)), res), .5);
+	const sv = __tsover_sub(__tsover_mul(std.clamp(uvy, d.f32(0), d.f32(1)), res), .5);
+	const x0 = std.floor(su);
+	const y0 = std.floor(sv);
+	const fx = __tsover_sub(su, x0);
+	const fy = __tsover_sub(sv, y0);
+	const ix0 = d.u32(std.clamp(x0, d.f32(0), maxT));
+	const ix1 = d.u32(std.clamp(__tsover_add(x0, 1), d.f32(0), maxT));
+	const iy0 = d.u32(std.clamp(y0, d.f32(0), maxT));
+	const iy1 = d.u32(std.clamp(__tsover_add(y0, 1), d.f32(0), maxT));
+	const p00 = std.textureLoad(trailLayout.$.prev, d.vec2u(ix0, iy0), 0);
+	const p10 = std.textureLoad(trailLayout.$.prev, d.vec2u(ix1, iy0), 0);
+	const p01 = std.textureLoad(trailLayout.$.prev, d.vec2u(ix0, iy1), 0);
+	const p11 = std.textureLoad(trailLayout.$.prev, d.vec2u(ix1, iy1), 0);
+	return std.mix(std.mix(p00, p10, fx), std.mix(p01, p11, fx), fy);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "uvx"
+		}, {
+			"type": "i",
+			"name": "uvy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"res",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["STATE_RES"]
+				]
+			],
+			[
+				13,
+				"maxT",
+				[
+					1,
+					"res",
+					"-",
+					[5, "1"]
+				]
+			],
+			[
+				13,
+				"su",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"uvx",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "1"]]
+								]
+							]
+						],
+						"*",
+						"res"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"sv",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"uvy",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "1"]]
+								]
+							]
+						],
+						"*",
+						"res"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"x0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					["su"]
+				]
+			],
+			[
+				13,
+				"y0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					["sv"]
+				]
+			],
+			[
+				13,
+				"fx",
+				[
+					1,
+					"su",
+					"-",
+					"x0"
+				]
+			],
+			[
+				13,
+				"fy",
+				[
+					1,
+					"sv",
+					"-",
+					"y0"
+				]
+			],
+			[
+				13,
+				"ix0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							"x0",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							"maxT"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"ix1",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								"x0",
+								"+",
+								[5, "1"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							"maxT"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"iy0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							"y0",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							"maxT"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"iy1",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								"y0",
+								"+",
+								[5, "1"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							"maxT"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"p00",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"trailLayout",
+								"$"
+							],
+							"prev"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["ix0", "iy0"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"p10",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"trailLayout",
+								"$"
+							],
+							"prev"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["ix1", "iy0"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"p01",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"trailLayout",
+								"$"
+							],
+							"prev"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["ix0", "iy1"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"p11",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"trailLayout",
+								"$"
+							],
+							"prev"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["ix1", "iy1"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"mix"
+				],
+				[
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							"p00",
+							"p10",
+							"fx"
+						]
+					],
+					[
+						6,
+						[
+							7,
+							"std",
+							"mix"
+						],
+						[
+							"p01",
+							"p11",
+							"fx"
+						]
+					],
+					"fy"
+				]
+			]]
+		]],
+		"externalNames": [
+			"d",
+			"STATE_RES",
+			"std",
+			"trailLayout"
+		]
+	},
+	externals: () => ({
+		d,
+		STATE_RES,
+		std,
+		trailLayout
+	})
+}) && $.f)({}));
+const timeTrailMotionMask = tgpu.fn([
+	d.vec4f,
+	d.vec4f,
+	d.f32
+], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((live, prev, threshold) => {
+	"use gpu";
+	const dRgb = std.abs(live.xyz.sub(prev.xyz));
+	const dA = std.abs(__tsover_sub(live.w, prev.w));
+	const diff = __tsover_add(std.dot(dRgb, d.vec3f(.299, .587, .114)), dA);
+	return std.smoothstep(threshold, __tsover_add(__tsover_mul(threshold, 2), .001), diff);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "live"
+			},
+			{
+				"type": "i",
+				"name": "prev"
+			},
+			{
+				"type": "i",
+				"name": "threshold"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"dRgb",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								7,
+								"live",
+								"xyz"
+							],
+							"sub"
+						],
+						[[
+							7,
+							"prev",
+							"xyz"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"dA",
+				[
+					6,
+					[
+						7,
+						"std",
+						"abs"
+					],
+					[[
+						1,
+						[
+							7,
+							"live",
+							"w"
+						],
+						"-",
+						[
+							7,
+							"prev",
+							"w"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"diff",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"dot"
+						],
+						["dRgb", [
+							6,
+							[
+								7,
+								"d",
+								"vec3f"
+							],
+							[
+								[5, "0.299"],
+								[5, "0.587"],
+								[5, "0.114"]
+							]
+						]]
+					],
+					"+",
+					"dA"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"smoothstep"
+				],
+				[
+					"threshold",
+					[
+						1,
+						[
+							1,
+							"threshold",
+							"*",
+							[5, "2"]
+						],
+						"+",
+						[5, "0.001"]
+					],
+					"diff"
+				]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const timeTrailRotateHue = tgpu.fn([d.vec3f, d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, amount) => {
+	"use gpu";
+	const hsl = rgbToHsl(rgb);
+	return hslToRgb(d.vec3f(std.fract(__tsover_add(hsl.x, amount)), hsl.y, hsl.z));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rgb"
+		}, {
+			"type": "i",
+			"name": "amount"
+		}],
+		"body": [0, [
+			[
+				13,
+				"hsl",
+				[
+					6,
+					[
+						7,
+						"colorMixing",
+						"rgbToHsl"
+					],
+					["rgb"]
+				]
+			],
+			[
+				13,
+				"rotated",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec3f"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"fract"
+							],
+							[[
+								1,
+								[
+									7,
+									"hsl",
+									"x"
+								],
+								"+",
+								"amount"
+							]]
+						],
+						[
+							7,
+							"hsl",
+							"y"
+						],
+						[
+							7,
+							"hsl",
+							"z"
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"colorMixing",
+					"hslToRgb"
+				],
+				["rotated"]
+			]]
+		]],
+		"externalNames": [
+			"colorMixing",
+			"d",
+			"std"
+		]
+	},
+	externals: () => ({
+		colorMixing: colorMixing_exports,
+		d,
+		std
+	})
+}) && $.f)({}));
+const timeTrailKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const P = trailLayout.$.params;
+	const res = d.f32(STATE_RES);
+	const fx = __tsover_div(__tsover_add(d.f32(cx), .5), res);
+	const fy = __tsover_div(__tsover_add(d.f32(cy), .5), res);
+	const zoom = std.max(P.zoom, .01);
+	const bx = __tsover_sub(__tsover_add(__tsover_div(__tsover_sub(fx, .5), zoom), .5), __tsover_mul(__tsover_mul(P.driftX, P.dt), DRIFT_SCALE));
+	const by = __tsover_sub(__tsover_add(__tsover_div(__tsover_sub(fy, .5), zoom), .5), __tsover_mul(__tsover_mul(P.driftY, P.dt), DRIFT_SCALE));
+	const o = __tsover_mul(P.diffusion, __tsover_div(DIFFUSE_TEXELS, res));
+	const c = timeTrailSampleHistory(bx, by).mul(4);
+	const edgesSum = timeTrailSampleHistory(__tsover_sub(bx, o), by).add(timeTrailSampleHistory(__tsover_add(bx, o), by)).add(timeTrailSampleHistory(bx, __tsover_sub(by, o))).add(timeTrailSampleHistory(bx, __tsover_add(by, o))).mul(2);
+	const cornersSum = timeTrailSampleHistory(__tsover_sub(bx, o), __tsover_sub(by, o)).add(timeTrailSampleHistory(__tsover_add(bx, o), __tsover_sub(by, o))).add(timeTrailSampleHistory(__tsover_sub(bx, o), __tsover_add(by, o))).add(timeTrailSampleHistory(__tsover_add(bx, o), __tsover_add(by, o)));
+	const decayed = c.add(edgesSum).add(cornersSum).div(16).mul(P.persistence);
+	const a = std.max(decayed.w, 1e-4);
+	const rotated = timeTrailRotateHue(decayed.xyz.div(a), P.hueRate).mul(decayed.w);
+	const trail = d.vec4f(std.select(decayed.xyz, rotated, std.abs(P.hueRate) > 1e-4), decayed.w);
+	const srcDims = std.textureDimensions(trailLayout.$.src);
+	const srcW = d.f32(srcDims.x);
+	const srcH = d.f32(srcDims.y);
+	const cu = __tsover_sub(__tsover_mul(fx, srcW), .5);
+	const cv = __tsover_sub(__tsover_mul(fy, srcH), .5);
+	const cx0 = std.floor(cu);
+	const cy0 = std.floor(cv);
+	const cfx = __tsover_sub(cu, cx0);
+	const cfy = __tsover_sub(cv, cy0);
+	const jx0 = d.u32(std.clamp(cx0, d.f32(0), __tsover_sub(srcW, 1)));
+	const jx1 = d.u32(std.clamp(__tsover_add(cx0, 1), d.f32(0), __tsover_sub(srcW, 1)));
+	const jy0 = d.u32(std.clamp(cy0, d.f32(0), __tsover_sub(srcH, 1)));
+	const jy1 = d.u32(std.clamp(__tsover_add(cy0, 1), d.f32(0), __tsover_sub(srcH, 1)));
+	const s00 = std.textureLoad(trailLayout.$.src, d.vec2u(jx0, jy0), 0);
+	const s10 = std.textureLoad(trailLayout.$.src, d.vec2u(jx1, jy0), 0);
+	const s01 = std.textureLoad(trailLayout.$.src, d.vec2u(jx0, jy1), 0);
+	const s11 = std.textureLoad(trailLayout.$.src, d.vec2u(jx1, jy1), 0);
+	const live = std.mix(std.mix(s00, s10, cfx), std.mix(s01, s11, cfx), cfy);
+	const mMotion = timeTrailMotionMask(live, std.textureLoad(trailLayout.$.prevLive, d.vec2u(cx, cy), 0), P.motionThreshold);
+	const m = std.select(d.f32(1), mMotion, P.motionMode > .5);
+	const stamp = d.vec4f(live.xyz.mul(m), __tsover_mul(live.w, m));
+	const outA = __tsover_add(stamp.w, __tsover_mul(trail.w, __tsover_sub(1, stamp.w)));
+	const rgbNormal = stamp.xyz.add(trail.xyz.mul(__tsover_sub(1, stamp.w)));
+	const rgbScreen = stamp.xyz.add(trail.xyz).sub(stamp.xyz.mul(trail.xyz));
+	const rgbAdd = stamp.xyz.add(trail.xyz);
+	const rgbSN = std.select(rgbNormal, rgbScreen, P.blendMode > .5);
+	const rgb = std.select(rgbSN, rgbAdd, P.blendMode > 1.5);
+	const outC = d.vec4f(rgb, outA);
+	const disp = std.select(outC, trail, P.motionMode > .5);
+	std.textureStore(trailLayout.$.next, d.vec2u(cx, cy), outC);
+	std.textureStore(trailLayout.$.display, d.vec2u(cx, cy), disp);
+	std.textureStore(trailLayout.$.prevLiveOut, d.vec2u(cx, cy), live);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"P",
+				[
+					7,
+					[
+						7,
+						"trailLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"res",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["STATE_RES"]
+				]
+			],
+			[
+				13,
+				"fx",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cx"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"res"
+				]
+			],
+			[
+				13,
+				"fy",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["cy"]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"res"
+				]
+			],
+			[
+				13,
+				"zoom",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						7,
+						"P",
+						"zoom"
+					], [5, "0.01"]]
+				]
+			],
+			[
+				13,
+				"bx",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"fx",
+								"-",
+								[5, "0.5"]
+							],
+							"/",
+							"zoom"
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"-",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"P",
+								"driftX"
+							],
+							"*",
+							[
+								7,
+								"P",
+								"dt"
+							]
+						],
+						"*",
+						"DRIFT_SCALE"
+					]
+				]
+			],
+			[
+				13,
+				"by",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"fy",
+								"-",
+								[5, "0.5"]
+							],
+							"/",
+							"zoom"
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"-",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"P",
+								"driftY"
+							],
+							"*",
+							[
+								7,
+								"P",
+								"dt"
+							]
+						],
+						"*",
+						"DRIFT_SCALE"
+					]
+				]
+			],
+			[
+				13,
+				"o",
+				[
+					1,
+					[
+						7,
+						"P",
+						"diffusion"
+					],
+					"*",
+					[
+						1,
+						"DIFFUSE_TEXELS",
+						"/",
+						"res"
+					]
+				]
+			],
+			[
+				13,
+				"c",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							"timeTrailSampleHistory",
+							["bx", "by"]
+						],
+						"mul"
+					],
+					[[5, "4"]]
+				]
+			],
+			[
+				13,
+				"edgesSum",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										[
+											6,
+											[
+												7,
+												[
+													6,
+													"timeTrailSampleHistory",
+													[[
+														1,
+														"bx",
+														"-",
+														"o"
+													], "by"]
+												],
+												"add"
+											],
+											[[
+												6,
+												"timeTrailSampleHistory",
+												[[
+													1,
+													"bx",
+													"+",
+													"o"
+												], "by"]
+											]]
+										],
+										"add"
+									],
+									[[
+										6,
+										"timeTrailSampleHistory",
+										["bx", [
+											1,
+											"by",
+											"-",
+											"o"
+										]]
+									]]
+								],
+								"add"
+							],
+							[[
+								6,
+								"timeTrailSampleHistory",
+								["bx", [
+									1,
+									"by",
+									"+",
+									"o"
+								]]
+							]]
+						],
+						"mul"
+					],
+					[[5, "2"]]
+				]
+			],
+			[
+				13,
+				"cornersSum",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										[
+											6,
+											"timeTrailSampleHistory",
+											[[
+												1,
+												"bx",
+												"-",
+												"o"
+											], [
+												1,
+												"by",
+												"-",
+												"o"
+											]]
+										],
+										"add"
+									],
+									[[
+										6,
+										"timeTrailSampleHistory",
+										[[
+											1,
+											"bx",
+											"+",
+											"o"
+										], [
+											1,
+											"by",
+											"-",
+											"o"
+										]]
+									]]
+								],
+								"add"
+							],
+							[[
+								6,
+								"timeTrailSampleHistory",
+								[[
+									1,
+									"bx",
+									"-",
+									"o"
+								], [
+									1,
+									"by",
+									"+",
+									"o"
+								]]
+							]]
+						],
+						"add"
+					],
+					[[
+						6,
+						"timeTrailSampleHistory",
+						[[
+							1,
+							"bx",
+							"+",
+							"o"
+						], [
+							1,
+							"by",
+							"+",
+							"o"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"blurred",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"c",
+										"add"
+									],
+									["edgesSum"]
+								],
+								"add"
+							],
+							["cornersSum"]
+						],
+						"div"
+					],
+					[[5, "16"]]
+				]
+			],
+			[
+				13,
+				"decayed",
+				[
+					6,
+					[
+						7,
+						"blurred",
+						"mul"
+					],
+					[[
+						7,
+						"P",
+						"persistence"
+					]]
+				]
+			],
+			[
+				13,
+				"a",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						7,
+						"decayed",
+						"w"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"straight",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"decayed",
+							"xyz"
+						],
+						"div"
+					],
+					["a"]
+				]
+			],
+			[
+				13,
+				"rotated",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							"timeTrailRotateHue",
+							["straight", [
+								7,
+								"P",
+								"hueRate"
+							]]
+						],
+						"mul"
+					],
+					[[
+						7,
+						"decayed",
+						"w"
+					]]
+				]
+			],
+			[
+				13,
+				"trail",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							[
+								7,
+								"decayed",
+								"xyz"
+							],
+							"rotated",
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"std",
+										"abs"
+									],
+									[[
+										7,
+										"P",
+										"hueRate"
+									]]
+								],
+								">",
+								[5, "0.0001"]
+							]
+						]
+					], [
+						7,
+						"decayed",
+						"w"
+					]]
+				]
+			],
+			[
+				13,
+				"srcDims",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureDimensions"
+					],
+					[[
+						7,
+						[
+							7,
+							"trailLayout",
+							"$"
+						],
+						"src"
+					]]
+				]
+			],
+			[
+				13,
+				"srcW",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[
+						7,
+						"srcDims",
+						"x"
+					]]
+				]
+			],
+			[
+				13,
+				"srcH",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[
+						7,
+						"srcDims",
+						"y"
+					]]
+				]
+			],
+			[
+				13,
+				"cu",
+				[
+					1,
+					[
+						1,
+						"fx",
+						"*",
+						"srcW"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"cv",
+				[
+					1,
+					[
+						1,
+						"fy",
+						"*",
+						"srcH"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"cx0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					["cu"]
+				]
+			],
+			[
+				13,
+				"cy0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					["cv"]
+				]
+			],
+			[
+				13,
+				"cfx",
+				[
+					1,
+					"cu",
+					"-",
+					"cx0"
+				]
+			],
+			[
+				13,
+				"cfy",
+				[
+					1,
+					"cv",
+					"-",
+					"cy0"
+				]
+			],
+			[
+				13,
+				"jx0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							"cx0",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							[
+								1,
+								"srcW",
+								"-",
+								[5, "1"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"jx1",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								"cx0",
+								"+",
+								[5, "1"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							[
+								1,
+								"srcW",
+								"-",
+								[5, "1"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"jy0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							"cy0",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							[
+								1,
+								"srcH",
+								"-",
+								[5, "1"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"jy1",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								"cy0",
+								"+",
+								[5, "1"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							[
+								1,
+								"srcH",
+								"-",
+								[5, "1"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"s00",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"trailLayout",
+								"$"
+							],
+							"src"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["jx0", "jy0"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"s10",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"trailLayout",
+								"$"
+							],
+							"src"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["jx1", "jy0"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"s01",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"trailLayout",
+								"$"
+							],
+							"src"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["jx0", "jy1"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"s11",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"trailLayout",
+								"$"
+							],
+							"src"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["jx1", "jy1"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"live",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								"s00",
+								"s10",
+								"cfx"
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								"s01",
+								"s11",
+								"cfx"
+							]
+						],
+						"cfy"
+					]
+				]
+			],
+			[
+				13,
+				"pl",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"trailLayout",
+								"$"
+							],
+							"prevLive"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["cx", "cy"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"mMotion",
+				[
+					6,
+					"timeTrailMotionMask",
+					[
+						"live",
+						"pl",
+						[
+							7,
+							"P",
+							"motionThreshold"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"m",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "1"]]
+						],
+						"mMotion",
+						[
+							1,
+							[
+								7,
+								"P",
+								"motionMode"
+							],
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"stamp",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								7,
+								"live",
+								"xyz"
+							],
+							"mul"
+						],
+						["m"]
+					], [
+						1,
+						[
+							7,
+							"live",
+							"w"
+						],
+						"*",
+						"m"
+					]]
+				]
+			],
+			[
+				13,
+				"outA",
+				[
+					1,
+					[
+						7,
+						"stamp",
+						"w"
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"trail",
+							"w"
+						],
+						"*",
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								7,
+								"stamp",
+								"w"
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"rgbNormal",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"stamp",
+							"xyz"
+						],
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								7,
+								"trail",
+								"xyz"
+							],
+							"mul"
+						],
+						[[
+							1,
+							[5, "1"],
+							"-",
+							[
+								7,
+								"stamp",
+								"w"
+							]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"rgbScreen",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									7,
+									"stamp",
+									"xyz"
+								],
+								"add"
+							],
+							[[
+								7,
+								"trail",
+								"xyz"
+							]]
+						],
+						"sub"
+					],
+					[[
+						6,
+						[
+							7,
+							[
+								7,
+								"stamp",
+								"xyz"
+							],
+							"mul"
+						],
+						[[
+							7,
+							"trail",
+							"xyz"
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"rgbAdd",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"stamp",
+							"xyz"
+						],
+						"add"
+					],
+					[[
+						7,
+						"trail",
+						"xyz"
+					]]
+				]
+			],
+			[
+				13,
+				"rgbSN",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"rgbNormal",
+						"rgbScreen",
+						[
+							1,
+							[
+								7,
+								"P",
+								"blendMode"
+							],
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"rgb",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"rgbSN",
+						"rgbAdd",
+						[
+							1,
+							[
+								7,
+								"P",
+								"blendMode"
+							],
+							">",
+							[5, "1.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"outC",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					["rgb", "outA"]
+				]
+			],
+			[
+				13,
+				"disp",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"outC",
+						"trail",
+						[
+							1,
+							[
+								7,
+								"P",
+								"motionMode"
+							],
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"textureStore"
+				],
+				[
+					[
+						7,
+						[
+							7,
+							"trailLayout",
+							"$"
+						],
+						"next"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2u"
+						],
+						["cx", "cy"]
+					],
+					"outC"
+				]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"textureStore"
+				],
+				[
+					[
+						7,
+						[
+							7,
+							"trailLayout",
+							"$"
+						],
+						"display"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2u"
+						],
+						["cx", "cy"]
+					],
+					"disp"
+				]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"textureStore"
+				],
+				[
+					[
+						7,
+						[
+							7,
+							"trailLayout",
+							"$"
+						],
+						"prevLiveOut"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2u"
+						],
+						["cx", "cy"]
+					],
+					"live"
+				]
+			]
+		]],
+		"externalNames": [
+			"trailLayout",
+			"d",
+			"STATE_RES",
+			"std",
+			"DRIFT_SCALE",
+			"DIFFUSE_TEXELS",
+			"timeTrailSampleHistory",
+			"timeTrailRotateHue",
+			"timeTrailMotionMask"
+		]
+	},
+	externals: () => ({
+		trailLayout,
+		d,
+		STATE_RES,
+		std,
+		DRIFT_SCALE,
+		DIFFUSE_TEXELS,
+		timeTrailSampleHistory,
+		timeTrailRotateHue,
+		timeTrailMotionMask
+	})
+}) && $.f)({})).$name("timeTrailStep");
+const timeTrailColorize = tgpu.fn([d.vec4f, d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((trail, tint) => {
+	"use gpu";
+	const a = std.max(trail.w, 1e-4);
+	const straight = trail.xyz.div(a);
+	const lum = std.dot(straight, d.vec3f(.299, .587, .114));
+	const colored = tint.xyz.mul(__tsover_mul(lum, 1.5));
+	return d.vec4f(colored.mul(trail.w), trail.w);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "trail"
+		}, {
+			"type": "i",
+			"name": "tint"
+		}],
+		"body": [0, [
+			[
+				13,
+				"a",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						7,
+						"trail",
+						"w"
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"straight",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"trail",
+							"xyz"
+						],
+						"div"
+					],
+					["a"]
+				]
+			],
+			[
+				13,
+				"lum",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["straight", [
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[5, "0.299"],
+							[5, "0.587"],
+							[5, "0.114"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"colored",
+				[
+					6,
+					[
+						7,
+						[
+							7,
+							"tint",
+							"xyz"
+						],
+						"mul"
+					],
+					[[
+						1,
+						"lum",
+						"*",
+						[5, "1.5"]
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[[
+					6,
+					[
+						7,
+						"colored",
+						"mul"
+					],
+					[[
+						7,
+						"trail",
+						"w"
+					]]
+				], [
+					7,
+					"trail",
+					"w"
+				]]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const timeTrailScaleTrail = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((trail, k) => {
+	"use gpu";
+	return trail.mul(k);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "trail"
+		}, {
+			"type": "i",
+			"name": "k"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"trail",
+				"mul"
+			],
+			["k"]
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+var TINT_MODES = {
+	none: 0,
+	color: 1,
+	rainbow: 2
+};
+var SOURCE_MODES = {
+	motion: 1,
+	alpha: 0
+};
+var resolveBlendKey = (v) => {
+	const key = v === "add" ? "linearDodge" : String(v ?? "normal");
+	return key in blendModes ? key : "normal";
+};
+var stampModeFor = (key) => key === "screen" ? 1 : key === "linearDodge" ? 2 : 0;
+const componentDefinition = {
+	name: "TimeTrail",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "An Echo-style temporal trail — whatever moves sheds a smooth, decaying long-exposure ghost trail (frame-difference Motion mode works on opaque images and video; Alpha mode trails a shape's coverage), with optional zoom-feedback tunnels and rainbow light-painting",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		trailSource: {
+			default: "motion",
+			description: "What sheds the trail — Motion trails whatever changes frame-to-frame (works on opaque images and video), Alpha trails the child's transparency coverage (best for a clean shape over empty canvas)",
+			compileTime: true,
+			transform: (v) => SOURCE_MODES[v] ?? 1,
+			ui: {
+				type: "select",
+				options: [{
+					label: "Motion",
+					value: "motion"
+				}, {
+					label: "Alpha",
+					value: "alpha"
+				}],
+				label: "Source",
+				group: "Trail"
+			}
+		},
+		motionThreshold: {
+			default: .06,
+			description: "How much a pixel must change between frames to shed a trail (Motion source only) — lower catches subtle movement, higher only fast motion",
+			ui: {
+				type: ["range", "map"],
+				min: .01,
+				max: .5,
+				step: .01,
+				label: "Motion Threshold",
+				group: "Trail"
+			}
+		},
+		trailLength: {
+			default: .6,
+			description: "How long the trail lingers, in seconds — the time constant of the fade (the star control)",
+			ui: {
+				type: ["range", "map"],
+				min: .05,
+				max: 4,
+				step: .01,
+				label: "Trail Length",
+				group: "Trail"
+			}
+		},
+		diffusion: {
+			default: 1,
+			description: "How much the trail smears and softens as it fades — 0 keeps crisp ghost frames, higher melts them together",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Diffusion",
+				group: "Trail"
+			}
+		},
+		trailOpacity: {
+			default: 1,
+			description: "Overall strength of the trail behind the live frame",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Trail Opacity",
+				group: "Trail"
+			}
+		},
+		trailBlend: {
+			default: "normal",
+			description: "How the trail combines with the frame — Add / Screen build glowing light-painting trails, Multiply lays down dark ink ghosts, plus the full standard blend set",
+			compileTime: true,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Normal",
+						value: "normal"
+					},
+					{
+						label: "Add",
+						value: "add"
+					},
+					{
+						label: "Screen",
+						value: "screen"
+					},
+					{
+						label: "Multiply",
+						value: "multiply"
+					},
+					{
+						label: "Overlay",
+						value: "overlay"
+					},
+					{
+						label: "Soft Light",
+						value: "softLight"
+					},
+					{
+						label: "Hard Light",
+						value: "hardLight"
+					},
+					{
+						label: "Darken",
+						value: "darken"
+					},
+					{
+						label: "Lighten",
+						value: "lighten"
+					},
+					{
+						label: "Color Dodge",
+						value: "colorDodge"
+					},
+					{
+						label: "Color Burn",
+						value: "colorBurn"
+					},
+					{
+						label: "Linear Burn",
+						value: "linearBurn"
+					},
+					{
+						label: "Difference",
+						value: "difference"
+					},
+					{
+						label: "Exclusion",
+						value: "exclusion"
+					},
+					{
+						label: "Hue",
+						value: "hue"
+					},
+					{
+						label: "Saturation",
+						value: "saturation"
+					},
+					{
+						label: "Color",
+						value: "color"
+					},
+					{
+						label: "Luminosity",
+						value: "luminosity"
+					}
+				],
+				label: "Blend",
+				group: "Trail"
+			}
+		},
+		driftX: {
+			default: 0,
+			description: "Sideways drift of the trail per second — smears the trail in a direction",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Drift X",
+				group: "Feedback"
+			}
+		},
+		driftY: {
+			default: 0,
+			description: "Vertical drift of the trail per second",
+			ui: {
+				type: ["range", "map"],
+				min: -1,
+				max: 1,
+				step: .01,
+				label: "Drift Y",
+				group: "Feedback"
+			}
+		},
+		zoom: {
+			default: 1,
+			description: "Per-frame zoom of the trail around the centre — above 1 pulls the trail into an outward tunnel, below 1 sucks it inward",
+			ui: {
+				type: ["range", "map"],
+				min: .9,
+				max: 1.1,
+				step: .001,
+				label: "Zoom",
+				group: "Feedback"
+			}
+		},
+		tintMode: {
+			default: "none",
+			description: "Colour the trail — Color tints it a single hue, Rainbow cycles hue as the trail ages",
+			compileTime: true,
+			transform: (v) => TINT_MODES[v] ?? 0,
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "None",
+						value: "none"
+					},
+					{
+						label: "Color",
+						value: "color"
+					},
+					{
+						label: "Rainbow",
+						value: "rainbow"
+					}
+				],
+				label: "Tint Mode",
+				group: "Color"
+			}
+		},
+		tint: {
+			default: "#33aaff",
+			transform: transformColor,
+			description: "Trail tint colour (used in Color mode)",
+			ui: {
+				type: "color",
+				label: "Tint",
+				group: "Color"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Simulation speed. 0 freezes the trail in place.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		}
+	},
+	compute: (params) => {
+		const { childNode, gpu, registerComputeTexture, convertToTexture, getCpuValue, propValues, onCleanup } = params;
+		if (!childNode) return null;
+		const root = gpu?.root;
+		if (!root) return null;
+		const childTexture = convertToTexture(childNode);
+		const stateA = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [STATE_RES, STATE_RES],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "stateA");
+		const stateB = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [STATE_RES, STATE_RES],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "stateB");
+		const displayTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [STATE_RES, STATE_RES],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "displayTex");
+		const prevLiveA = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [STATE_RES, STATE_RES],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "prevLiveA");
+		const prevLiveB = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [STATE_RES, STATE_RES],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "prevLiveB");
+		onCleanup(() => {
+			stateA.destroy();
+			stateB.destroy();
+			displayTex.destroy();
+			prevLiveA.destroy();
+			prevLiveB.destroy();
+		});
+		const display = registerComputeTexture(displayTex);
+		const paramsBuf = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(TrailParams), "paramsBuf");
+		const pipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			timeTrailKernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"timeTrailKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["timeTrailKernel"]
+			},
+			externals: () => ({ timeTrailKernel })
+		}) && $.f)({}), { size: [STATE_RES, STATE_RES] });
+		const tintMode = Number(propValues.tintMode) || 0;
+		const blendMode = stampModeFor(resolveBlendKey(propValues.trailBlend));
+		const sourceMode = propValues.trailSource == null ? 1 : Number(propValues.trailSource);
+		let bgAB = null;
+		let bgBA = null;
+		let direction = 0;
+		return {
+			outputs: {
+				childTexture,
+				display
+			},
+			bindInputs: (resolve) => {
+				const src = resolve(childTexture.key);
+				if (!src) return;
+				bgAB = root.createBindGroup(trailLayout, {
+					src: src.texture,
+					prev: stateA,
+					next: stateB,
+					display: displayTex,
+					prevLive: prevLiveA,
+					prevLiveOut: prevLiveB,
+					params: paramsBuf.buffer
+				});
+				bgBA = root.createBindGroup(trailLayout, {
+					src: src.texture,
+					prev: stateB,
+					next: stateA,
+					display: displayTex,
+					prevLive: prevLiveB,
+					prevLiveOut: prevLiveA,
+					params: paramsBuf.buffer
+				});
+			},
+			getComputeNodes: (frameParams) => {
+				if (!bgAB || !bgBA) return null;
+				const fp = frameParams;
+				const speed = getCpuValue("speed") ?? 1;
+				const dt = Math.min(fp.deltaTime ?? .016, .05) * speed;
+				const trailLength = Math.max(getCpuValue("trailLength") ?? .6, .001);
+				paramsBuf.write({
+					persistence: Math.exp(-dt / trailLength),
+					diffusion: getCpuValue("diffusion") ?? .3,
+					driftX: getCpuValue("driftX") ?? 0,
+					driftY: getCpuValue("driftY") ?? 0,
+					dt,
+					zoom: getCpuValue("zoom") ?? 1,
+					hueRate: tintMode === 2 ? RAINBOW_RATE * dt : 0,
+					blendMode,
+					motionMode: sourceMode,
+					motionThreshold: getCpuValue("motionThreshold") ?? .06
+				});
+				const nodes = [pipeline.with(direction === 0 ? bgAB : bgBA)];
+				direction = 1 - direction;
+				return nodes;
+			}
+		};
+	},
+	fragment: ({ childNode, ctx, computeOutputs, uniforms, propValues, convertToTexture }) => {
+		if (!childNode) return ZERO;
+		const display = computeOutputs?.display;
+		const live = (computeOutputs?.childTexture ?? convertToTexture(childNode)).sample(ctx.uv);
+		if (!display) return call(unpremultiplyAlpha, "unpremultiplyAlpha", [live]);
+		const blendKey = resolveBlendKey(propValues.trailBlend);
+		const blendFn = blendModes[blendKey];
+		const tintMode = Number(propValues.tintMode) || 0;
+		const sourceMode = propValues.trailSource == null ? 1 : Number(propValues.trailSource);
+		let trail = display.sample(ctx.uv, "linearClamp");
+		if (tintMode === 1) trail = call(timeTrailColorize, "timeTrailColorize", [trail, uniforms.tint]);
+		const liveStraight = call(unpremultiplyAlpha, "unpremultiplyLive", [live]);
+		if (sourceMode === 1) {
+			const trailStraight$1 = call(unpremultiplyAlpha, "unpremultiplyTrail", [trail]);
+			return call(unpremultiplyAlpha, "unpremultiplyOut", [call(blendFn, `trailBlend_${blendKey}`, [
+				liveStraight,
+				trailStraight$1,
+				uniforms.trailOpacity
+			])]);
+		}
+		const trailStraight = call(unpremultiplyAlpha, "unpremultiplyTrail", [call(timeTrailScaleTrail, "timeTrailScaleTrail", [trail, uniforms.trailOpacity])]);
+		return call(unpremultiplyAlpha, "unpremultiplyOut", [call(blendFn, `trailBlend_${blendKey}`, [
+			trailStraight,
+			liveStraight,
+			floatE(1)
+		])]);
+	}
+};
+var TimeTrail_default = componentDefinition;
+export { timeTrailMotionMask as a, timeTrailScaleTrail as c, timeTrailKernel as i, componentDefinition as n, timeTrailRotateHue as o, timeTrailColorize as r, timeTrailSampleHistory as s, TimeTrail_default as t };