shaders 3.1.462 → 3.2.464

package/dist/core/ParticleFlow-D5LhGlwp.js

@@ -1,3919 +0,0 @@
-import { Ft as vec3f, Gt as textureStorage2d, H as mixColorsLinear, Kt as arrayOf, Lt as vec4f, Mt as vec2f, Pt as vec2u, U as mixColorsVariants, Vt as atomic, Wt as texture2d, _t as max, cn as i32, ct as clamp, d as ZERO, et as typegpu_default, ft as exp, gt as length, ht as fract, it as abs, kt as sqrt, ln as u32, mt as floor, qt as struct, rt as select, sn as f32, st as ceil, vt as min, yt as mix } from "./edges-CV-BHMpI.js";
-import { c as resolveAgentShape, d as atomicStore, i as makeAgentTexelWeightFn, l as atomicAdd, o as orientedShapeOptions, t as AGENT_SHAPES, u as atomicLoad } from "./agents-CxygFSH4.js";
-import { I as textureLoad, M as createGuardedCompute, P as createStateBuffer, R as textureStore, t as isMobileGpuViewport } from "./device-DKcu50_C.js";
-import { a as gaussianBrushSq, c as createStableFluidsPasses, l as neighbourIndex, s as buildStableFluidsKernels } from "./porters-j7yWJYy2.js";
-import { r as curl22z, u as hash33 } from "./noise-eXd1Bfrw.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
-import { i as pathStampRibbon, n as createPointerVelocityTracker, t as createIdleGate } from "./pointer-DKBz1Qcc.js";
-var N = 256;
-var FLUID_COUNT = N * N;
-var JACOBI_ITERS = isMobileGpuViewport() ? 6 : 10;
-var VEL_FORMAT = "rgba16float";
-var RES = isMobileGpuViewport() ? 512 : 1024;
-var INV_RES = 1 / RES;
-var SIZE_REF_RES = 1024;
-var STATE_FORMAT = "rgba16float";
-var MAX_PARTICLES = 16384;
-var COUNT_MAX_MOBILE = 6e3;
-var SPLAT_R = 14;
-var AA_W = .75 * INV_RES;
-var HARD_GAIN = 637;
-var SOFT_GAIN = 255;
-var IMPULSE_K = .16;
-var MAX_STEPS = 16;
-var FORCE_RADIUS_GRID = .16 * N;
-var VEL_FADE_MAX = 4;
-var VEL_FADE_MIN = .05;
-var AMBIENT_K = 26;
-var AMBIENT_FREQ = 2.4;
-var AMBIENT_DRIFT = .09;
-var INERTIA_RATE = 6;
-var SPEED_NORM = .35;
-var WARMUP_FRAMES = 3;
-var FlowParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	dt: f32,
-	curlStrength: f32,
-	velFade: f32,
-	ambient: f32,
-	ambientTime: f32,
-	ambientFreq: f32
-}), "FlowParams");
-var SplatParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	posX: f32,
-	posY: f32,
-	velX: f32,
-	velY: f32,
-	radius: f32
-}), "SplatParams");
-var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	colA: vec4f,
-	colB: vec4f,
-	dt: f32,
-	aspect: f32,
-	trails: f32,
-	bodyR: f32,
-	speedNorm: f32,
-	advect: f32
-}), "SimParams");
-var fluidLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	velA: {
-		storage: arrayOf(vec4f, FLUID_COUNT),
-		access: "mutable"
-	},
-	velB: {
-		storage: arrayOf(vec4f, FLUID_COUNT),
-		access: "mutable"
-	},
-	pressure: {
-		storage: arrayOf(f32, FLUID_COUNT),
-		access: "mutable"
-	},
-	divergence: {
-		storage: arrayOf(f32, FLUID_COUNT),
-		access: "mutable"
-	},
-	params: { uniform: FlowParams },
-	sparams: { uniform: SplatParams },
-	velOutTex: { storageTexture: textureStorage2d(VEL_FORMAT, "write-only") }
-}), "fluidLayout");
-var pfLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	particles: {
-		storage: arrayOf(vec4f, MAX_PARTICLES),
-		access: "mutable"
-	},
-	accumE: {
-		storage: arrayOf(atomic(u32), RES * RES),
-		access: "mutable"
-	},
-	accumS: {
-		storage: arrayOf(atomic(u32), RES * RES),
-		access: "mutable"
-	},
-	trailBuf: {
-		storage: arrayOf(vec4f, RES * RES),
-		access: "mutable"
-	},
-	velTex: { texture: texture2d(f32) },
-	params: { uniform: SimParams },
-	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
-}), "pfLayout");
-var nidx = neighbourIndex(N, "clamped");
-const particleFlowForceKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const p = fluidLayout.$.sparams;
-	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
-	const cellX = __tsover_add(f32(cx), .5);
-	const cellY = __tsover_add(f32(cy), .5);
-	const dx = __tsover_sub(cellX, p.posX);
-	const dy = __tsover_sub(cellY, p.posY);
-	const inf = gaussianBrushSq(__tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy)), max(__tsover_mul(p.radius, p.radius), f32(1)));
-	const vel = fluidLayout.$.velA[idx];
-	fluidLayout.$.velA[idx] = vec4f(__tsover_add(vel.x, __tsover_mul(p.velX, inf)), __tsover_add(vel.y, __tsover_mul(p.velY, inf)), vel.z, 0);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"p",
-				[
-					7,
-					[
-						7,
-						"fluidLayout",
-						"$"
-					],
-					"sparams"
-				]
-			],
-			[
-				13,
-				"idx",
-				[
-					1,
-					[
-						1,
-						"cy",
-						"*",
-						[
-							6,
-							"d.u32",
-							["N"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"cellX",
-				[
-					1,
-					[
-						6,
-						"d.f32",
-						["cx"]
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"cellY",
-				[
-					1,
-					[
-						6,
-						"d.f32",
-						["cy"]
-					],
-					"+",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"dx",
-				[
-					1,
-					"cellX",
-					"-",
-					[
-						7,
-						"p",
-						"posX"
-					]
-				]
-			],
-			[
-				13,
-				"dy",
-				[
-					1,
-					"cellY",
-					"-",
-					[
-						7,
-						"p",
-						"posY"
-					]
-				]
-			],
-			[
-				13,
-				"distSq",
-				[
-					1,
-					[
-						1,
-						"dx",
-						"*",
-						"dx"
-					],
-					"+",
-					[
-						1,
-						"dy",
-						"*",
-						"dy"
-					]
-				]
-			],
-			[
-				13,
-				"radSq",
-				[
-					6,
-					"std.max",
-					[[
-						1,
-						[
-							7,
-							"p",
-							"radius"
-						],
-						"*",
-						[
-							7,
-							"p",
-							"radius"
-						]
-					], [
-						6,
-						"d.f32",
-						[[5, "1"]]
-					]]
-				]
-			],
-			[
-				13,
-				"inf",
-				[
-					6,
-					"gaussianBrushSq",
-					["distSq", "radSq"]
-				]
-			],
-			[
-				13,
-				"vel",
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"velA"
-					],
-					"idx"
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"velA"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						[
-							1,
-							[
-								7,
-								"vel",
-								"x"
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"p",
-									"velX"
-								],
-								"*",
-								"inf"
-							]
-						],
-						[
-							1,
-							[
-								7,
-								"vel",
-								"y"
-							],
-							"+",
-							[
-								1,
-								[
-									7,
-									"p",
-									"velY"
-								],
-								"*",
-								"inf"
-							]
-						],
-						[
-							7,
-							"vel",
-							"z"
-						],
-						[5, "0"]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"fluidLayout": () => fluidLayout,
-		"d.u32": () => u32,
-		"N": () => N,
-		"d.f32": () => f32,
-		"std.max": () => max,
-		"gaussianBrushSq": () => gaussianBrushSq,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("particleFlowForce");
-var solverKernels = buildStableFluidsKernels(fluidLayout, {
-	n: N,
-	namePrefix: "particleFlow",
-	boundary: "clamped",
-	dye: "none",
-	publishVelocityTexture: true
-});
-const { curl: particleFlowCurlKernel, divergence: particleFlowDivergenceKernel, jacobi: particleFlowJacobiKernel, gradSubtract: particleFlowGradSubtractKernel, advectVel: particleFlowAdvectVelKernel, copyVel: particleFlowCopyVelKernel } = solverKernels;
-const particleFlowVorticityKernel = typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-	"use gpu";
-	const p = fluidLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
-	const ii = i32(cy);
-	const ji = i32(cx);
-	const cL = abs(fluidLayout.$.velA[nidx(ii, ji, 0, -1)].z);
-	const cR = abs(fluidLayout.$.velA[nidx(ii, ji, 0, 1)].z);
-	const cU = abs(fluidLayout.$.velA[nidx(ii, ji, -1, 0)].z);
-	const cD = abs(fluidLayout.$.velA[nidx(ii, ji, 1, 0)].z);
-	const cc = fluidLayout.$.velA[idx].z;
-	const gx = __tsover_mul(__tsover_sub(cR, cL), .5);
-	const gy = __tsover_mul(__tsover_sub(cD, cU), .5);
-	const gl = max(sqrt(__tsover_add(__tsover_mul(gx, gx), __tsover_mul(gy, gy))), f32(1e-5));
-	const fx = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_div(gy, gl), cc), p.curlStrength), p.dt);
-	const fy = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_div(gx, gl), -1), cc), p.curlStrength), p.dt);
-	let ax = f32(0);
-	let ay = f32(0);
-	if (p.ambient > 0) {
-		const uvx = __tsover_div(__tsover_add(f32(cx), .5), f32(N));
-		const uvy = __tsover_div(__tsover_add(f32(cy), .5), f32(N));
-		const amb = curl22z(vec2f(__tsover_mul(uvx, p.ambientFreq), __tsover_mul(uvy, p.ambientFreq)), p.ambientTime);
-		const af = __tsover_mul(__tsover_mul(p.ambient, AMBIENT_K), p.dt);
-		ax = __tsover_mul(amb.x, af);
-		ay = __tsover_mul(amb.y, af);
-	}
-	const vel = fluidLayout.$.velA[idx];
-	fluidLayout.$.velA[idx] = vec4f(__tsover_add(__tsover_add(vel.x, fx), ax), __tsover_add(__tsover_add(vel.y, fy), ay), vel.z, 0);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "cx"
-		}, {
-			"type": "i",
-			"name": "cy"
-		}],
-		"body": [0, [
-			[
-				13,
-				"p",
-				[
-					7,
-					[
-						7,
-						"fluidLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"idx",
-				[
-					1,
-					[
-						1,
-						"cy",
-						"*",
-						[
-							6,
-							"d.u32",
-							["N"]
-						]
-					],
-					"+",
-					"cx"
-				]
-			],
-			[
-				13,
-				"ii",
-				[
-					6,
-					"d.i32",
-					["cy"]
-				]
-			],
-			[
-				13,
-				"ji",
-				[
-					6,
-					"d.i32",
-					["cx"]
-				]
-			],
-			[
-				13,
-				"cL",
-				[
-					6,
-					"std.abs",
-					[[
-						7,
-						[
-							8,
-							[
-								7,
-								[
-									7,
-									"fluidLayout",
-									"$"
-								],
-								"velA"
-							],
-							[
-								6,
-								"nidx",
-								[
-									"ii",
-									"ji",
-									[5, "0"],
-									[
-										4,
-										"-",
-										[5, "1"]
-									]
-								]
-							]
-						],
-						"z"
-					]]
-				]
-			],
-			[
-				13,
-				"cR",
-				[
-					6,
-					"std.abs",
-					[[
-						7,
-						[
-							8,
-							[
-								7,
-								[
-									7,
-									"fluidLayout",
-									"$"
-								],
-								"velA"
-							],
-							[
-								6,
-								"nidx",
-								[
-									"ii",
-									"ji",
-									[5, "0"],
-									[5, "1"]
-								]
-							]
-						],
-						"z"
-					]]
-				]
-			],
-			[
-				13,
-				"cU",
-				[
-					6,
-					"std.abs",
-					[[
-						7,
-						[
-							8,
-							[
-								7,
-								[
-									7,
-									"fluidLayout",
-									"$"
-								],
-								"velA"
-							],
-							[
-								6,
-								"nidx",
-								[
-									"ii",
-									"ji",
-									[
-										4,
-										"-",
-										[5, "1"]
-									],
-									[5, "0"]
-								]
-							]
-						],
-						"z"
-					]]
-				]
-			],
-			[
-				13,
-				"cD",
-				[
-					6,
-					"std.abs",
-					[[
-						7,
-						[
-							8,
-							[
-								7,
-								[
-									7,
-									"fluidLayout",
-									"$"
-								],
-								"velA"
-							],
-							[
-								6,
-								"nidx",
-								[
-									"ii",
-									"ji",
-									[5, "1"],
-									[5, "0"]
-								]
-							]
-						],
-						"z"
-					]]
-				]
-			],
-			[
-				13,
-				"cc",
-				[
-					7,
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"fluidLayout",
-								"$"
-							],
-							"velA"
-						],
-						"idx"
-					],
-					"z"
-				]
-			],
-			[
-				13,
-				"gx",
-				[
-					1,
-					[
-						1,
-						"cR",
-						"-",
-						"cL"
-					],
-					"*",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"gy",
-				[
-					1,
-					[
-						1,
-						"cD",
-						"-",
-						"cU"
-					],
-					"*",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"gl",
-				[
-					6,
-					"std.max",
-					[[
-						6,
-						"std.sqrt",
-						[[
-							1,
-							[
-								1,
-								"gx",
-								"*",
-								"gx"
-							],
-							"+",
-							[
-								1,
-								"gy",
-								"*",
-								"gy"
-							]
-						]]
-					], [
-						6,
-						"d.f32",
-						[[5, "0.00001"]]
-					]]
-				]
-			],
-			[
-				13,
-				"fx",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								"gy",
-								"/",
-								"gl"
-							],
-							"*",
-							"cc"
-						],
-						"*",
-						[
-							7,
-							"p",
-							"curlStrength"
-						]
-					],
-					"*",
-					[
-						7,
-						"p",
-						"dt"
-					]
-				]
-			],
-			[
-				13,
-				"fy",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									"gx",
-									"/",
-									"gl"
-								],
-								"*",
-								[
-									4,
-									"-",
-									[5, "1"]
-								]
-							],
-							"*",
-							"cc"
-						],
-						"*",
-						[
-							7,
-							"p",
-							"curlStrength"
-						]
-					],
-					"*",
-					[
-						7,
-						"p",
-						"dt"
-					]
-				]
-			],
-			[
-				12,
-				"ax",
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			],
-			[
-				12,
-				"ay",
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			],
-			[
-				11,
-				[
-					1,
-					[
-						7,
-						"p",
-						"ambient"
-					],
-					">",
-					[5, "0"]
-				],
-				[0, [
-					[
-						13,
-						"uvx",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cx"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							[
-								6,
-								"d.f32",
-								["N"]
-							]
-						]
-					],
-					[
-						13,
-						"uvy",
-						[
-							1,
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["cy"]
-								],
-								"+",
-								[5, "0.5"]
-							],
-							"/",
-							[
-								6,
-								"d.f32",
-								["N"]
-							]
-						]
-					],
-					[
-						13,
-						"amb",
-						[
-							6,
-							"noise.curl22z",
-							[[
-								6,
-								"d.vec2f",
-								[[
-									1,
-									"uvx",
-									"*",
-									[
-										7,
-										"p",
-										"ambientFreq"
-									]
-								], [
-									1,
-									"uvy",
-									"*",
-									[
-										7,
-										"p",
-										"ambientFreq"
-									]
-								]]
-							], [
-								7,
-								"p",
-								"ambientTime"
-							]]
-						]
-					],
-					[
-						13,
-						"af",
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"p",
-									"ambient"
-								],
-								"*",
-								"AMBIENT_K"
-							],
-							"*",
-							[
-								7,
-								"p",
-								"dt"
-							]
-						]
-					],
-					[
-						2,
-						"ax",
-						"=",
-						[
-							1,
-							[
-								7,
-								"amb",
-								"x"
-							],
-							"*",
-							"af"
-						]
-					],
-					[
-						2,
-						"ay",
-						"=",
-						[
-							1,
-							[
-								7,
-								"amb",
-								"y"
-							],
-							"*",
-							"af"
-						]
-					]
-				]]
-			],
-			[
-				13,
-				"vel",
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"velA"
-					],
-					"idx"
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"fluidLayout",
-							"$"
-						],
-						"velA"
-					],
-					"idx"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"vel",
-									"x"
-								],
-								"+",
-								"fx"
-							],
-							"+",
-							"ax"
-						],
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"vel",
-									"y"
-								],
-								"+",
-								"fy"
-							],
-							"+",
-							"ay"
-						],
-						[
-							7,
-							"vel",
-							"z"
-						],
-						[5, "0"]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"fluidLayout": () => fluidLayout,
-		"d.u32": () => u32,
-		"N": () => N,
-		"d.i32": () => i32,
-		"std.abs": () => abs,
-		"nidx": () => nidx,
-		"std.max": () => max,
-		"std.sqrt": () => sqrt,
-		"d.f32": () => f32,
-		"noise.curl22z": () => curl22z,
-		"d.vec2f": () => vec2f,
-		"AMBIENT_K": () => AMBIENT_K,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("particleFlowVorticity");
-const particleFlowInitKernel = typegpu_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-	"use gpu";
-	const prm = pfLayout.$.params;
-	const fi = f32(i);
-	const r = hash33(vec3f(__tsover_add(__tsover_mul(fi, 1.6180339), .71), __tsover_add(__tsover_mul(fi, 2.7182818), 4.17), __tsover_add(__tsover_mul(fi, 3.1415926), 9.03)));
-	pfLayout.$.particles[i] = vec4f(__tsover_mul(r.x, prm.aspect), r.y, 0, 0);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "i"
-		}],
-		"body": [0, [
-			[
-				13,
-				"prm",
-				[
-					7,
-					[
-						7,
-						"pfLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"fi",
-				[
-					6,
-					"d.f32",
-					["i"]
-				]
-			],
-			[
-				13,
-				"r",
-				[
-					6,
-					"noise.hash33",
-					[[
-						6,
-						"d.vec3f",
-						[
-							[
-								1,
-								[
-									1,
-									"fi",
-									"*",
-									[5, "1.6180339"]
-								],
-								"+",
-								[5, "0.71"]
-							],
-							[
-								1,
-								[
-									1,
-									"fi",
-									"*",
-									[5, "2.7182818"]
-								],
-								"+",
-								[5, "4.17"]
-							],
-							[
-								1,
-								[
-									1,
-									"fi",
-									"*",
-									[5, "3.1415926"]
-								],
-								"+",
-								[5, "9.03"]
-							]
-						]
-					]]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"pfLayout",
-							"$"
-						],
-						"particles"
-					],
-					"i"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						[
-							1,
-							[
-								7,
-								"r",
-								"x"
-							],
-							"*",
-							[
-								7,
-								"prm",
-								"aspect"
-							]
-						],
-						[
-							7,
-							"r",
-							"y"
-						],
-						[5, "0"],
-						[5, "0"]
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"pfLayout": () => pfLayout,
-		"d.f32": () => f32,
-		"noise.hash33": () => hash33,
-		"d.vec3f": () => vec3f,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("particleFlowInit");
-var R2A = .7548776662466927;
-var R2B = .5698402909980532;
-var HOME_RATE = 1.8;
-const particleFlowIntegrateKernel = typegpu_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-	"use gpu";
-	const prm = pfLayout.$.params;
-	const a = pfLayout.$.particles[i];
-	const pos = vec2f(a.x, a.y);
-	const dt = prm.dt;
-	const aspect = max(prm.aspect, 1e-5);
-	const uvx = __tsover_div(pos.x, aspect);
-	const uvy = pos.y;
-	const NF = f32(N);
-	const su = __tsover_sub(__tsover_mul(uvx, NF), .5);
-	const sv = __tsover_sub(__tsover_mul(uvy, NF), .5);
-	const x0 = floor(su);
-	const y0 = floor(sv);
-	const fx = __tsover_sub(su, x0);
-	const fy = __tsover_sub(sv, y0);
-	const maxT = __tsover_sub(NF, 1);
-	const ix0 = u32(clamp(x0, 0, maxT));
-	const ix1 = u32(clamp(__tsover_add(x0, 1), 0, maxT));
-	const iy0 = u32(clamp(y0, 0, maxT));
-	const iy1 = u32(clamp(__tsover_add(y0, 1), 0, maxT));
-	const v00 = textureLoad(pfLayout.$.velTex, vec2u(ix0, iy0), 0);
-	const v10 = textureLoad(pfLayout.$.velTex, vec2u(ix1, iy0), 0);
-	const v01 = textureLoad(pfLayout.$.velTex, vec2u(ix0, iy1), 0);
-	const v11 = textureLoad(pfLayout.$.velTex, vec2u(ix1, iy1), 0);
-	const gvx = mix(mix(v00.x, v10.x, fx), mix(v01.x, v11.x, fx), fy);
-	const gvy = mix(mix(v00.y, v10.y, fx), mix(v01.y, v11.y, fx), fy);
-	const fieldVx = __tsover_mul(__tsover_mul(__tsover_div(gvx, NF), aspect), prm.advect);
-	const fieldVy = __tsover_mul(__tsover_div(gvy, NF), prm.advect);
-	const blend = __tsover_sub(1, exp(__tsover_mul(__tsover_mul(dt, INERTIA_RATE), -1)));
-	const fi = f32(i);
-	const homeX = __tsover_mul(fract(__tsover_add(.5, __tsover_mul(fi, R2A))), aspect);
-	const homeY = fract(__tsover_add(.5, __tsover_mul(fi, R2B)));
-	const velX = __tsover_add(mix(a.z, fieldVx, blend), __tsover_mul(__tsover_sub(homeX, pos.x), __tsover_mul(HOME_RATE, dt)));
-	const velY = __tsover_add(mix(a.w, fieldVy, blend), __tsover_mul(__tsover_sub(homeY, pos.y), __tsover_mul(HOME_RATE, dt)));
-	const nposX = clamp(__tsover_add(pos.x, __tsover_mul(velX, dt)), 0, aspect);
-	const nposY = clamp(__tsover_add(pos.y, __tsover_mul(velY, dt)), 0, 1);
-	pfLayout.$.particles[i] = vec4f(nposX, nposY, velX, velY);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "i"
-		}],
-		"body": [0, [
-			[
-				13,
-				"prm",
-				[
-					7,
-					[
-						7,
-						"pfLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"a",
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"pfLayout",
-							"$"
-						],
-						"particles"
-					],
-					"i"
-				]
-			],
-			[
-				13,
-				"pos",
-				[
-					6,
-					"d.vec2f",
-					[[
-						7,
-						"a",
-						"x"
-					], [
-						7,
-						"a",
-						"y"
-					]]
-				]
-			],
-			[
-				13,
-				"dt",
-				[
-					7,
-					"prm",
-					"dt"
-				]
-			],
-			[
-				13,
-				"aspect",
-				[
-					6,
-					"std.max",
-					[[
-						7,
-						"prm",
-						"aspect"
-					], [5, "0.00001"]]
-				]
-			],
-			[
-				13,
-				"uvx",
-				[
-					1,
-					[
-						7,
-						"pos",
-						"x"
-					],
-					"/",
-					"aspect"
-				]
-			],
-			[
-				13,
-				"uvy",
-				[
-					7,
-					"pos",
-					"y"
-				]
-			],
-			[
-				13,
-				"NF",
-				[
-					6,
-					"d.f32",
-					["N"]
-				]
-			],
-			[
-				13,
-				"su",
-				[
-					1,
-					[
-						1,
-						"uvx",
-						"*",
-						"NF"
-					],
-					"-",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"sv",
-				[
-					1,
-					[
-						1,
-						"uvy",
-						"*",
-						"NF"
-					],
-					"-",
-					[5, "0.5"]
-				]
-			],
-			[
-				13,
-				"x0",
-				[
-					6,
-					"std.floor",
-					["su"]
-				]
-			],
-			[
-				13,
-				"y0",
-				[
-					6,
-					"std.floor",
-					["sv"]
-				]
-			],
-			[
-				13,
-				"fx",
-				[
-					1,
-					"su",
-					"-",
-					"x0"
-				]
-			],
-			[
-				13,
-				"fy",
-				[
-					1,
-					"sv",
-					"-",
-					"y0"
-				]
-			],
-			[
-				13,
-				"maxT",
-				[
-					1,
-					"NF",
-					"-",
-					[5, "1"]
-				]
-			],
-			[
-				13,
-				"ix0",
-				[
-					6,
-					"d.u32",
-					[[
-						6,
-						"std.clamp",
-						[
-							"x0",
-							[5, "0"],
-							"maxT"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"ix1",
-				[
-					6,
-					"d.u32",
-					[[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								"x0",
-								"+",
-								[5, "1"]
-							],
-							[5, "0"],
-							"maxT"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"iy0",
-				[
-					6,
-					"d.u32",
-					[[
-						6,
-						"std.clamp",
-						[
-							"y0",
-							[5, "0"],
-							"maxT"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"iy1",
-				[
-					6,
-					"d.u32",
-					[[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								"y0",
-								"+",
-								[5, "1"]
-							],
-							[5, "0"],
-							"maxT"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"v00",
-				[
-					6,
-					"std.textureLoad",
-					[
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"velTex"
-						],
-						[
-							6,
-							"d.vec2u",
-							["ix0", "iy0"]
-						],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				13,
-				"v10",
-				[
-					6,
-					"std.textureLoad",
-					[
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"velTex"
-						],
-						[
-							6,
-							"d.vec2u",
-							["ix1", "iy0"]
-						],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				13,
-				"v01",
-				[
-					6,
-					"std.textureLoad",
-					[
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"velTex"
-						],
-						[
-							6,
-							"d.vec2u",
-							["ix0", "iy1"]
-						],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				13,
-				"v11",
-				[
-					6,
-					"std.textureLoad",
-					[
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"velTex"
-						],
-						[
-							6,
-							"d.vec2u",
-							["ix1", "iy1"]
-						],
-						[5, "0"]
-					]
-				]
-			],
-			[
-				13,
-				"gvx",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							6,
-							"std.mix",
-							[
-								[
-									7,
-									"v00",
-									"x"
-								],
-								[
-									7,
-									"v10",
-									"x"
-								],
-								"fx"
-							]
-						],
-						[
-							6,
-							"std.mix",
-							[
-								[
-									7,
-									"v01",
-									"x"
-								],
-								[
-									7,
-									"v11",
-									"x"
-								],
-								"fx"
-							]
-						],
-						"fy"
-					]
-				]
-			],
-			[
-				13,
-				"gvy",
-				[
-					6,
-					"std.mix",
-					[
-						[
-							6,
-							"std.mix",
-							[
-								[
-									7,
-									"v00",
-									"y"
-								],
-								[
-									7,
-									"v10",
-									"y"
-								],
-								"fx"
-							]
-						],
-						[
-							6,
-							"std.mix",
-							[
-								[
-									7,
-									"v01",
-									"y"
-								],
-								[
-									7,
-									"v11",
-									"y"
-								],
-								"fx"
-							]
-						],
-						"fy"
-					]
-				]
-			],
-			[
-				13,
-				"fieldVx",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"gvx",
-							"/",
-							"NF"
-						],
-						"*",
-						"aspect"
-					],
-					"*",
-					[
-						7,
-						"prm",
-						"advect"
-					]
-				]
-			],
-			[
-				13,
-				"fieldVy",
-				[
-					1,
-					[
-						1,
-						"gvy",
-						"/",
-						"NF"
-					],
-					"*",
-					[
-						7,
-						"prm",
-						"advect"
-					]
-				]
-			],
-			[
-				13,
-				"blend",
-				[
-					1,
-					[5, "1"],
-					"-",
-					[
-						6,
-						"std.exp",
-						[[
-							1,
-							[
-								1,
-								"dt",
-								"*",
-								"INERTIA_RATE"
-							],
-							"*",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						]]
-					]
-				]
-			],
-			[
-				13,
-				"fi",
-				[
-					6,
-					"d.f32",
-					["i"]
-				]
-			],
-			[
-				13,
-				"homeX",
-				[
-					1,
-					[
-						6,
-						"std.fract",
-						[[
-							1,
-							[5, "0.5"],
-							"+",
-							[
-								1,
-								"fi",
-								"*",
-								"R2A"
-							]
-						]]
-					],
-					"*",
-					"aspect"
-				]
-			],
-			[
-				13,
-				"homeY",
-				[
-					6,
-					"std.fract",
-					[[
-						1,
-						[5, "0.5"],
-						"+",
-						[
-							1,
-							"fi",
-							"*",
-							"R2B"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"velX",
-				[
-					1,
-					[
-						6,
-						"std.mix",
-						[
-							[
-								7,
-								"a",
-								"z"
-							],
-							"fieldVx",
-							"blend"
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							1,
-							"homeX",
-							"-",
-							[
-								7,
-								"pos",
-								"x"
-							]
-						],
-						"*",
-						[
-							1,
-							"HOME_RATE",
-							"*",
-							"dt"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"velY",
-				[
-					1,
-					[
-						6,
-						"std.mix",
-						[
-							[
-								7,
-								"a",
-								"w"
-							],
-							"fieldVy",
-							"blend"
-						]
-					],
-					"+",
-					[
-						1,
-						[
-							1,
-							"homeY",
-							"-",
-							[
-								7,
-								"pos",
-								"y"
-							]
-						],
-						"*",
-						[
-							1,
-							"HOME_RATE",
-							"*",
-							"dt"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"nposX",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								7,
-								"pos",
-								"x"
-							],
-							"+",
-							[
-								1,
-								"velX",
-								"*",
-								"dt"
-							]
-						],
-						[5, "0"],
-						"aspect"
-					]
-				]
-			],
-			[
-				13,
-				"nposY",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								7,
-								"pos",
-								"y"
-							],
-							"+",
-							[
-								1,
-								"velY",
-								"*",
-								"dt"
-							]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"pfLayout",
-							"$"
-						],
-						"particles"
-					],
-					"i"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						"nposX",
-						"nposY",
-						"velX",
-						"velY"
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"pfLayout": () => pfLayout,
-		"d.vec2f": () => vec2f,
-		"std.max": () => max,
-		"d.f32": () => f32,
-		"N": () => N,
-		"std.floor": () => floor,
-		"d.u32": () => u32,
-		"std.clamp": () => clamp,
-		"std.textureLoad": () => textureLoad,
-		"d.vec2u": () => vec2u,
-		"std.mix": () => mix,
-		"std.exp": () => exp,
-		"INERTIA_RATE": () => INERTIA_RATE,
-		"std.fract": () => fract,
-		"R2A": () => R2A,
-		"R2B": () => R2B,
-		"HOME_RATE": () => HOME_RATE,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("particleFlowIntegrate");
-function makeParticleFlowSplatKernel(shape) {
-	const name = resolveAgentShape(shape, "streak");
-	const s = AGENT_SHAPES[name];
-	const weightFn = makeAgentTexelWeightFn(name);
-	const HL = name === "glow" ? 1 : s.hl;
-	const SOFT = s.soft;
-	const EXT = name === "glow" ? s.ext + 1 : s.ext;
-	const GAIN = s.soft ? SOFT_GAIN : HARD_GAIN;
-	return typegpu_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-		"use gpu";
-		const prm = pfLayout.$.params;
-		const a = pfLayout.$.particles[i];
-		const pos = vec2f(a.x, a.y);
-		const vel = vec2f(a.z, a.w);
-		const spd = length(vel);
-		const dir = select(vec2f(1, 0), vel.div(max(spd, 1e-5)), spd > 1e-5);
-		const agitI = clamp(__tsover_div(spd, max(prm.speedNorm, 1e-5)), 0, 1);
-		const aspect = max(prm.aspect, 1e-5);
-		const bodyR = clamp(prm.bodyR, 1e-6, __tsover_mul(f32(SPLAT_R), INV_RES));
-		const hl = __tsover_mul(bodyR, HL);
-		const invR2 = __tsover_div(1, __tsover_mul(bodyR, bodyR));
-		const radW = __tsover_add(__tsover_mul(bodyR, EXT), __tsover_mul(AA_W, 2));
-		const extSq = __tsover_mul(radW, radW);
-		const txf = __tsover_mul(__tsover_div(pos.x, aspect), f32(RES));
-		const tyf = __tsover_mul(pos.y, f32(RES));
-		const cxi = i32(floor(txf));
-		const cyi = i32(floor(tyf));
-		const radY = i32(ceil(__tsover_mul(radW, f32(RES))));
-		const radX = i32(ceil(__tsover_div(__tsover_mul(radW, f32(RES)), aspect)));
-		const x0 = max(__tsover_sub(cxi, radX), 0);
-		const x1 = min(__tsover_add(cxi, radX), __tsover_sub(i32(RES), 1));
-		const y0 = max(__tsover_sub(cyi, radY), 0);
-		const y1 = min(__tsover_add(cyi, radY), __tsover_sub(i32(RES), 1));
-		for (let py = y0; py <= y1; py++) {
-			const offY = __tsover_sub(__tsover_mul(__tsover_add(f32(py), .5), INV_RES), pos.y);
-			const offYSq = __tsover_mul(offY, offY);
-			for (let px = x0; px <= x1; px++) {
-				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(f32(px), .5), INV_RES), aspect), pos.x);
-				if (__tsover_add(__tsover_mul(offX, offX), offYSq) < extSq) {
-					const t = __tsover_add(__tsover_mul(offX, dir.x), __tsover_mul(offY, dir.y));
-					const n = __tsover_add(__tsover_mul(offX, -dir.y), __tsover_mul(offY, dir.x));
-					const tEval = select(t, __tsover_sub(t, clamp(t, -hl, hl)), f32(SOFT) > .5);
-					const tk = clamp(__tsover_div(__tsover_sub(hl, t), max(__tsover_mul(hl, 2), 1e-6)), 0, 1);
-					const bright = __tsover_sub(1, __tsover_mul(__tsover_mul(.55, tk), f32(SOFT)));
-					const qEval = __tsover_mul(__tsover_add(__tsover_mul(tEval, tEval), __tsover_mul(n, n)), invR2);
-					const w = __tsover_mul(weightFn(qEval, tEval, n, bodyR, AA_W), bright);
-					const e = u32(__tsover_mul(w, f32(GAIN)));
-					if (e > u32(0)) {
-						const idx = u32(__tsover_add(__tsover_mul(py, i32(RES)), px));
-						atomicAdd(pfLayout.$.accumE[idx], e);
-						atomicAdd(pfLayout.$.accumS[idx], u32(__tsover_mul(__tsover_mul(w, agitI), f32(GAIN))));
-					}
-				}
-			}
-		}
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "i"
-			}],
-			"body": [0, [
-				[
-					13,
-					"prm",
-					[
-						7,
-						[
-							7,
-							"pfLayout",
-							"$"
-						],
-						"params"
-					]
-				],
-				[
-					13,
-					"a",
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"particles"
-						],
-						"i"
-					]
-				],
-				[
-					13,
-					"pos",
-					[
-						6,
-						"d.vec2f",
-						[[
-							7,
-							"a",
-							"x"
-						], [
-							7,
-							"a",
-							"y"
-						]]
-					]
-				],
-				[
-					13,
-					"vel",
-					[
-						6,
-						"d.vec2f",
-						[[
-							7,
-							"a",
-							"z"
-						], [
-							7,
-							"a",
-							"w"
-						]]
-					]
-				],
-				[
-					13,
-					"spd",
-					[
-						6,
-						"std.length",
-						["vel"]
-					]
-				],
-				[
-					13,
-					"dir",
-					[
-						6,
-						"std.select",
-						[
-							[
-								6,
-								"d.vec2f",
-								[[5, "1"], [5, "0"]]
-							],
-							[
-								6,
-								[
-									7,
-									"vel",
-									"div"
-								],
-								[[
-									6,
-									"std.max",
-									["spd", [5, "0.00001"]]
-								]]
-							],
-							[
-								1,
-								"spd",
-								">",
-								[5, "0.00001"]
-							]
-						]
-					]
-				],
-				[
-					13,
-					"agitI",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								1,
-								"spd",
-								"/",
-								[
-									6,
-									"std.max",
-									[[
-										7,
-										"prm",
-										"speedNorm"
-									], [5, "0.00001"]]
-								]
-							],
-							[5, "0"],
-							[5, "1"]
-						]
-					]
-				],
-				[
-					13,
-					"aspect",
-					[
-						6,
-						"std.max",
-						[[
-							7,
-							"prm",
-							"aspect"
-						], [5, "0.00001"]]
-					]
-				],
-				[
-					13,
-					"bodyR",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								7,
-								"prm",
-								"bodyR"
-							],
-							[5, "0.000001"],
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["SPLAT_R"]
-								],
-								"*",
-								"INV_RES"
-							]
-						]
-					]
-				],
-				[
-					13,
-					"hl",
-					[
-						1,
-						"bodyR",
-						"*",
-						"HL"
-					]
-				],
-				[
-					13,
-					"invR2",
-					[
-						1,
-						[5, "1"],
-						"/",
-						[
-							1,
-							"bodyR",
-							"*",
-							"bodyR"
-						]
-					]
-				],
-				[
-					13,
-					"radW",
-					[
-						1,
-						[
-							1,
-							"bodyR",
-							"*",
-							"EXT"
-						],
-						"+",
-						[
-							1,
-							"AA_W",
-							"*",
-							[5, "2"]
-						]
-					]
-				],
-				[
-					13,
-					"extSq",
-					[
-						1,
-						"radW",
-						"*",
-						"radW"
-					]
-				],
-				[
-					13,
-					"txf",
-					[
-						1,
-						[
-							1,
-							[
-								7,
-								"pos",
-								"x"
-							],
-							"/",
-							"aspect"
-						],
-						"*",
-						[
-							6,
-							"d.f32",
-							["RES"]
-						]
-					]
-				],
-				[
-					13,
-					"tyf",
-					[
-						1,
-						[
-							7,
-							"pos",
-							"y"
-						],
-						"*",
-						[
-							6,
-							"d.f32",
-							["RES"]
-						]
-					]
-				],
-				[
-					13,
-					"cxi",
-					[
-						6,
-						"d.i32",
-						[[
-							6,
-							"std.floor",
-							["txf"]
-						]]
-					]
-				],
-				[
-					13,
-					"cyi",
-					[
-						6,
-						"d.i32",
-						[[
-							6,
-							"std.floor",
-							["tyf"]
-						]]
-					]
-				],
-				[
-					13,
-					"radY",
-					[
-						6,
-						"d.i32",
-						[[
-							6,
-							"std.ceil",
-							[[
-								1,
-								"radW",
-								"*",
-								[
-									6,
-									"d.f32",
-									["RES"]
-								]
-							]]
-						]]
-					]
-				],
-				[
-					13,
-					"radX",
-					[
-						6,
-						"d.i32",
-						[[
-							6,
-							"std.ceil",
-							[[
-								1,
-								[
-									1,
-									"radW",
-									"*",
-									[
-										6,
-										"d.f32",
-										["RES"]
-									]
-								],
-								"/",
-								"aspect"
-							]]
-						]]
-					]
-				],
-				[
-					13,
-					"x0",
-					[
-						6,
-						"std.max",
-						[[
-							1,
-							"cxi",
-							"-",
-							"radX"
-						], [5, "0"]]
-					]
-				],
-				[
-					13,
-					"x1",
-					[
-						6,
-						"std.min",
-						[[
-							1,
-							"cxi",
-							"+",
-							"radX"
-						], [
-							1,
-							[
-								6,
-								"d.i32",
-								["RES"]
-							],
-							"-",
-							[5, "1"]
-						]]
-					]
-				],
-				[
-					13,
-					"y0",
-					[
-						6,
-						"std.max",
-						[[
-							1,
-							"cyi",
-							"-",
-							"radY"
-						], [5, "0"]]
-					]
-				],
-				[
-					13,
-					"y1",
-					[
-						6,
-						"std.min",
-						[[
-							1,
-							"cyi",
-							"+",
-							"radY"
-						], [
-							1,
-							[
-								6,
-								"d.i32",
-								["RES"]
-							],
-							"-",
-							[5, "1"]
-						]]
-					]
-				],
-				[
-					14,
-					[
-						12,
-						"py",
-						"y0"
-					],
-					[
-						1,
-						"py",
-						"<=",
-						"y1"
-					],
-					[
-						102,
-						"++",
-						"py"
-					],
-					[0, [
-						[
-							13,
-							"offY",
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											6,
-											"d.f32",
-											["py"]
-										],
-										"+",
-										[5, "0.5"]
-									],
-									"*",
-									"INV_RES"
-								],
-								"-",
-								[
-									7,
-									"pos",
-									"y"
-								]
-							]
-						],
-						[
-							13,
-							"offYSq",
-							[
-								1,
-								"offY",
-								"*",
-								"offY"
-							]
-						],
-						[
-							14,
-							[
-								12,
-								"px",
-								"x0"
-							],
-							[
-								1,
-								"px",
-								"<=",
-								"x1"
-							],
-							[
-								102,
-								"++",
-								"px"
-							],
-							[0, [[
-								13,
-								"offX",
-								[
-									1,
-									[
-										1,
-										[
-											1,
-											[
-												1,
-												[
-													6,
-													"d.f32",
-													["px"]
-												],
-												"+",
-												[5, "0.5"]
-											],
-											"*",
-											"INV_RES"
-										],
-										"*",
-										"aspect"
-									],
-									"-",
-									[
-										7,
-										"pos",
-										"x"
-									]
-								]
-							], [
-								11,
-								[
-									1,
-									[
-										1,
-										[
-											1,
-											"offX",
-											"*",
-											"offX"
-										],
-										"+",
-										"offYSq"
-									],
-									"<",
-									"extSq"
-								],
-								[0, [
-									[
-										13,
-										"t",
-										[
-											1,
-											[
-												1,
-												"offX",
-												"*",
-												[
-													7,
-													"dir",
-													"x"
-												]
-											],
-											"+",
-											[
-												1,
-												"offY",
-												"*",
-												[
-													7,
-													"dir",
-													"y"
-												]
-											]
-										]
-									],
-									[
-										13,
-										"n",
-										[
-											1,
-											[
-												1,
-												"offX",
-												"*",
-												[
-													4,
-													"-",
-													[
-														7,
-														"dir",
-														"y"
-													]
-												]
-											],
-											"+",
-											[
-												1,
-												"offY",
-												"*",
-												[
-													7,
-													"dir",
-													"x"
-												]
-											]
-										]
-									],
-									[
-										13,
-										"tGlow",
-										[
-											1,
-											"t",
-											"-",
-											[
-												6,
-												"std.clamp",
-												[
-													"t",
-													[
-														4,
-														"-",
-														"hl"
-													],
-													"hl"
-												]
-											]
-										]
-									],
-									[
-										13,
-										"tEval",
-										[
-											6,
-											"std.select",
-											[
-												"t",
-												"tGlow",
-												[
-													1,
-													[
-														6,
-														"d.f32",
-														["SOFT"]
-													],
-													">",
-													[5, "0.5"]
-												]
-											]
-										]
-									],
-									[
-										13,
-										"tk",
-										[
-											6,
-											"std.clamp",
-											[
-												[
-													1,
-													[
-														1,
-														"hl",
-														"-",
-														"t"
-													],
-													"/",
-													[
-														6,
-														"std.max",
-														[[
-															1,
-															"hl",
-															"*",
-															[5, "2"]
-														], [5, "0.000001"]]
-													]
-												],
-												[5, "0"],
-												[5, "1"]
-											]
-										]
-									],
-									[
-										13,
-										"bright",
-										[
-											1,
-											[5, "1"],
-											"-",
-											[
-												1,
-												[
-													1,
-													[5, "0.55"],
-													"*",
-													"tk"
-												],
-												"*",
-												[
-													6,
-													"d.f32",
-													["SOFT"]
-												]
-											]
-										]
-									],
-									[
-										13,
-										"qEval",
-										[
-											1,
-											[
-												1,
-												[
-													1,
-													"tEval",
-													"*",
-													"tEval"
-												],
-												"+",
-												[
-													1,
-													"n",
-													"*",
-													"n"
-												]
-											],
-											"*",
-											"invR2"
-										]
-									],
-									[
-										13,
-										"w",
-										[
-											1,
-											[
-												6,
-												"weightFn",
-												[
-													"qEval",
-													"tEval",
-													"n",
-													"bodyR",
-													"AA_W"
-												]
-											],
-											"*",
-											"bright"
-										]
-									],
-									[
-										13,
-										"e",
-										[
-											6,
-											"d.u32",
-											[[
-												1,
-												"w",
-												"*",
-												[
-													6,
-													"d.f32",
-													["GAIN"]
-												]
-											]]
-										]
-									],
-									[
-										11,
-										[
-											1,
-											"e",
-											">",
-											[
-												6,
-												"d.u32",
-												[[5, "0"]]
-											]
-										],
-										[0, [
-											[
-												13,
-												"idx",
-												[
-													6,
-													"d.u32",
-													[[
-														1,
-														[
-															1,
-															"py",
-															"*",
-															[
-																6,
-																"d.i32",
-																["RES"]
-															]
-														],
-														"+",
-														"px"
-													]]
-												]
-											],
-											[
-												6,
-												"std.atomicAdd",
-												[[
-													8,
-													[
-														7,
-														[
-															7,
-															"pfLayout",
-															"$"
-														],
-														"accumE"
-													],
-													"idx"
-												], "e"]
-											],
-											[
-												6,
-												"std.atomicAdd",
-												[[
-													8,
-													[
-														7,
-														[
-															7,
-															"pfLayout",
-															"$"
-														],
-														"accumS"
-													],
-													"idx"
-												], [
-													6,
-													"d.u32",
-													[[
-														1,
-														[
-															1,
-															"w",
-															"*",
-															"agitI"
-														],
-														"*",
-														[
-															6,
-															"d.f32",
-															["GAIN"]
-														]
-													]]
-												]]
-											]
-										]]
-									]
-								]]
-							]]]
-						]
-					]]
-				]
-			]]
-		},
-		externals: {
-			"pfLayout": () => pfLayout,
-			"d.vec2f": () => vec2f,
-			"std.length": () => length,
-			"std.select": () => select,
-			"std.max": () => max,
-			"std.clamp": () => clamp,
-			"d.f32": () => f32,
-			"SPLAT_R": () => SPLAT_R,
-			"INV_RES": () => INV_RES,
-			"HL": () => HL,
-			"EXT": () => EXT,
-			"AA_W": () => AA_W,
-			"RES": () => RES,
-			"d.i32": () => i32,
-			"std.floor": () => floor,
-			"std.ceil": () => ceil,
-			"std.min": () => min,
-			"SOFT": () => SOFT,
-			"weightFn": () => weightFn,
-			"d.u32": () => u32,
-			"GAIN": () => GAIN,
-			"std.atomicAdd": () => atomicAdd
-		}
-	}) && $.f)({})).$name("particleFlowSplat");
-}
-const particleFlowSplatKernel = makeParticleFlowSplatKernel("streak");
-function makeParticleFlowResolveKernel(colorSpaceMode, trailsOn) {
-	const mixFn = mixColorsVariants[colorSpaceMode] ?? mixColorsLinear;
-	const composite = trailsOn ? typegpu_default.fn([
-		vec4f,
-		f32,
-		u32
-	], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((col, curA, idx) => {
-		"use gpu";
-		const prev = pfLayout.$.trailBuf[idx];
-		const prevA = __tsover_mul(prev.w, pfLayout.$.params.trails);
-		const win = curA >= prevA;
-		const rgb = select(vec3f(prev.x, prev.y, prev.z), vec3f(col.x, col.y, col.z), win);
-		return vec4f(rgb.x, rgb.y, rgb.z, max(curA, prevA));
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [
-				{
-					"type": "i",
-					"name": "col"
-				},
-				{
-					"type": "i",
-					"name": "curA"
-				},
-				{
-					"type": "i",
-					"name": "idx"
-				}
-			],
-			"body": [0, [
-				[
-					13,
-					"prev",
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"trailBuf"
-						],
-						"idx"
-					]
-				],
-				[
-					13,
-					"prevA",
-					[
-						1,
-						[
-							7,
-							"prev",
-							"w"
-						],
-						"*",
-						[
-							7,
-							[
-								7,
-								[
-									7,
-									"pfLayout",
-									"$"
-								],
-								"params"
-							],
-							"trails"
-						]
-					]
-				],
-				[
-					13,
-					"win",
-					[
-						1,
-						"curA",
-						">=",
-						"prevA"
-					]
-				],
-				[
-					13,
-					"rgb",
-					[
-						6,
-						"std.select",
-						[
-							[
-								6,
-								"d.vec3f",
-								[
-									[
-										7,
-										"prev",
-										"x"
-									],
-									[
-										7,
-										"prev",
-										"y"
-									],
-									[
-										7,
-										"prev",
-										"z"
-									]
-								]
-							],
-							[
-								6,
-								"d.vec3f",
-								[
-									[
-										7,
-										"col",
-										"x"
-									],
-									[
-										7,
-										"col",
-										"y"
-									],
-									[
-										7,
-										"col",
-										"z"
-									]
-								]
-							],
-							"win"
-						]
-					]
-				],
-				[10, [
-					6,
-					"d.vec4f",
-					[
-						[
-							7,
-							"rgb",
-							"x"
-						],
-						[
-							7,
-							"rgb",
-							"y"
-						],
-						[
-							7,
-							"rgb",
-							"z"
-						],
-						[
-							6,
-							"std.max",
-							["curA", "prevA"]
-						]
-					]
-				]]
-			]]
-		},
-		externals: {
-			"pfLayout": () => pfLayout,
-			"std.select": () => select,
-			"d.vec3f": () => vec3f,
-			"d.vec4f": () => vec4f,
-			"std.max": () => max
-		}
-	}) && $.f)({})).$name("particleFlowTrailComposite") : typegpu_default.fn([
-		vec4f,
-		f32,
-		u32
-	], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((col, curA, _idx) => {
-		"use gpu";
-		return vec4f(col.x, col.y, col.z, curA);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [
-				{
-					"type": "i",
-					"name": "col"
-				},
-				{
-					"type": "i",
-					"name": "curA"
-				},
-				{
-					"type": "i",
-					"name": "_idx"
-				}
-			],
-			"body": [0, [[10, [
-				6,
-				"d.vec4f",
-				[
-					[
-						7,
-						"col",
-						"x"
-					],
-					[
-						7,
-						"col",
-						"y"
-					],
-					[
-						7,
-						"col",
-						"z"
-					],
-					"curA"
-				]
-			]]]]
-		},
-		externals: { "d.vec4f": () => vec4f }
-	}) && $.f)({})).$name("particleFlowTrailComposite");
-	return typegpu_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
-		"use gpu";
-		const prm = pfLayout.$.params;
-		const idx = __tsover_add(__tsover_mul(y, u32(RES)), x);
-		const eRaw = f32(atomicLoad(pfLayout.$.accumE[idx]));
-		atomicStore(pfLayout.$.accumE[idx], u32(0));
-		const sRaw = f32(atomicLoad(pfLayout.$.accumS[idx]));
-		atomicStore(pfLayout.$.accumS[idx], u32(0));
-		const energy = __tsover_mul(eRaw, __tsover_div(1, 255));
-		let col = vec4f(prm.colA);
-		if (eRaw > 0) {
-			const agitAvg = __tsover_div(sRaw, max(eRaw, 1));
-			col = mixFn(prm.colA, prm.colB, clamp(agitAvg, 0, 1));
-		}
-		const curA = __tsover_mul(__tsover_sub(1, exp(__tsover_mul(energy, -1.6))), col.w);
-		const out = composite(col, curA, idx);
-		pfLayout.$.trailBuf[idx] = vec4f(out);
-		textureStore(pfLayout.$.outTex, vec2u(x, y), out);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "x"
-			}, {
-				"type": "i",
-				"name": "y"
-			}],
-			"body": [0, [
-				[
-					13,
-					"prm",
-					[
-						7,
-						[
-							7,
-							"pfLayout",
-							"$"
-						],
-						"params"
-					]
-				],
-				[
-					13,
-					"idx",
-					[
-						1,
-						[
-							1,
-							"y",
-							"*",
-							[
-								6,
-								"d.u32",
-								["RES"]
-							]
-						],
-						"+",
-						"x"
-					]
-				],
-				[
-					13,
-					"eRaw",
-					[
-						6,
-						"d.f32",
-						[[
-							6,
-							"std.atomicLoad",
-							[[
-								8,
-								[
-									7,
-									[
-										7,
-										"pfLayout",
-										"$"
-									],
-									"accumE"
-								],
-								"idx"
-							]]
-						]]
-					]
-				],
-				[
-					6,
-					"std.atomicStore",
-					[[
-						8,
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"accumE"
-						],
-						"idx"
-					], [
-						6,
-						"d.u32",
-						[[5, "0"]]
-					]]
-				],
-				[
-					13,
-					"sRaw",
-					[
-						6,
-						"d.f32",
-						[[
-							6,
-							"std.atomicLoad",
-							[[
-								8,
-								[
-									7,
-									[
-										7,
-										"pfLayout",
-										"$"
-									],
-									"accumS"
-								],
-								"idx"
-							]]
-						]]
-					]
-				],
-				[
-					6,
-					"std.atomicStore",
-					[[
-						8,
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"accumS"
-						],
-						"idx"
-					], [
-						6,
-						"d.u32",
-						[[5, "0"]]
-					]]
-				],
-				[
-					13,
-					"energy",
-					[
-						1,
-						"eRaw",
-						"*",
-						[
-							1,
-							[5, "1"],
-							"/",
-							[5, "255"]
-						]
-					]
-				],
-				[
-					12,
-					"col",
-					[
-						6,
-						"d.vec4f",
-						[[
-							7,
-							"prm",
-							"colA"
-						]]
-					]
-				],
-				[
-					11,
-					[
-						1,
-						"eRaw",
-						">",
-						[5, "0"]
-					],
-					[0, [[
-						13,
-						"agitAvg",
-						[
-							1,
-							"sRaw",
-							"/",
-							[
-								6,
-								"std.max",
-								["eRaw", [5, "1"]]
-							]
-						]
-					], [
-						2,
-						"col",
-						"=",
-						[
-							6,
-							"mixFn",
-							[
-								[
-									7,
-									"prm",
-									"colA"
-								],
-								[
-									7,
-									"prm",
-									"colB"
-								],
-								[
-									6,
-									"std.clamp",
-									[
-										"agitAvg",
-										[5, "0"],
-										[5, "1"]
-									]
-								]
-							]
-						]
-					]]]
-				],
-				[
-					13,
-					"curA",
-					[
-						1,
-						[
-							1,
-							[5, "1"],
-							"-",
-							[
-								6,
-								"std.exp",
-								[[
-									1,
-									"energy",
-									"*",
-									[
-										4,
-										"-",
-										[5, "1.6"]
-									]
-								]]
-							]
-						],
-						"*",
-						[
-							7,
-							"col",
-							"w"
-						]
-					]
-				],
-				[
-					13,
-					"out",
-					[
-						6,
-						"composite",
-						[
-							"col",
-							"curA",
-							"idx"
-						]
-					]
-				],
-				[
-					2,
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"trailBuf"
-						],
-						"idx"
-					],
-					"=",
-					[
-						6,
-						"d.vec4f",
-						["out"]
-					]
-				],
-				[
-					6,
-					"std.textureStore",
-					[
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"outTex"
-						],
-						[
-							6,
-							"d.vec2u",
-							["x", "y"]
-						],
-						"out"
-					]
-				]
-			]]
-		},
-		externals: {
-			"pfLayout": () => pfLayout,
-			"d.u32": () => u32,
-			"RES": () => RES,
-			"d.f32": () => f32,
-			"std.atomicLoad": () => atomicLoad,
-			"std.atomicStore": () => atomicStore,
-			"d.vec4f": () => vec4f,
-			"std.max": () => max,
-			"mixFn": () => mixFn,
-			"std.clamp": () => clamp,
-			"std.exp": () => exp,
-			"composite": () => composite,
-			"std.textureStore": () => textureStore,
-			"d.vec2u": () => vec2u
-		}
-	}) && $.f)({})).$name("particleFlowResolve");
-}
-const particleFlowResolveKernel = makeParticleFlowResolveKernel(2, false);
-const componentDefinition = {
-	name: "ParticleFlow",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Interactive",
-	description: "Thousands of drifting dust particles carried by a real incompressible fluid field the cursor stirs — drag to plow a wake and the particles ride the eddies and vortices it leaves behind, while a gentle ambient breeze keeps the whole scene breathing on its own",
-	requiresRTT: false,
-	requiresChild: false,
-	usesPointer: true,
-	props: {
-		colorA: {
-			default: "#8ec5ff",
-			transform: transformColor,
-			description: "Color of particles drifting slowly with the flow",
-			ui: {
-				type: "color",
-				label: "Rest Color",
-				group: "Colors"
-			}
-		},
-		colorB: {
-			default: "#ffd98e",
-			transform: transformColor,
-			description: "Color particles flash toward as they speed up in the fast jets and wakes",
-			ui: {
-				type: "color",
-				label: "Excited Color",
-				group: "Colors"
-			}
-		},
-		colorSpace: {
-			default: "oklab",
-			transform: transformColorSpace,
-			compileTime: true,
-			description: "Color space for the rest→excited color ramp",
-			ui: {
-				type: "select",
-				options: colorSpaceOptions,
-				label: "Color Space",
-				group: "Colors"
-			}
-		},
-		shape: {
-			default: "streak",
-			compileTime: true,
-			description: "What each particle is drawn as — a streak or arrow that stretches along the flow, a plain dot, a square, or a soft glowing comet",
-			ui: {
-				type: "select",
-				options: orientedShapeOptions,
-				label: "Shape",
-				group: "Particles"
-			}
-		},
-		count: {
-			default: 6e3,
-			description: "Number of drifting particles",
-			ui: {
-				type: "range",
-				min: 1e3,
-				max: 16e3,
-				step: 500,
-				label: "Count",
-				group: "Particles"
-			}
-		},
-		size: {
-			default: 1.2,
-			description: "Size of each particle",
-			ui: {
-				type: "range",
-				min: .3,
-				max: 3,
-				step: .05,
-				label: "Size",
-				group: "Particles"
-			}
-		},
-		trails: {
-			default: 0,
-			compileTimeWhen: (previousValue, newValue) => previousValue > 0 !== newValue > 0,
-			description: "How long each particle's motion trail persists — 0 draws crisp dust, 1 leaves long flowing ribbons",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Trails",
-				group: "Particles"
-			}
-		},
-		speed: {
-			default: 1,
-			description: "How strongly the fluid carries the particles — higher makes the dust ride the flow faster",
-			ui: {
-				type: "range",
-				min: .2,
-				max: 3,
-				step: .05,
-				label: "Flow Speed",
-				group: "Particles"
-			}
-		},
-		force: {
-			default: 1,
-			description: "How hard the cursor's motion pushes the fluid — higher plows faster, more violent wakes and jets",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 3,
-				step: .05,
-				label: "Cursor Force",
-				group: "Dynamics"
-			}
-		},
-		swirl: {
-			default: 25,
-			description: "Vorticity confinement — swirl energy that spins the flow into persistent eddies and vortices the dust orbits",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 60,
-				step: 1,
-				label: "Swirl",
-				group: "Dynamics"
-			}
-		},
-		momentum: {
-			default: .6,
-			description: "How long the fluid keeps flowing after you stop dragging — high momentum lets the eddies carry the dust on and on",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Momentum",
-				group: "Dynamics"
-			}
-		},
-		ambient: {
-			default: .15,
-			description: "A gentle, ever-evolving breeze that keeps the dust drifting even without the cursor — set to 0 for a field that only moves when you stir it",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Ambient",
-				group: "Dynamics"
-			}
-		}
-	},
-	compute: (params) => {
-		const { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
-		const root = gpu?.root;
-		if (!root) return null;
-		const velA = createStateBuffer(root, vec4f, FLUID_COUNT);
-		const velB = createStateBuffer(root, vec4f, FLUID_COUNT);
-		const pressure = createStateBuffer(root, f32, FLUID_COUNT);
-		const divergence = createStateBuffer(root, f32, FLUID_COUNT);
-		const particles = createStateBuffer(root, vec4f, MAX_PARTICLES);
-		const accumE = createStateBuffer(root, atomic(u32), RES * RES);
-		const accumS = createStateBuffer(root, atomic(u32), RES * RES);
-		const trailBuf = createStateBuffer(root, vec4f, RES * RES);
-		const velTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-			size: [N, N],
-			format: VEL_FORMAT
-		}).$usage("storage", "sampled"), "velTex");
-		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
-			size: [RES, RES],
-			format: STATE_FORMAT
-		}).$usage("storage", "sampled"), "outTex");
-		onCleanup(() => {
-			velTex.destroy();
-			outTex.destroy();
-		});
-		const flowTexture = registerComputeTexture(outTex);
-		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(FlowParams), "paramsU");
-		const splatU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(SplatParams), "splatU");
-		const simU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(SimParams), "simU");
-		const fluidBg = root.createBindGroup(fluidLayout, {
-			velA,
-			velB,
-			pressure,
-			divergence,
-			params: paramsU.buffer,
-			sparams: splatU.buffer,
-			velOutTex: velTex
-		});
-		const pfBg = root.createBindGroup(pfLayout, {
-			particles,
-			accumE,
-			accumS,
-			trailBuf,
-			velTex,
-			params: simU.buffer,
-			outTex
-		});
-		const fluidSize = [N, N];
-		const force = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			particleFlowForceKernel(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"particleFlowForceKernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "particleFlowForceKernel": () => particleFlowForceKernel }
-		}) && $.f)({}), {
-			size: fluidSize,
-			bindGroup: fluidBg
-		});
-		const vorticity = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
-			"use gpu";
-			particleFlowVorticityKernel(cx, cy);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "cx"
-				}, {
-					"type": "i",
-					"name": "cy"
-				}],
-				"body": [0, [[
-					6,
-					"particleFlowVorticityKernel",
-					["cx", "cy"]
-				]]]
-			},
-			externals: { "particleFlowVorticityKernel": () => particleFlowVorticityKernel }
-		}) && $.f)({}), {
-			size: fluidSize,
-			bindGroup: fluidBg
-		});
-		const solver = createStableFluidsPasses(root, solverKernels, {
-			n: N,
-			bindGroup: fluidBg
-		});
-		const trailsCpu = getCpuValue("trails");
-		const splatKernel = makeParticleFlowSplatKernel(getCpuValue("shape") || "streak");
-		const resolveKernel = makeParticleFlowResolveKernel(getCpuValue("colorSpace") ?? 2, typeof trailsCpu === "number" && trailsCpu > 0);
-		const init = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-			"use gpu";
-			particleFlowInitKernel(i);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "i"
-				}],
-				"body": [0, [[
-					6,
-					"particleFlowInitKernel",
-					["i"]
-				]]]
-			},
-			externals: { "particleFlowInitKernel": () => particleFlowInitKernel }
-		}) && $.f)({})).with(pfBg);
-		const integrate = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-			"use gpu";
-			particleFlowIntegrateKernel(i);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "i"
-				}],
-				"body": [0, [[
-					6,
-					"particleFlowIntegrateKernel",
-					["i"]
-				]]]
-			},
-			externals: { "particleFlowIntegrateKernel": () => particleFlowIntegrateKernel }
-		}) && $.f)({})).with(pfBg);
-		const splat = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-			"use gpu";
-			splatKernel(i);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "i"
-				}],
-				"body": [0, [[
-					6,
-					"splatKernel",
-					["i"]
-				]]]
-			},
-			externals: { "splatKernel": () => splatKernel }
-		}) && $.f)({})).with(pfBg);
-		const resolve = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
-			"use gpu";
-			resolveKernel(x, y);
-		}), {
-			v: 2,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "x"
-				}, {
-					"type": "i",
-					"name": "y"
-				}],
-				"body": [0, [[
-					6,
-					"resolveKernel",
-					["x", "y"]
-				]]]
-			},
-			externals: { "resolveKernel": () => resolveKernel }
-		}) && $.f)({}), { size: [RES, RES] }).with(pfBg);
-		let lastTime = Date.now();
-		let ambientTime = 0;
-		let initialized = false;
-		const pointer = createPointerVelocityTracker();
-		const idle = createIdleGate({ warmupFrames: WARMUP_FRAMES + 1 });
-		const countCap = isMobileGpuViewport() ? COUNT_MAX_MOBILE : MAX_PARTICLES;
-		const num = (key, fallback) => {
-			const v = getCpuValue(key);
-			return typeof v === "number" ? v : fallback;
-		};
-		return {
-			outputs: { flowTexture },
-			getComputeNodes: (frameParams) => {
-				const fp = frameParams;
-				const now = Date.now();
-				const dt = Math.min(fp.deltaTime ?? (now - lastTime) / 1e3, .033);
-				lastTime = now;
-				if (dt < .001) return null;
-				const h = fp.dimensions?.height ?? 0;
-				const aspect = h > 0 ? (fp.dimensions?.width ?? 0) / h : 16 / 9;
-				const domainX = Math.max(aspect, .01);
-				const forceVal = num("force", 1);
-				const swirl = num("swirl", 25);
-				const ambient = Math.min(Math.max(num("ambient", .15), 0), 1);
-				const momentum = Math.min(Math.max(num("momentum", .6), 0), 1);
-				const advect = num("speed", 1);
-				const count = Math.min(Math.max(Math.round(num("count", 6e3)), 100), countCap);
-				const bodyR = Math.min(Math.max(num("size", 1.2), .3), 3) * 1.3 / SIZE_REF_RES;
-				const ptr = pointer.update(fp.pointer, dt);
-				const active = ptr.moving || ambient > .001;
-				if (active) idle.markActive(now);
-				ambientTime += dt * AMBIENT_DRIFT;
-				if (initialized && idle.shouldSkip(now, 2 + momentum * 13, active)) return null;
-				idle.tickFrame();
-				const velFade = VEL_FADE_MAX * Math.pow(VEL_FADE_MIN / VEL_FADE_MAX, momentum);
-				paramsU.write({
-					dt,
-					curlStrength: swirl,
-					velFade,
-					ambient,
-					ambientTime,
-					ambientFreq: AMBIENT_FREQ
-				});
-				const colA = getCpuValue("colorA");
-				const colB = getCpuValue("colorB");
-				simU.write({
-					colA: vec4f(colA?.x ?? .56, colA?.y ?? .77, colA?.z ?? 1, colA?.w ?? 1),
-					colB: vec4f(colB?.x ?? 1, colB?.y ?? .85, colB?.z ?? .56, colB?.w ?? 1),
-					dt,
-					aspect: domainX,
-					trails: Math.min(Math.max(num("trails", 0), 0), 1) * .92,
-					bodyR,
-					speedNorm: SPEED_NORM,
-					advect
-				});
-				const nodes = [];
-				if (!initialized) {
-					initialized = true;
-					nodes.push(() => init.dispatchThreads(MAX_PARTICLES));
-				}
-				if (ptr.moving) {
-					const velX = ptr.velX * N * forceVal * IMPULSE_K;
-					const velY = ptr.velY * N * forceVal * IMPULSE_K;
-					pathStampRibbon(nodes, {
-						fromX: ptr.prevX,
-						fromY: ptr.prevY,
-						dx: ptr.dx,
-						dy: ptr.dy,
-						dragDist: ptr.dragDist,
-						stepSize: Math.max(.004, FORCE_RADIUS_GRID / N * .6),
-						maxSteps: MAX_STEPS,
-						scale: N,
-						write: (posX, posY) => splatU.write({
-							posX,
-							posY,
-							velX,
-							velY,
-							radius: FORCE_RADIUS_GRID
-						}),
-						pass: force
-					});
-				}
-				nodes.push(...solver.solveSteps({
-					jacobiIters: JACOBI_ITERS,
-					vorticity
-				}));
-				nodes.push(() => integrate.dispatchThreads(count), () => splat.dispatchThreads(count), resolve);
-				return nodes;
-			}
-		};
-	},
-	fragment: ({ ctx, computeOutputs }) => {
-		const flowField = computeOutputs?.flowTexture;
-		if (!flowField) return ZERO;
-		return flowField.sample(ctx.uv, "linearClamp");
-	}
-};
-var ParticleFlow_default = componentDefinition;
-export { particleFlowAdvectVelKernel as a, particleFlowDivergenceKernel as c, particleFlowInitKernel as d, particleFlowIntegrateKernel as f, particleFlowVorticityKernel as g, particleFlowSplatKernel as h, makeParticleFlowSplatKernel as i, particleFlowForceKernel as l, particleFlowResolveKernel as m, componentDefinition as n, particleFlowCopyVelKernel as o, particleFlowJacobiKernel as p, makeParticleFlowResolveKernel as r, particleFlowCurlKernel as s, ParticleFlow_default as t, particleFlowGradSubtractKernel as u };