shaders 2.5.135 → 3.0.437

package/dist/core/DataMosh-BSYAol1u.js

@@ -0,0 +1,2647 @@
+import { At as call, B as createGuardedCompute, Ft as mixExpr, Ot as ZERO, R as std, Wt as unpremultiplyAlpha, n as tgpu, on as d } from "./coords-BlwgBpJf.js";
+var STATE_RES = 768;
+var STATE_FORMAT = "rgba16float";
+var MoshParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	time: d.f32,
+	dt: d.f32,
+	seed: d.f32,
+	intensity: d.f32,
+	blockSize: d.f32,
+	drift: d.f32,
+	churn: d.f32
+}), "MoshParams");
+var moshLayout = /* @__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") },
+	params: { uniform: MoshParams }
+}), "moshLayout");
+const moshHash = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x) => {
+	"use gpu";
+	return std.fract(__tsover_mul(std.sin(x), 43758.5453123));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "x"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"fract"
+			],
+			[[
+				1,
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					["x"]
+				],
+				"*",
+				[5, "43758.5453123"]
+			]]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std })
+}) && $.f)({}));
+const moshKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	"use gpu";
+	const P = moshLayout.$.params;
+	const res = d.f32(STATE_RES);
+	const px = d.f32(cx);
+	const py = d.f32(cy);
+	const fx = __tsover_div(__tsover_add(px, .5), res);
+	const fy = __tsover_div(__tsover_add(py, .5), res);
+	const churnRate = __tsover_add(.15, __tsover_mul(P.churn, .8));
+	const bsF = std.max(P.blockSize, 8);
+	const coarse = __tsover_mul(bsF, 2.6);
+	const cbx = std.floor(__tsover_div(px, coarse));
+	const cby = std.floor(__tsover_div(py, coarse));
+	const cPhase = moshHash(__tsover_add(__tsover_add(__tsover_mul(cbx, 91.17), __tsover_mul(cby, 41.23)), __tsover_mul(P.seed, 3.7)));
+	const cEpoch = std.floor(__tsover_add(__tsover_mul(__tsover_mul(P.time, churnRate), .25), cPhase));
+	const scalePick = moshHash(__tsover_add(__tsover_add(__tsover_add(__tsover_mul(cbx, 12.9898), __tsover_mul(cby, 78.233)), __tsover_mul(cEpoch, 37.71)), __tsover_mul(P.seed, 3.7)));
+	const bs = std.select(bsF, coarse, scalePick < .35);
+	const bx = std.floor(__tsover_div(px, bs));
+	const by = std.floor(__tsover_div(py, bs));
+	const bPhase = moshHash(__tsover_add(__tsover_add(__tsover_mul(bx, 127.1), __tsover_mul(by, 311.7)), __tsover_mul(P.seed, 17.9)));
+	const bRate = __tsover_mul(churnRate, __tsover_add(.7, __tsover_mul(.6, moshHash(__tsover_add(__tsover_add(__tsover_mul(bx, 53.7), __tsover_mul(by, 97.3)), __tsover_mul(P.seed, 5.3))))));
+	const bEpoch = std.floor(__tsover_add(__tsover_mul(P.time, bRate), bPhase));
+	const bh = __tsover_add(__tsover_add(__tsover_add(__tsover_mul(bx, 127.1), __tsover_mul(by, 311.7)), __tsover_mul(bEpoch, 74.7)), __tsover_mul(P.seed, 17.9));
+	const h1 = moshHash(__tsover_add(bh, .13));
+	const h2 = moshHash(__tsover_add(bh, 7.77));
+	const h3 = moshHash(__tsover_add(bh, 23.19));
+	const bcx = __tsover_div(__tsover_mul(__tsover_add(bx, .5), bs), res);
+	const bcy = __tsover_div(__tsover_mul(__tsover_add(by, .5), bs), res);
+	const field = __tsover_add(__tsover_add(.5, __tsover_mul(__tsover_mul(.25, std.sin(__tsover_add(__tsover_add(__tsover_mul(bcx, 2.7), __tsover_mul(P.time, .31)), P.seed))), std.sin(__tsover_add(__tsover_sub(__tsover_mul(bcy, 2.1), __tsover_mul(P.time, .23)), __tsover_mul(P.seed, .4))))), __tsover_mul(.25, std.sin(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(bcx, bcy), 1.6), __tsover_mul(P.time, .17)), __tsover_mul(P.seed, .7)))));
+	const thresh = __tsover_sub(1, __tsover_mul(P.intensity, .55));
+	const hold = std.smoothstep(__tsover_sub(thresh, .09), __tsover_add(thresh, .09), __tsover_add(field, __tsover_mul(__tsover_sub(h1, .5), .3)));
+	const flowAng = __tsover_add(__tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(bcx, 1.9), __tsover_mul(P.seed, 3.1))), 1.7), __tsover_mul(std.cos(__tsover_sub(__tsover_mul(bcy, 2.3), __tsover_mul(P.seed, 2.7))), 1.3)), __tsover_mul(P.time, .15));
+	const ang = __tsover_add(flowAng, __tsover_mul(__tsover_sub(h2, .5), 1.1));
+	const mag = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_add(.5, __tsover_mul(.5, h3)), P.drift), P.dt), 10), __tsover_div(bs, res));
+	const suRaw = __tsover_sub(fx, __tsover_mul(std.cos(ang), mag));
+	const svRaw = __tsover_sub(fy, __tsover_mul(std.sin(ang), mag));
+	const inBounds = __tsover_mul(__tsover_mul(__tsover_mul(std.select(d.f32(0), d.f32(1), suRaw >= 0), std.select(d.f32(0), d.f32(1), suRaw <= 1)), std.select(d.f32(0), d.f32(1), svRaw >= 0)), std.select(d.f32(0), d.f32(1), svRaw <= 1));
+	const su = __tsover_sub(__tsover_mul(std.clamp(suRaw, 0, 1), res), .5);
+	const sv = __tsover_sub(__tsover_mul(std.clamp(svRaw, 0, 1), res), .5);
+	const sx0 = std.floor(su);
+	const sy0 = std.floor(sv);
+	const sfx = __tsover_sub(su, sx0);
+	const sfy = __tsover_sub(sv, sy0);
+	const maxT = __tsover_sub(res, 1);
+	const ix0 = d.u32(std.clamp(sx0, d.f32(0), maxT));
+	const ix1 = d.u32(std.clamp(__tsover_add(sx0, 1), d.f32(0), maxT));
+	const iy0 = d.u32(std.clamp(sy0, d.f32(0), maxT));
+	const iy1 = d.u32(std.clamp(__tsover_add(sy0, 1), d.f32(0), maxT));
+	const p00 = std.textureLoad(moshLayout.$.prev, d.vec2u(ix0, iy0), 0);
+	const p10 = std.textureLoad(moshLayout.$.prev, d.vec2u(ix1, iy0), 0);
+	const p01 = std.textureLoad(moshLayout.$.prev, d.vec2u(ix0, iy1), 0);
+	const p11 = std.textureLoad(moshLayout.$.prev, d.vec2u(ix1, iy1), 0);
+	const prevC = std.mix(std.mix(p00, p10, sfx), std.mix(p01, p11, sfx), sfy);
+	const quant = std.floor(prevC.xyz.mul(18)).add(d.vec3f(.5, .5, .5)).div(18);
+	const heldRgb = std.mix(prevC.xyz, quant, .12).mul(.9985);
+	const held = d.vec4f(heldRgb, prevC.w);
+	const rekey = std.clamp(__tsover_mul(P.dt, __tsover_add(1.2, __tsover_mul(__tsover_sub(1, P.intensity), 2))), 0, .2);
+	const srcDims = std.textureDimensions(moshLayout.$.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 c00 = std.textureLoad(moshLayout.$.src, d.vec2u(jx0, jy0), 0);
+	const c10 = std.textureLoad(moshLayout.$.src, d.vec2u(jx1, jy0), 0);
+	const c01 = std.textureLoad(moshLayout.$.src, d.vec2u(jx0, jy1), 0);
+	const c11 = std.textureLoad(moshLayout.$.src, d.vec2u(jx1, jy1), 0);
+	const fresh = std.mix(std.mix(c00, c10, cfx), std.mix(c01, c11, cfx), cfy);
+	const heldAnchored = std.mix(held, fresh, rekey);
+	const outC = std.mix(fresh, heldAnchored, __tsover_mul(hold, inBounds));
+	std.textureStore(moshLayout.$.next, d.vec2u(cx, cy), outC);
+	std.textureStore(moshLayout.$.display, d.vec2u(cx, cy), outC);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "cx"
+		}, {
+			"type": "i",
+			"name": "cy"
+		}],
+		"body": [0, [
+			[
+				13,
+				"P",
+				[
+					7,
+					[
+						7,
+						"moshLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"res",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["STATE_RES"]
+				]
+			],
+			[
+				13,
+				"px",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["cx"]
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["cy"]
+				]
+			],
+			[
+				13,
+				"fx",
+				[
+					1,
+					[
+						1,
+						"px",
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"res"
+				]
+			],
+			[
+				13,
+				"fy",
+				[
+					1,
+					[
+						1,
+						"py",
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"res"
+				]
+			],
+			[
+				13,
+				"churnRate",
+				[
+					1,
+					[5, "0.15"],
+					"+",
+					[
+						1,
+						[
+							7,
+							"P",
+							"churn"
+						],
+						"*",
+						[5, "0.8"]
+					]
+				]
+			],
+			[
+				13,
+				"bsF",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						7,
+						"P",
+						"blockSize"
+					], [5, "8"]]
+				]
+			],
+			[
+				13,
+				"coarse",
+				[
+					1,
+					"bsF",
+					"*",
+					[5, "2.6"]
+				]
+			],
+			[
+				13,
+				"cbx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						"px",
+						"/",
+						"coarse"
+					]]
+				]
+			],
+			[
+				13,
+				"cby",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						"py",
+						"/",
+						"coarse"
+					]]
+				]
+			],
+			[
+				13,
+				"cPhase",
+				[
+					6,
+					"moshHash",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								"cbx",
+								"*",
+								[5, "91.17"]
+							],
+							"+",
+							[
+								1,
+								"cby",
+								"*",
+								[5, "41.23"]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"P",
+								"seed"
+							],
+							"*",
+							[5, "3.7"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"cEpoch",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"P",
+									"time"
+								],
+								"*",
+								"churnRate"
+							],
+							"*",
+							[5, "0.25"]
+						],
+						"+",
+						"cPhase"
+					]]
+				]
+			],
+			[
+				13,
+				"scalePick",
+				[
+					6,
+					"moshHash",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									"cbx",
+									"*",
+									[5, "12.9898"]
+								],
+								"+",
+								[
+									1,
+									"cby",
+									"*",
+									[5, "78.233"]
+								]
+							],
+							"+",
+							[
+								1,
+								"cEpoch",
+								"*",
+								[5, "37.71"]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"P",
+								"seed"
+							],
+							"*",
+							[5, "3.7"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"bs",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"bsF",
+						"coarse",
+						[
+							1,
+							"scalePick",
+							"<",
+							[5, "0.35"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"bx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						"px",
+						"/",
+						"bs"
+					]]
+				]
+			],
+			[
+				13,
+				"by",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						"py",
+						"/",
+						"bs"
+					]]
+				]
+			],
+			[
+				13,
+				"bPhase",
+				[
+					6,
+					"moshHash",
+					[[
+						1,
+						[
+							1,
+							[
+								1,
+								"bx",
+								"*",
+								[5, "127.1"]
+							],
+							"+",
+							[
+								1,
+								"by",
+								"*",
+								[5, "311.7"]
+							]
+						],
+						"+",
+						[
+							1,
+							[
+								7,
+								"P",
+								"seed"
+							],
+							"*",
+							[5, "17.9"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"bRate",
+				[
+					1,
+					"churnRate",
+					"*",
+					[
+						1,
+						[5, "0.7"],
+						"+",
+						[
+							1,
+							[5, "0.6"],
+							"*",
+							[
+								6,
+								"moshHash",
+								[[
+									1,
+									[
+										1,
+										[
+											1,
+											"bx",
+											"*",
+											[5, "53.7"]
+										],
+										"+",
+										[
+											1,
+											"by",
+											"*",
+											[5, "97.3"]
+										]
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											"P",
+											"seed"
+										],
+										"*",
+										[5, "5.3"]
+									]
+								]]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"bEpoch",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						[
+							1,
+							[
+								7,
+								"P",
+								"time"
+							],
+							"*",
+							"bRate"
+						],
+						"+",
+						"bPhase"
+					]]
+				]
+			],
+			[
+				13,
+				"bh",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"bx",
+								"*",
+								[5, "127.1"]
+							],
+							"+",
+							[
+								1,
+								"by",
+								"*",
+								[5, "311.7"]
+							]
+						],
+						"+",
+						[
+							1,
+							"bEpoch",
+							"*",
+							[5, "74.7"]
+						]
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"P",
+							"seed"
+						],
+						"*",
+						[5, "17.9"]
+					]
+				]
+			],
+			[
+				13,
+				"h1",
+				[
+					6,
+					"moshHash",
+					[[
+						1,
+						"bh",
+						"+",
+						[5, "0.13"]
+					]]
+				]
+			],
+			[
+				13,
+				"h2",
+				[
+					6,
+					"moshHash",
+					[[
+						1,
+						"bh",
+						"+",
+						[5, "7.77"]
+					]]
+				]
+			],
+			[
+				13,
+				"h3",
+				[
+					6,
+					"moshHash",
+					[[
+						1,
+						"bh",
+						"+",
+						[5, "23.19"]
+					]]
+				]
+			],
+			[
+				13,
+				"bcx",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"bx",
+							"+",
+							[5, "0.5"]
+						],
+						"*",
+						"bs"
+					],
+					"/",
+					"res"
+				]
+			],
+			[
+				13,
+				"bcy",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"by",
+							"+",
+							[5, "0.5"]
+						],
+						"*",
+						"bs"
+					],
+					"/",
+					"res"
+				]
+			],
+			[
+				13,
+				"field",
+				[
+					1,
+					[
+						1,
+						[5, "0.5"],
+						"+",
+						[
+							1,
+							[
+								1,
+								[5, "0.25"],
+								"*",
+								[
+									6,
+									[
+										7,
+										"std",
+										"sin"
+									],
+									[[
+										1,
+										[
+											1,
+											[
+												1,
+												"bcx",
+												"*",
+												[5, "2.7"]
+											],
+											"+",
+											[
+												1,
+												[
+													7,
+													"P",
+													"time"
+												],
+												"*",
+												[5, "0.31"]
+											]
+										],
+										"+",
+										[
+											7,
+											"P",
+											"seed"
+										]
+									]]
+								]
+							],
+							"*",
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										[
+											1,
+											"bcy",
+											"*",
+											[5, "2.1"]
+										],
+										"-",
+										[
+											1,
+											[
+												7,
+												"P",
+												"time"
+											],
+											"*",
+											[5, "0.23"]
+										]
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											"P",
+											"seed"
+										],
+										"*",
+										[5, "0.4"]
+									]
+								]]
+							]
+						]
+					],
+					"+",
+					[
+						1,
+						[5, "0.25"],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							[[
+								1,
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											"bcx",
+											"+",
+											"bcy"
+										],
+										"*",
+										[5, "1.6"]
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											"P",
+											"time"
+										],
+										"*",
+										[5, "0.17"]
+									]
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"P",
+										"seed"
+									],
+									"*",
+									[5, "0.7"]
+								]
+							]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"thresh",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						1,
+						[
+							7,
+							"P",
+							"intensity"
+						],
+						"*",
+						[5, "0.55"]
+					]
+				]
+			],
+			[
+				13,
+				"hold",
+				[
+					6,
+					[
+						7,
+						"std",
+						"smoothstep"
+					],
+					[
+						[
+							1,
+							"thresh",
+							"-",
+							[5, "0.09"]
+						],
+						[
+							1,
+							"thresh",
+							"+",
+							[5, "0.09"]
+						],
+						[
+							1,
+							"field",
+							"+",
+							[
+								1,
+								[
+									1,
+									"h1",
+									"-",
+									[5, "0.5"]
+								],
+								"*",
+								[5, "0.3"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"flowAng",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								[[
+									1,
+									[
+										1,
+										"bcx",
+										"*",
+										[5, "1.9"]
+									],
+									"+",
+									[
+										1,
+										[
+											7,
+											"P",
+											"seed"
+										],
+										"*",
+										[5, "3.1"]
+									]
+								]]
+							],
+							"*",
+							[5, "1.7"]
+						],
+						"+",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"cos"
+								],
+								[[
+									1,
+									[
+										1,
+										"bcy",
+										"*",
+										[5, "2.3"]
+									],
+									"-",
+									[
+										1,
+										[
+											7,
+											"P",
+											"seed"
+										],
+										"*",
+										[5, "2.7"]
+									]
+								]]
+							],
+							"*",
+							[5, "1.3"]
+						]
+					],
+					"+",
+					[
+						1,
+						[
+							7,
+							"P",
+							"time"
+						],
+						"*",
+						[5, "0.15"]
+					]
+				]
+			],
+			[
+				13,
+				"ang",
+				[
+					1,
+					"flowAng",
+					"+",
+					[
+						1,
+						[
+							1,
+							"h2",
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						[5, "1.1"]
+					]
+				]
+			],
+			[
+				13,
+				"mag",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								[
+									1,
+									[5, "0.5"],
+									"+",
+									[
+										1,
+										[5, "0.5"],
+										"*",
+										"h3"
+									]
+								],
+								"*",
+								[
+									7,
+									"P",
+									"drift"
+								]
+							],
+							"*",
+							[
+								7,
+								"P",
+								"dt"
+							]
+						],
+						"*",
+						[5, "10"]
+					],
+					"*",
+					[
+						1,
+						"bs",
+						"/",
+						"res"
+					]
+				]
+			],
+			[
+				13,
+				"suRaw",
+				[
+					1,
+					"fx",
+					"-",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							["ang"]
+						],
+						"*",
+						"mag"
+					]
+				]
+			],
+			[
+				13,
+				"svRaw",
+				[
+					1,
+					"fy",
+					"-",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							["ang"]
+						],
+						"*",
+						"mag"
+					]
+				]
+			],
+			[
+				13,
+				"inBounds",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"select"
+								],
+								[
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										[[5, "0"]]
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										[[5, "1"]]
+									],
+									[
+										1,
+										"suRaw",
+										">=",
+										[5, "0"]
+									]
+								]
+							],
+							"*",
+							[
+								6,
+								[
+									7,
+									"std",
+									"select"
+								],
+								[
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										[[5, "0"]]
+									],
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										[[5, "1"]]
+									],
+									[
+										1,
+										"suRaw",
+										"<=",
+										[5, "1"]
+									]
+								]
+							]
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"select"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "1"]]
+								],
+								[
+									1,
+									"svRaw",
+									">=",
+									[5, "0"]
+								]
+							]
+						]
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "1"]]
+							],
+							[
+								1,
+								"svRaw",
+								"<=",
+								[5, "1"]
+							]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"su",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"suRaw",
+								[5, "0"],
+								[5, "1"]
+							]
+						],
+						"*",
+						"res"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"sv",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"clamp"
+							],
+							[
+								"svRaw",
+								[5, "0"],
+								[5, "1"]
+							]
+						],
+						"*",
+						"res"
+					],
+					"-",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"sx0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					["su"]
+				]
+			],
+			[
+				13,
+				"sy0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					["sv"]
+				]
+			],
+			[
+				13,
+				"sfx",
+				[
+					1,
+					"su",
+					"-",
+					"sx0"
+				]
+			],
+			[
+				13,
+				"sfy",
+				[
+					1,
+					"sv",
+					"-",
+					"sy0"
+				]
+			],
+			[
+				13,
+				"maxT",
+				[
+					1,
+					"res",
+					"-",
+					[5, "1"]
+				]
+			],
+			[
+				13,
+				"ix0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							"sx0",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							"maxT"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"ix1",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								"sx0",
+								"+",
+								[5, "1"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							"maxT"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"iy0",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							"sy0",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							"maxT"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"iy1",
+				[
+					6,
+					[
+						7,
+						"d",
+						"u32"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								1,
+								"sy0",
+								"+",
+								[5, "1"]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								[[5, "0"]]
+							],
+							"maxT"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"p00",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"moshLayout",
+								"$"
+							],
+							"prev"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["ix0", "iy0"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"p10",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"moshLayout",
+								"$"
+							],
+							"prev"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["ix1", "iy0"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"p01",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"moshLayout",
+								"$"
+							],
+							"prev"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["ix0", "iy1"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"p11",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"moshLayout",
+								"$"
+							],
+							"prev"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["ix1", "iy1"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"prevC",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								"p00",
+								"p10",
+								"sfx"
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								"p01",
+								"p11",
+								"sfx"
+							]
+						],
+						"sfy"
+					]
+				]
+			],
+			[
+				13,
+				"quant",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"std",
+										"floor"
+									],
+									[[
+										6,
+										[
+											7,
+											[
+												7,
+												"prevC",
+												"xyz"
+											],
+											"mul"
+										],
+										[[5, "18"]]
+									]]
+								],
+								"add"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[5, "0.5"],
+									[5, "0.5"],
+									[5, "0.5"]
+								]
+							]]
+						],
+						"div"
+					],
+					[[5, "18"]]
+				]
+			],
+			[
+				13,
+				"heldRgb",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								[
+									7,
+									"prevC",
+									"xyz"
+								],
+								"quant",
+								[5, "0.12"]
+							]
+						],
+						"mul"
+					],
+					[[5, "0.9985"]]
+				]
+			],
+			[
+				13,
+				"held",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					["heldRgb", [
+						7,
+						"prevC",
+						"w"
+					]]
+				]
+			],
+			[
+				13,
+				"rekey",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								7,
+								"P",
+								"dt"
+							],
+							"*",
+							[
+								1,
+								[5, "1.2"],
+								"+",
+								[
+									1,
+									[
+										1,
+										[5, "1"],
+										"-",
+										[
+											7,
+											"P",
+											"intensity"
+										]
+									],
+									"*",
+									[5, "2"]
+								]
+							]
+						],
+						[5, "0"],
+						[5, "0.2"]
+					]
+				]
+			],
+			[
+				13,
+				"srcDims",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureDimensions"
+					],
+					[[
+						7,
+						[
+							7,
+							"moshLayout",
+							"$"
+						],
+						"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,
+				"c00",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"moshLayout",
+								"$"
+							],
+							"src"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["jx0", "jy0"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"c10",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"moshLayout",
+								"$"
+							],
+							"src"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["jx1", "jy0"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"c01",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"moshLayout",
+								"$"
+							],
+							"src"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["jx0", "jy1"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"c11",
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureLoad"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"moshLayout",
+								"$"
+							],
+							"src"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["jx1", "jy1"]
+						],
+						[5, "0"]
+					]
+				]
+			],
+			[
+				13,
+				"fresh",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								"c00",
+								"c10",
+								"cfx"
+							]
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"mix"
+							],
+							[
+								"c01",
+								"c11",
+								"cfx"
+							]
+						],
+						"cfy"
+					]
+				]
+			],
+			[
+				13,
+				"heldAnchored",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"held",
+						"fresh",
+						"rekey"
+					]
+				]
+			],
+			[
+				13,
+				"outC",
+				[
+					6,
+					[
+						7,
+						"std",
+						"mix"
+					],
+					[
+						"fresh",
+						"heldAnchored",
+						[
+							1,
+							"hold",
+							"*",
+							"inBounds"
+						]
+					]
+				]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"textureStore"
+				],
+				[
+					[
+						7,
+						[
+							7,
+							"moshLayout",
+							"$"
+						],
+						"next"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2u"
+						],
+						["cx", "cy"]
+					],
+					"outC"
+				]
+			],
+			[
+				6,
+				[
+					7,
+					"std",
+					"textureStore"
+				],
+				[
+					[
+						7,
+						[
+							7,
+							"moshLayout",
+							"$"
+						],
+						"display"
+					],
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2u"
+						],
+						["cx", "cy"]
+					],
+					"outC"
+				]
+			]
+		]],
+		"externalNames": [
+			"moshLayout",
+			"d",
+			"STATE_RES",
+			"std",
+			"moshHash"
+		]
+	},
+	externals: () => ({
+		moshLayout,
+		d,
+		STATE_RES,
+		std,
+		moshHash
+	})
+}) && $.f)({})).$name("dataMoshStep");
+const componentDefinition = {
+	name: "DataMosh",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "Corrupted-codec motion smearing — macroblocks lock in place and drag their pixels across the frame in liquid trails, each recovering on its own clock, like a video stream that lost its keyframes",
+	requiresRTT: true,
+	requiresChild: true,
+	props: {
+		intensity: {
+			default: .7,
+			description: "How much of the image locks and smears — the fraction of corrupted macroblocks",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Intensity",
+				group: "Mosh"
+			}
+		},
+		blockSize: {
+			default: 48,
+			description: "Macroblock size — the granularity of the corruption",
+			ui: {
+				type: "range",
+				min: 30,
+				max: 150,
+				step: 1,
+				label: "Block Size",
+				group: "Mosh"
+			}
+		},
+		drift: {
+			default: .35,
+			description: "Motion vector strength — how fast corrupted areas drag their pixels away",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Drift",
+				group: "Mosh"
+			}
+		},
+		churn: {
+			default: .4,
+			description: "How often each block re-rolls its fate — low values let corrupted regions melt for a long time before recovering",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Churn",
+				group: "Mosh"
+			}
+		},
+		blend: {
+			default: 1,
+			description: "Blend between the live image and the moshed stream",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Blend",
+				group: "Mosh"
+			}
+		},
+		speed: {
+			default: 1,
+			description: "Simulation speed. 0 freezes the decay in place.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 4,
+				step: .1,
+				label: "Speed",
+				group: "Animation"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for the corruption layout",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Animation"
+			}
+		}
+	},
+	compute: (params) => {
+		const { childNode, gpu, registerComputeTexture, convertToTexture, getCpuValue, 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");
+		onCleanup(() => {
+			stateA.destroy();
+			stateB.destroy();
+			displayTex.destroy();
+		});
+		const display = registerComputeTexture(displayTex);
+		const paramsBuf = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(MoshParams), "paramsBuf");
+		const pipeline = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+			"use gpu";
+			moshKernel(cx, cy);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "cx"
+				}, {
+					"type": "i",
+					"name": "cy"
+				}],
+				"body": [0, [[
+					6,
+					"moshKernel",
+					["cx", "cy"]
+				]]],
+				"externalNames": ["moshKernel"]
+			},
+			externals: () => ({ moshKernel })
+		}) && $.f)({}), { size: [STATE_RES, STATE_RES] });
+		let bgAB = null;
+		let bgBA = null;
+		let direction = 0;
+		let localTime = 0;
+		return {
+			outputs: {
+				childTexture,
+				display
+			},
+			bindInputs: (resolve) => {
+				const src = resolve(childTexture.key);
+				if (!src) return;
+				bgAB = root.createBindGroup(moshLayout, {
+					src: src.texture,
+					prev: stateA,
+					next: stateB,
+					display: displayTex,
+					params: paramsBuf.buffer
+				});
+				bgBA = root.createBindGroup(moshLayout, {
+					src: src.texture,
+					prev: stateB,
+					next: stateA,
+					display: displayTex,
+					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;
+				localTime += dt;
+				paramsBuf.write({
+					time: localTime,
+					dt,
+					seed: getCpuValue("seed") ?? 0,
+					intensity: getCpuValue("intensity") ?? .7,
+					blockSize: getCpuValue("blockSize") ?? 48,
+					drift: getCpuValue("drift") ?? .35,
+					churn: getCpuValue("churn") ?? .4
+				});
+				const nodes = [pipeline.with(direction === 0 ? bgAB : bgBA)];
+				direction = 1 - direction;
+				return nodes;
+			}
+		};
+	},
+	fragment: ({ childNode, ctx, computeOutputs, uniforms, 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]);
+		return call(unpremultiplyAlpha, "unpremultiplyAlpha", [mixExpr(live, display.sample(ctx.uv, "linearClamp"), uniforms.blend)]);
+	}
+};
+var DataMosh_default = componentDefinition;
+export { moshKernel as i, componentDefinition as n, moshHash as r, DataMosh_default as t };