shaders 3.0.448 → 3.0.450

package/dist/core/{ParticleFlow-DiHWbIon.js → ParticleFlow-RPxLP8HC.js}

@@ -1,16 +1,21 @@
-import { Bt as ZERO, J as std, Tn as d, X as createGuardedCompute, Z as createStateBuffer, c as orientedShapeOptions, gn as mixColorsVariants, hn as mixColorsLinear, lt as hash33, n as tgpu, pt as noise_exports, r as AGENT_SHAPES, rt as curl22z, s as makeAgentWeightFn, u as resolveAgentShape } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { At as mix, Bt as sqrt, Ct as exp, Dt as length, Et as fract, Gt as arrayOf, H as mixColorsLinear, Kt as texture2d, Ot as max, Qt as struct, Tt as floor, U as mixColorsVariants, Ut as data_exports, Wt as atomic, cn as i32, d as ZERO, dt as atomicLoad, et as src_default, ft as atomicStore, ht as abs, in as vec3f, it as textureLoad, kt as min, ln as u32, mt as select, nt as std_exports, on as vec4f, ot as textureStore, qt as textureStorage2d, rn as vec2u, sn as f32, tn as vec2f, ut as atomicAdd, vt as ceil, yt as clamp } from "./edges-BZUKQxSE.js";
+import { l as hash33, p as noise_exports, r as curl22z } from "./noise-Cq0KUOSC.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BoeIXi0l.js";
+import { t as isMobileGpuViewport } from "./device-BODv_4aH.js";
+import { a as makeAgentTexelWeightFn, l as resolveAgentShape, s as orientedShapeOptions, t as AGENT_SHAPES } from "./agents-c-JjGH1b.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var N = 256;
 var FLUID_COUNT = N * N;
-var JACOBI_ITERS = 10;
+var JACOBI_ITERS = isMobileGpuViewport() ? 6 : 10;
 var PRESSURE_DISSIPATION = .8;
 var VEL_FORMAT = "rgba16float";
-var RES = 1024;
+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 SPLAT_WIN = 29;
 var AA_W = .75 * INV_RES;
 var HARD_GAIN = 637;
 var SOFT_GAIN = 255;
@@ -25,83 +30,83 @@ var AMBIENT_DRIFT = .09;
 var INERTIA_RATE = 6;
 var SPEED_NORM = .35;
 var WARMUP_FRAMES = 3;
-var FlowParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	dt: d.f32,
-	curlStrength: d.f32,
-	velFade: d.f32,
-	ambient: d.f32,
-	ambientTime: d.f32,
-	ambientFreq: d.f32
+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))(d.struct({
-	posX: d.f32,
-	posY: d.f32,
-	velX: d.f32,
-	velY: d.f32,
-	radius: d.f32
+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))(d.struct({
-	colA: d.vec4f,
-	colB: d.vec4f,
-	dt: d.f32,
-	aspect: d.f32,
-	trails: d.f32,
-	bodyR: d.f32,
-	speedNorm: d.f32,
-	advect: d.f32
+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))(tgpu.bindGroupLayout({
+var fluidLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	velA: {
-		storage: d.arrayOf(d.vec4f, FLUID_COUNT),
+		storage: arrayOf(vec4f, FLUID_COUNT),
 		access: "mutable"
 	},
 	velB: {
-		storage: d.arrayOf(d.vec4f, FLUID_COUNT),
+		storage: arrayOf(vec4f, FLUID_COUNT),
 		access: "mutable"
 	},
 	pressure: {
-		storage: d.arrayOf(d.f32, FLUID_COUNT),
+		storage: arrayOf(f32, FLUID_COUNT),
 		access: "mutable"
 	},
 	divergence: {
-		storage: d.arrayOf(d.f32, FLUID_COUNT),
+		storage: arrayOf(f32, FLUID_COUNT),
 		access: "mutable"
 	},
 	params: { uniform: FlowParams },
 	sparams: { uniform: SplatParams },
-	velOutTex: { storageTexture: d.textureStorage2d(VEL_FORMAT, "write-only") }
+	velOutTex: { storageTexture: textureStorage2d(VEL_FORMAT, "write-only") }
 }), "fluidLayout");
-var pfLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var pfLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	particles: {
-		storage: d.arrayOf(d.vec4f, MAX_PARTICLES),
+		storage: arrayOf(vec4f, MAX_PARTICLES),
 		access: "mutable"
 	},
 	accumE: {
-		storage: d.arrayOf(d.atomic(d.u32), RES * RES),
+		storage: arrayOf(atomic(u32), RES * RES),
 		access: "mutable"
 	},
 	accumS: {
-		storage: d.arrayOf(d.atomic(d.u32), RES * RES),
+		storage: arrayOf(atomic(u32), RES * RES),
 		access: "mutable"
 	},
 	trailBuf: {
-		storage: d.arrayOf(d.vec4f, RES * RES),
+		storage: arrayOf(vec4f, RES * RES),
 		access: "mutable"
 	},
-	velTex: { texture: d.texture2d(d.f32) },
+	velTex: { texture: texture2d(f32) },
 	params: { uniform: SimParams },
-	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "pfLayout");
-var nidx = tgpu.fn([
-	d.i32,
-	d.i32,
-	d.i32,
-	d.i32
-], d.u32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ii, ji, di, dj) => {
+var nidx = src_default.fn([
+	i32,
+	i32,
+	i32,
+	i32
+], u32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ii, ji, di, dj) => {
 	"use gpu";
-	const row = std.clamp(__tsover_add(ii, di), 0, __tsover_sub(N, 1));
-	const col = std.clamp(__tsover_add(ji, dj), 0, __tsover_sub(N, 1));
-	return d.u32(__tsover_add(__tsover_mul(row, N), col));
+	const row = clamp(__tsover_add(ii, di), 0, __tsover_sub(N, 1));
+	const col = clamp(__tsover_add(ji, dj), 0, __tsover_sub(N, 1));
+	return u32(__tsover_add(__tsover_mul(row, N), col));
 }), {
 	v: 1,
 	name: void 0,
@@ -206,24 +211,24 @@ var nidx = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		N,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const particleFlowForceKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const particleFlowForceKernel = src_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, d.u32(N)), cx);
-	const cellX = __tsover_add(d.f32(cx), .5);
-	const cellY = __tsover_add(d.f32(cy), .5);
+	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 distSq = __tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy));
-	const radSq = std.max(__tsover_mul(p.radius, p.radius), d.f32(1));
-	const inf = std.exp(__tsover_mul(__tsover_div(distSq, radSq), -1));
+	const radSq = max(__tsover_mul(p.radius, p.radius), f32(1));
+	const inf = exp(__tsover_mul(__tsover_div(distSq, radSq), -1));
 	const vel = fluidLayout.$.velA[idx];
-	fluidLayout.$.velA[idx] = d.vec4f(__tsover_add(vel.x, __tsover_mul(p.velX, inf)), __tsover_add(vel.y, __tsover_mul(p.velY, inf)), vel.z, 0);
+	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: 1,
 	name: void 0,
@@ -515,23 +520,23 @@ const particleFlowForceKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) =>
 	},
 	externals: () => ({
 		fluidLayout,
-		d,
+		d: data_exports,
 		N,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("particleFlowForce");
-const particleFlowCurlKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const particleFlowCurlKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
 	const vL = fluidLayout.$.velA[nidx(ii, ji, 0, -1)];
 	const vR = fluidLayout.$.velA[nidx(ii, ji, 0, 1)];
 	const vU = fluidLayout.$.velA[nidx(ii, ji, -1, 0)];
 	const vD = fluidLayout.$.velA[nidx(ii, ji, 1, 0)];
 	const curl = __tsover_mul(__tsover_sub(__tsover_sub(vR.y, vL.y), __tsover_sub(vD.x, vU.x)), .5);
 	const vel = fluidLayout.$.velA[idx];
-	fluidLayout.$.velA[idx] = d.vec4f(vel.x, vel.y, curl, 0);
+	fluidLayout.$.velA[idx] = vec4f(vel.x, vel.y, curl, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -811,34 +816,40 @@ const particleFlowCurlKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx
 	})
 }) && $.f)({})).$name("particleFlowCurl");
-const particleFlowVorticityKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const particleFlowVorticityKernel = src_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, d.u32(N)), cx);
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
-	const cL = std.abs(fluidLayout.$.velA[nidx(ii, ji, 0, -1)].z);
-	const cR = std.abs(fluidLayout.$.velA[nidx(ii, ji, 0, 1)].z);
-	const cU = std.abs(fluidLayout.$.velA[nidx(ii, ji, -1, 0)].z);
-	const cD = std.abs(fluidLayout.$.velA[nidx(ii, ji, 1, 0)].z);
+	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 = std.max(std.sqrt(__tsover_add(__tsover_mul(gx, gx), __tsover_mul(gy, gy))), d.f32(1e-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);
-	const uvx = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(N));
-	const uvy = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(N));
-	const amb = curl22z(d.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);
+	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] = d.vec4f(__tsover_add(__tsover_add(vel.x, fx), __tsover_mul(amb.x, af)), __tsover_add(__tsover_add(vel.y, fy), __tsover_mul(amb.y, af)), vel.z, 0);
+	fluidLayout.$.velA[idx] = vec4f(__tsover_add(__tsover_add(vel.x, fx), ax), __tsover_add(__tsover_add(vel.y, fy), ay), vel.z, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -1244,132 +1255,203 @@ const particleFlowVorticityKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($)
 				]
 			],
 			[
-				13,
-				"uvx",
+				12,
+				"ax",
 				[
-					1,
+					6,
 					[
-						1,
-						[
-							6,
-							[
-								7,
-								"d",
-								"f32"
-							],
-							["cx"]
-						],
-						"+",
-						[5, "0.5"]
+						7,
+						"d",
+						"f32"
 					],
-					"/",
-					[
-						6,
-						[
-							7,
-							"d",
-							"f32"
-						],
-						["N"]
-					]
+					[[5, "0"]]
 				]
 			],
 			[
-				13,
-				"uvy",
+				12,
+				"ay",
 				[
-					1,
+					6,
 					[
-						1,
-						[
-							6,
-							[
-								7,
-								"d",
-								"f32"
-							],
-							["cy"]
-						],
-						"+",
-						[5, "0.5"]
+						7,
+						"d",
+						"f32"
 					],
-					"/",
-					[
-						6,
-						[
-							7,
-							"d",
-							"f32"
-						],
-						["N"]
-					]
+					[[5, "0"]]
 				]
 			],
 			[
-				13,
-				"amb",
+				11,
 				[
-					6,
+					1,
 					[
 						7,
-						"noise",
-						"curl22z"
+						"p",
+						"ambient"
 					],
-					[[
-						6,
+					">",
+					[5, "0"]
+				],
+				[0, [
+					[
+						13,
+						"uvx",
 						[
-							7,
-							"d",
-							"vec2f"
-						],
-						[[
 							1,
-							"uvx",
-							"*",
 							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["cx"]
+								],
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["N"]
+							]
+						]
+					],
+					[
+						13,
+						"uvy",
+						[
+							1,
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["cy"]
+								],
+								"+",
+								[5, "0.5"]
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["N"]
+							]
+						]
+					],
+					[
+						13,
+						"amb",
+						[
+							6,
+							[
+								7,
+								"noise",
+								"curl22z"
+							],
+							[[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								[[
+									1,
+									"uvx",
+									"*",
+									[
+										7,
+										"p",
+										"ambientFreq"
+									]
+								], [
+									1,
+									"uvy",
+									"*",
+									[
+										7,
+										"p",
+										"ambientFreq"
+									]
+								]]
+							], [
 								7,
 								"p",
-								"ambientFreq"
-							]
-						], [
+								"ambientTime"
+							]]
+						]
+					],
+					[
+						13,
+						"af",
+						[
 							1,
-							"uvy",
+							[
+								1,
+								[
+									7,
+									"p",
+									"ambient"
+								],
+								"*",
+								"AMBIENT_K"
+							],
 							"*",
 							[
 								7,
 								"p",
-								"ambientFreq"
+								"dt"
 							]
-						]]
-					], [
-						7,
-						"p",
-						"ambientTime"
-					]]
-				]
-			],
-			[
-				13,
-				"af",
-				[
-					1,
+						]
+					],
 					[
-						1,
+						2,
+						"ax",
+						"=",
 						[
-							7,
-							"p",
-							"ambient"
-						],
-						"*",
-						"AMBIENT_K"
+							1,
+							[
+								7,
+								"amb",
+								"x"
+							],
+							"*",
+							"af"
+						]
 					],
-					"*",
 					[
-						7,
-						"p",
-						"dt"
+						2,
+						"ay",
+						"=",
+						[
+							1,
+							[
+								7,
+								"amb",
+								"y"
+							],
+							"*",
+							"af"
+						]
 					]
-				]
+				]]
 			],
 			[
 				13,
@@ -1425,16 +1507,7 @@ const particleFlowVorticityKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($)
 								"fx"
 							],
 							"+",
-							[
-								1,
-								[
-									7,
-									"amb",
-									"x"
-								],
-								"*",
-								"af"
-							]
+							"ax"
 						],
 						[
 							1,
@@ -1449,16 +1522,7 @@ const particleFlowVorticityKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($)
 								"fy"
 							],
 							"+",
-							[
-								1,
-								[
-									7,
-									"amb",
-									"y"
-								],
-								"*",
-								"af"
-							]
+							"ay"
 						],
 						[
 							7,
@@ -1482,30 +1546,30 @@ const particleFlowVorticityKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($)
 	},
 	externals: () => ({
 		fluidLayout,
-		d,
+		d: data_exports,
 		N,
-		std,
+		std: std_exports,
 		nidx,
 		noise: noise_exports,
 		AMBIENT_K
 	})
 }) && $.f)({})).$name("particleFlowVorticity");
-const particleFlowDivergenceKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const particleFlowDivergenceKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
-	const jf = d.f32(cx);
-	const iF = d.f32(cy);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
+	const jf = f32(cx);
+	const iF = f32(cy);
 	const selfVel = fluidLayout.$.velA[idx];
 	const normalL = fluidLayout.$.velA[nidx(ii, ji, 0, -1)].x;
 	const normalR = fluidLayout.$.velA[nidx(ii, ji, 0, 1)].x;
 	const normalU = fluidLayout.$.velA[nidx(ii, ji, -1, 0)].y;
 	const normalD = fluidLayout.$.velA[nidx(ii, ji, 1, 0)].y;
-	const L = std.select(normalL, __tsover_mul(selfVel.x, -1), jf < .5);
-	const R = std.select(normalR, __tsover_mul(selfVel.x, -1), jf > d.f32(__tsover_sub(N, 1.5)));
-	const T = std.select(normalU, __tsover_mul(selfVel.y, -1), iF < .5);
-	const B = std.select(normalD, __tsover_mul(selfVel.y, -1), iF > d.f32(__tsover_sub(N, 1.5)));
+	const L = select(normalL, __tsover_mul(selfVel.x, -1), jf < .5);
+	const R = select(normalR, __tsover_mul(selfVel.x, -1), jf > f32(__tsover_sub(N, 1.5)));
+	const T = select(normalU, __tsover_mul(selfVel.y, -1), iF < .5);
+	const B = select(normalD, __tsover_mul(selfVel.y, -1), iF > f32(__tsover_sub(N, 1.5)));
 	const div = __tsover_mul(__tsover_add(__tsover_sub(R, L), __tsover_sub(B, T)), .5);
 	fluidLayout.$.pressure[idx] = __tsover_mul(fluidLayout.$.pressure[idx], PRESSURE_DISSIPATION);
 	fluidLayout.$.divergence[idx] = div;
@@ -1996,19 +2060,19 @@ const particleFlowDivergenceKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx,
-		std,
+		std: std_exports,
 		PRESSURE_DISSIPATION
 	})
 }) && $.f)({})).$name("particleFlowDivergence");
-const particleFlowJacobiKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const particleFlowJacobiKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
 	const pL = fluidLayout.$.pressure[nidx(ii, ji, 0, -1)];
 	const pR = fluidLayout.$.pressure[nidx(ii, ji, 0, 1)];
 	const pU = fluidLayout.$.pressure[nidx(ii, ji, -1, 0)];
@@ -2257,23 +2321,23 @@ const particleFlowJacobiKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) =>
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx
 	})
 }) && $.f)({})).$name("particleFlowJacobi");
-const particleFlowGradSubtractKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const particleFlowGradSubtractKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
 	const pL = fluidLayout.$.pressure[nidx(ii, ji, 0, -1)];
 	const pR = fluidLayout.$.pressure[nidx(ii, ji, 0, 1)];
 	const pU = fluidLayout.$.pressure[nidx(ii, ji, -1, 0)];
 	const pD = fluidLayout.$.pressure[nidx(ii, ji, 1, 0)];
 	const vel = fluidLayout.$.velA[idx];
-	fluidLayout.$.velA[idx] = d.vec4f(__tsover_sub(vel.x, __tsover_mul(__tsover_sub(pR, pL), .5)), __tsover_sub(vel.y, __tsover_mul(__tsover_sub(pD, pU), .5)), vel.z, 0);
+	fluidLayout.$.velA[idx] = vec4f(__tsover_sub(vel.x, __tsover_mul(__tsover_sub(pR, pL), .5)), __tsover_sub(vel.y, __tsover_mul(__tsover_sub(pD, pU), .5)), vel.z, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -2546,31 +2610,31 @@ const particleFlowGradSubtractKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx
 	})
 }) && $.f)({})).$name("particleFlowGradSubtract");
-const particleFlowAdvectVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const particleFlowAdvectVelKernel = src_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, d.u32(N)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
 	const vel = fluidLayout.$.velA[idx];
-	const srcX = std.clamp(__tsover_sub(d.f32(cx), __tsover_mul(vel.x, p.dt)), 0, d.f32(__tsover_sub(N, 1)));
-	const srcY = std.clamp(__tsover_sub(d.f32(cy), __tsover_mul(vel.y, p.dt)), 0, d.f32(__tsover_sub(N, 1)));
-	const x0 = std.clamp(std.floor(srcX), 0, d.f32(__tsover_sub(N, 2)));
-	const y0 = std.clamp(std.floor(srcY), 0, d.f32(__tsover_sub(N, 2)));
+	const srcX = clamp(__tsover_sub(f32(cx), __tsover_mul(vel.x, p.dt)), 0, f32(__tsover_sub(N, 1)));
+	const srcY = clamp(__tsover_sub(f32(cy), __tsover_mul(vel.y, p.dt)), 0, f32(__tsover_sub(N, 1)));
+	const x0 = clamp(floor(srcX), 0, f32(__tsover_sub(N, 2)));
+	const y0 = clamp(floor(srcY), 0, f32(__tsover_sub(N, 2)));
 	const sx = __tsover_sub(srcX, x0);
 	const sy = __tsover_sub(srcY, y0);
-	const ix0 = d.i32(x0);
-	const iy0 = d.i32(y0);
-	const v00 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_mul(iy0, N), ix0))];
-	const v10 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_add(__tsover_mul(iy0, N), ix0), 1))];
-	const v01 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0))];
-	const v11 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0), 1))];
+	const ix0 = i32(x0);
+	const iy0 = i32(y0);
+	const v00 = fluidLayout.$.velA[u32(__tsover_add(__tsover_mul(iy0, N), ix0))];
+	const v10 = fluidLayout.$.velA[u32(__tsover_add(__tsover_add(__tsover_mul(iy0, N), ix0), 1))];
+	const v01 = fluidLayout.$.velA[u32(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0))];
+	const v11 = fluidLayout.$.velA[u32(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0), 1))];
 	const decay = __tsover_add(1, __tsover_mul(p.velFade, p.dt));
-	fluidLayout.$.velB[idx] = d.vec4f(__tsover_div(std.mix(std.mix(v00.x, v10.x, sx), std.mix(v01.x, v11.x, sx), sy), decay), __tsover_div(std.mix(std.mix(v00.y, v10.y, sx), std.mix(v01.y, v11.y, sx), sy), decay), 0, 0);
+	fluidLayout.$.velB[idx] = vec4f(__tsover_div(mix(mix(v00.x, v10.x, sx), mix(v01.x, v11.x, sx), sy), decay), __tsover_div(mix(mix(v00.y, v10.y, sx), mix(v01.y, v11.y, sx), sy), decay), 0, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -3208,17 +3272,17 @@ const particleFlowAdvectVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($)
 	},
 	externals: () => ({
 		fluidLayout,
-		d,
+		d: data_exports,
 		N,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("particleFlowAdvectVel");
-const particleFlowCopyVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const particleFlowCopyVelKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
 	const v = fluidLayout.$.velB[idx];
-	fluidLayout.$.velA[idx] = d.vec4f(v.x, v.y, 0, 0);
-	std.textureStore(fluidLayout.$.velOutTex, d.vec2u(cx, cy), d.vec4f(v.x, v.y, 0, 0));
+	fluidLayout.$.velA[idx] = vec4f(v.x, v.y, 0, 0);
+	textureStore(fluidLayout.$.velOutTex, vec2u(cx, cy), vec4f(v.x, v.y, 0, 0));
 }), {
 	v: 1,
 	name: void 0,
@@ -3369,18 +3433,18 @@ const particleFlowCopyVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) =
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("particleFlowCopyVel");
-const particleFlowInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+const particleFlowInitKernel = src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 	"use gpu";
 	const prm = pfLayout.$.params;
-	const fi = d.f32(i);
-	const r = hash33(d.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] = d.vec4f(__tsover_mul(r.x, prm.aspect), r.y, 0, 0);
+	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: 1,
 	name: void 0,
@@ -3528,189 +3592,76 @@ const particleFlowInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalT
 	},
 	externals: () => ({
 		pfLayout,
-		d,
+		d: data_exports,
 		noise: noise_exports
 	})
 }) && $.f)({})).$name("particleFlowInit");
-const particleFlowClearKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+var R2A = .7548776662466927;
+var R2B = .5698402909980532;
+var HOME_RATE = 1.8;
+const particleFlowIntegrateKernel = src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(y, d.u32(RES)), x);
-	std.atomicStore(pfLayout.$.accumE[idx], d.u32(0));
-	std.atomicStore(pfLayout.$.accumS[idx], d.u32(0));
+	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: 1,
 	name: void 0,
 	ast: {
 		"params": [{
 			"type": "i",
-			"name": "x"
-		}, {
-			"type": "i",
-			"name": "y"
+			"name": "i"
 		}],
 		"body": [0, [
 			[
 				13,
-				"idx",
+				"prm",
 				[
-					1,
+					7,
 					[
-						1,
-						"y",
-						"*",
-						[
-							6,
-							[
-								7,
-								"d",
-								"u32"
-							],
-							["RES"]
-						]
+						7,
+						"pfLayout",
+						"$"
 					],
-					"+",
-					"x"
+					"params"
 				]
 			],
 			[
-				6,
-				[
-					7,
-					"std",
-					"atomicStore"
-				],
-				[[
-					8,
-					[
-						7,
-						[
-							7,
-							"pfLayout",
-							"$"
-						],
-						"accumE"
-					],
-					"idx"
-				], [
-					6,
-					[
-						7,
-						"d",
-						"u32"
-					],
-					[[5, "0"]]
-				]]
-			],
-			[
-				6,
-				[
-					7,
-					"std",
-					"atomicStore"
-				],
-				[[
-					8,
-					[
-						7,
-						[
-							7,
-							"pfLayout",
-							"$"
-						],
-						"accumS"
-					],
-					"idx"
-				], [
-					6,
-					[
-						7,
-						"d",
-						"u32"
-					],
-					[[5, "0"]]
-				]]
-			]
-		]],
-		"externalNames": [
-			"d",
-			"RES",
-			"std",
-			"pfLayout"
-		]
-	},
-	externals: () => ({
-		d,
-		RES,
-		std,
-		pfLayout
-	})
-}) && $.f)({})).$name("particleFlowClear");
-var R2A = .7548776662466927;
-var R2B = .5698402909980532;
-var HOME_RATE = 1.8;
-const particleFlowIntegrateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-	"use gpu";
-	const prm = pfLayout.$.params;
-	const a = pfLayout.$.particles[i];
-	const pos = d.vec2f(a.x, a.y);
-	const dt = prm.dt;
-	const aspect = std.max(prm.aspect, 1e-5);
-	const uvx = __tsover_div(pos.x, aspect);
-	const uvy = pos.y;
-	const NF = d.f32(N);
-	const su = __tsover_sub(__tsover_mul(uvx, NF), .5);
-	const sv = __tsover_sub(__tsover_mul(uvy, NF), .5);
-	const x0 = std.floor(su);
-	const y0 = std.floor(sv);
-	const fx = __tsover_sub(su, x0);
-	const fy = __tsover_sub(sv, y0);
-	const maxT = __tsover_sub(NF, 1);
-	const ix0 = d.u32(std.clamp(x0, 0, maxT));
-	const ix1 = d.u32(std.clamp(__tsover_add(x0, 1), 0, maxT));
-	const iy0 = d.u32(std.clamp(y0, 0, maxT));
-	const iy1 = d.u32(std.clamp(__tsover_add(y0, 1), 0, maxT));
-	const v00 = std.textureLoad(pfLayout.$.velTex, d.vec2u(ix0, iy0), 0);
-	const v10 = std.textureLoad(pfLayout.$.velTex, d.vec2u(ix1, iy0), 0);
-	const v01 = std.textureLoad(pfLayout.$.velTex, d.vec2u(ix0, iy1), 0);
-	const v11 = std.textureLoad(pfLayout.$.velTex, d.vec2u(ix1, iy1), 0);
-	const gvx = std.mix(std.mix(v00.x, v10.x, fx), std.mix(v01.x, v11.x, fx), fy);
-	const gvy = std.mix(std.mix(v00.y, v10.y, fx), std.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, std.exp(__tsover_mul(__tsover_mul(dt, INERTIA_RATE), -1)));
-	const fi = d.f32(i);
-	const homeX = __tsover_mul(std.fract(__tsover_add(.5, __tsover_mul(fi, R2A))), aspect);
-	const homeY = std.fract(__tsover_add(.5, __tsover_mul(fi, R2B)));
-	const velX = __tsover_add(std.mix(a.z, fieldVx, blend), __tsover_mul(__tsover_sub(homeX, pos.x), __tsover_mul(HOME_RATE, dt)));
-	const velY = __tsover_add(std.mix(a.w, fieldVy, blend), __tsover_mul(__tsover_sub(homeY, pos.y), __tsover_mul(HOME_RATE, dt)));
-	const nposX = std.clamp(__tsover_add(pos.x, __tsover_mul(velX, dt)), 0, aspect);
-	const nposY = std.clamp(__tsover_add(pos.y, __tsover_mul(velY, dt)), 0, 1);
-	pfLayout.$.particles[i] = d.vec4f(nposX, nposY, velX, velY);
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "i"
-		}],
-		"body": [0, [
-			[
-				13,
-				"prm",
-				[
-					7,
-					[
-						7,
-						"pfLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"a",
+				13,
+				"a",
 				[
 					8,
 					[
@@ -4586,8 +4537,8 @@ const particleFlowIntegrateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (gl
 	},
 	externals: () => ({
 		pfLayout,
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		N,
 		INERTIA_RATE,
 		R2A,
@@ -4598,46 +4549,54 @@ const particleFlowIntegrateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (gl
 function makeParticleFlowSplatKernel(shape) {
 	const name = resolveAgentShape(shape, "streak");
 	const s = AGENT_SHAPES[name];
-	const weightFn = makeAgentWeightFn(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 tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+	return src_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 = d.vec2f(a.x, a.y);
-		const vel = d.vec2f(a.z, a.w);
-		const spd = std.length(vel);
-		const dir = std.select(d.vec2f(1, 0), vel.div(std.max(spd, 1e-5)), spd > 1e-5);
-		const agitI = std.clamp(__tsover_div(spd, std.max(prm.speedNorm, 1e-5)), 0, 1);
-		const bodyR = std.max(prm.bodyR, 1e-6);
+		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 extSq = __tsover_mul(__tsover_add(__tsover_mul(bodyR, EXT), __tsover_mul(AA_W, 2)), __tsover_add(__tsover_mul(bodyR, EXT), __tsover_mul(AA_W, 2)));
-		const txf = __tsover_mul(__tsover_div(pos.x, std.max(prm.aspect, 1e-5)), d.f32(RES));
-		const tyf = __tsover_mul(pos.y, d.f32(RES));
-		const cxi = d.i32(std.floor(txf));
-		const cyi = d.i32(std.floor(tyf));
-		for (let ky = 0; ky < SPLAT_WIN; ky++) for (let kx = 0; kx < SPLAT_WIN; kx++) {
-			const px = __tsover_sub(__tsover_add(cxi, kx), SPLAT_R);
-			const py = __tsover_sub(__tsover_add(cyi, ky), SPLAT_R);
-			if (px >= 0 && px < RES && py >= 0 && py < RES) {
-				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(d.f32(px), .5), INV_RES), prm.aspect), pos.x);
-				const offY = __tsover_sub(__tsover_mul(__tsover_add(d.f32(py), .5), INV_RES), pos.y);
-				if (__tsover_add(__tsover_mul(offX, offX), __tsover_mul(offY, offY)) < extSq) {
+		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 tGlow = __tsover_sub(t, std.clamp(t, -hl, hl));
-					const tEval = std.select(t, tGlow, d.f32(SOFT) > .5);
-					const tk = std.clamp(__tsover_div(__tsover_sub(hl, t), std.max(__tsover_mul(hl, 2), 1e-6)), 0, 1);
-					const bright = __tsover_sub(1, __tsover_mul(__tsover_mul(.55, tk), d.f32(SOFT)));
-					const w = __tsover_mul(weightFn(tEval, n, bodyR, AA_W, d.f32(SOFT)), bright);
-					const e = d.u32(__tsover_mul(w, d.f32(GAIN)));
-					if (e > d.u32(0)) {
-						const idx = d.u32(__tsover_add(__tsover_mul(py, RES), px));
-						std.atomicAdd(pfLayout.$.accumE[idx], e);
-						std.atomicAdd(pfLayout.$.accumS[idx], d.u32(__tsover_mul(__tsover_mul(w, agitI), d.f32(GAIN))));
+					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))));
 					}
 				}
 			}
@@ -4818,7 +4777,7 @@ function makeParticleFlowSplatKernel(shape) {
 				],
 				[
 					13,
-					"bodyR",
+					"aspect",
 					[
 						6,
 						[
@@ -4829,8 +4788,42 @@ function makeParticleFlowSplatKernel(shape) {
 						[[
 							7,
 							"prm",
-							"bodyR"
-						], [5, "0.000001"]]
+							"aspect"
+						], [5, "0.00001"]]
+					]
+				],
+				[
+					13,
+					"bodyR",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								7,
+								"prm",
+								"bodyR"
+							],
+							[5, "0.000001"],
+							[
+								1,
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["SPLAT_R"]
+								],
+								"*",
+								"INV_RES"
+							]
+						]
 					]
 				],
 				[
@@ -4845,44 +4838,49 @@ function makeParticleFlowSplatKernel(shape) {
 				],
 				[
 					13,
-					"extSq",
+					"invR2",
 					[
 						1,
+						[5, "1"],
+						"/",
 						[
 							1,
-							[
-								1,
-								"bodyR",
-								"*",
-								"EXT"
-							],
-							"+",
-							[
-								1,
-								"AA_W",
-								"*",
-								[5, "2"]
-							]
+							"bodyR",
+							"*",
+							"bodyR"
+						]
+					]
+				],
+				[
+					13,
+					"radW",
+					[
+						1,
+						[
+							1,
+							"bodyR",
+							"*",
+							"EXT"
 						],
-						"*",
+						"+",
 						[
 							1,
-							[
-								1,
-								"bodyR",
-								"*",
-								"EXT"
-							],
-							"+",
-							[
-								1,
-								"AA_W",
-								"*",
-								[5, "2"]
-							]
+							"AA_W",
+							"*",
+							[5, "2"]
 						]
 					]
 				],
+				[
+					13,
+					"extSq",
+					[
+						1,
+						"radW",
+						"*",
+						"radW"
+					]
+				],
 				[
 					13,
 					"txf",
@@ -4896,19 +4894,7 @@ function makeParticleFlowSplatKernel(shape) {
 								"x"
 							],
 							"/",
-							[
-								6,
-								[
-									7,
-									"std",
-									"max"
-								],
-								[[
-									7,
-									"prm",
-									"aspect"
-								], [5, "0.00001"]]
-							]
+							"aspect"
 						],
 						"*",
 						[
@@ -4987,423 +4973,585 @@ function makeParticleFlowSplatKernel(shape) {
 					]
 				],
 				[
-					14,
-					[
-						12,
-						"ky",
-						[5, "0"]
-					],
-					[
-						1,
-						"ky",
-						"<",
-						"SPLAT_WIN"
-					],
+					13,
+					"radY",
 					[
-						102,
-						"++",
-						"ky"
-					],
-					[0, [[
-						14,
-						[
-							12,
-							"kx",
-							[5, "0"]
-						],
-						[
-							1,
-							"kx",
-							"<",
-							"SPLAT_WIN"
-						],
+						6,
 						[
-							102,
-							"++",
-							"kx"
+							7,
+							"d",
+							"i32"
 						],
-						[0, [
+						[[
+							6,
 							[
-								13,
-								"px",
+								7,
+								"std",
+								"ceil"
+							],
+							[[
+								1,
+								"radW",
+								"*",
 								[
-									1,
+									6,
 									[
-										1,
-										"cxi",
-										"+",
-										"kx"
+										7,
+										"d",
+										"f32"
 									],
-									"-",
-									"SPLAT_R"
+									["RES"]
 								]
-							],
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"radX",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							6,
 							[
-								13,
-								"py",
+								7,
+								"std",
+								"ceil"
+							],
+							[[
+								1,
 								[
 									1,
+									"radW",
+									"*",
 									[
-										1,
-										"cyi",
-										"+",
-										"ky"
-									],
-									"-",
-									"SPLAT_R"
-								]
-							],
-							[
-								11,
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["RES"]
+									]
+								],
+								"/",
+								"aspect"
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"x0",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							"cxi",
+							"-",
+							"radX"
+						], [5, "0"]]
+					]
+				],
+				[
+					13,
+					"x1",
+					[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						[[
+							1,
+							"cxi",
+							"+",
+							"radX"
+						], [
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"i32"
+								],
+								["RES"]
+							],
+							"-",
+							[5, "1"]
+						]]
+					]
+				],
+				[
+					13,
+					"y0",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							1,
+							"cyi",
+							"-",
+							"radY"
+						], [5, "0"]]
+					]
+				],
+				[
+					13,
+					"y1",
+					[
+						6,
+						[
+							7,
+							"std",
+							"min"
+						],
+						[[
+							1,
+							"cyi",
+							"+",
+							"radY"
+						], [
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"i32"
+								],
+								["RES"]
+							],
+							"-",
+							[5, "1"]
+						]]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"py",
+						"y0"
+					],
+					[
+						1,
+						"py",
+						"<=",
+						"y1"
+					],
+					[
+						102,
+						"++",
+						"py"
+					],
+					[0, [
+						[
+							13,
+							"offY",
+							[
+								1,
 								[
-									3,
+									1,
 									[
-										3,
+										1,
 										[
-											3,
+											6,
 											[
-												1,
-												"px",
-												">=",
-												[5, "0"]
+												7,
+												"d",
+												"f32"
 											],
-											"&&",
-											[
-												1,
-												"px",
-												"<",
-												"RES"
-											]
+											["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,
-											"py",
-											">=",
-											[5, "0"]
-										]
+											[
+												1,
+												[
+													6,
+													[
+														7,
+														"d",
+														"f32"
+													],
+													["px"]
+												],
+												"+",
+												[5, "0.5"]
+											],
+											"*",
+											"INV_RES"
+										],
+										"*",
+										"aspect"
 									],
-									"&&",
+									"-",
 									[
-										1,
-										"py",
-										"<",
-										"RES"
+										7,
+										"pos",
+										"x"
 									]
+								]
+							], [
+								11,
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											"offX",
+											"*",
+											"offX"
+										],
+										"+",
+										"offYSq"
+									],
+									"<",
+									"extSq"
 								],
 								[0, [
 									[
 										13,
-										"offX",
+										"t",
 										[
 											1,
 											[
 												1,
-												[
-													1,
-													[
-														1,
-														[
-															6,
-															[
-																7,
-																"d",
-																"f32"
-															],
-															["px"]
-														],
-														"+",
-														[5, "0.5"]
-													],
-													"*",
-													"INV_RES"
-												],
+												"offX",
 												"*",
 												[
 													7,
-													"prm",
-													"aspect"
+													"dir",
+													"x"
 												]
 											],
-											"-",
+											"+",
 											[
-												7,
-												"pos",
-												"x"
+												1,
+												"offY",
+												"*",
+												[
+													7,
+													"dir",
+													"y"
+												]
 											]
 										]
 									],
 									[
 										13,
-										"offY",
+										"n",
 										[
 											1,
 											[
 												1,
+												"offX",
+												"*",
 												[
-													1,
+													4,
+													"-",
 													[
-														6,
-														[
-															7,
-															"d",
-															"f32"
-														],
-														["py"]
-													],
-													"+",
-													[5, "0.5"]
-												],
-												"*",
-												"INV_RES"
+														7,
+														"dir",
+														"y"
+													]
+												]
 											],
-											"-",
+											"+",
 											[
-												7,
-												"pos",
-												"y"
+												1,
+												"offY",
+												"*",
+												[
+													7,
+													"dir",
+													"x"
+												]
 											]
 										]
 									],
 									[
-										11,
+										13,
+										"tGlow",
 										[
 											1,
+											"t",
+											"-",
 											[
-												1,
+												6,
 												[
-													1,
-													"offX",
-													"*",
-													"offX"
+													7,
+													"std",
+													"clamp"
 												],
-												"+",
 												[
-													1,
-													"offY",
-													"*",
-													"offY"
+													"t",
+													[
+														4,
+														"-",
+														"hl"
+													],
+													"hl"
 												]
+											]
+										]
+									],
+									[
+										13,
+										"tEval",
+										[
+											6,
+											[
+												7,
+												"std",
+												"select"
 											],
-											"<",
-											"extSq"
-										],
-										[0, [
 											[
-												13,
 												"t",
+												"tGlow",
 												[
 													1,
 													[
-														1,
-														"offX",
-														"*",
+														6,
 														[
 															7,
-															"dir",
-															"x"
-														]
+															"d",
+															"f32"
+														],
+														["SOFT"]
 													],
-													"+",
-													[
-														1,
-														"offY",
-														"*",
-														[
-															7,
-															"dir",
-															"y"
-														]
-													]
+													">",
+													[5, "0.5"]
 												]
+											]
+										]
+									],
+									[
+										13,
+										"tk",
+										[
+											6,
+											[
+												7,
+												"std",
+												"clamp"
 											],
 											[
-												13,
-												"n",
 												[
 													1,
 													[
 														1,
-														"offX",
-														"*",
-														[
-															4,
-															"-",
-															[
-																7,
-																"dir",
-																"y"
-															]
-														]
+														"hl",
+														"-",
+														"t"
 													],
-													"+",
-													[
-														1,
-														"offY",
-														"*",
-														[
-															7,
-															"dir",
-															"x"
-														]
-													]
-												]
-											],
-											[
-												13,
-												"tGlow",
-												[
-													1,
-													"t",
-													"-",
+													"/",
 													[
 														6,
 														[
 															7,
 															"std",
-															"clamp"
+															"max"
 														],
-														[
-															"t",
-															[
-																4,
-																"-",
-																"hl"
-															],
-															"hl"
-														]
+														[[
+															1,
+															"hl",
+															"*",
+															[5, "2"]
+														], [5, "0.000001"]]
 													]
-												]
-											],
+												],
+												[5, "0"],
+												[5, "1"]
+											]
+										]
+									],
+									[
+										13,
+										"bright",
+										[
+											1,
+											[5, "1"],
+											"-",
 											[
-												13,
-												"tEval",
+												1,
+												[
+													1,
+													[5, "0.55"],
+													"*",
+													"tk"
+												],
+												"*",
 												[
 													6,
 													[
 														7,
-														"std",
-														"select"
+														"d",
+														"f32"
 													],
-													[
-														"t",
-														"tGlow",
-														[
-															1,
-															[
-																6,
-																[
-																	7,
-																	"d",
-																	"f32"
-																],
-																["SOFT"]
-															],
-															">",
-															[5, "0.5"]
-														]
-													]
+													["SOFT"]
 												]
-											],
+											]
+										]
+									],
+									[
+										13,
+										"qEval",
+										[
+											1,
 											[
-												13,
-												"tk",
+												1,
 												[
-													6,
-													[
-														7,
-														"std",
-														"clamp"
-													],
-													[
-														[
-															1,
-															[
-																1,
-																"hl",
-																"-",
-																"t"
-															],
-															"/",
-															[
-																6,
-																[
-																	7,
-																	"std",
-																	"max"
-																],
-																[[
-																	1,
-																	"hl",
-																	"*",
-																	[5, "2"]
-																], [5, "0.000001"]]
-															]
-														],
-														[5, "0"],
-														[5, "1"]
-													]
+													1,
+													"tEval",
+													"*",
+													"tEval"
+												],
+												"+",
+												[
+													1,
+													"n",
+													"*",
+													"n"
 												]
 											],
+											"*",
+											"invR2"
+										]
+									],
+									[
+										13,
+										"w",
+										[
+											1,
 											[
-												13,
-												"bright",
+												6,
+												"weightFn",
 												[
-													1,
-													[5, "1"],
-													"-",
-													[
-														1,
-														[
-															1,
-															[5, "0.55"],
-															"*",
-															"tk"
-														],
-														"*",
-														[
-															6,
-															[
-																7,
-																"d",
-																"f32"
-															],
-															["SOFT"]
-														]
-													]
+													"qEval",
+													"tEval",
+													"n",
+													"bodyR",
+													"AA_W"
 												]
 											],
+											"*",
+											"bright"
+										]
+									],
+									[
+										13,
+										"e",
+										[
+											6,
 											[
-												13,
+												7,
+												"d",
+												"u32"
+											],
+											[[
+												1,
 												"w",
+												"*",
 												[
-													1,
+													6,
 													[
-														6,
-														"weightFn",
-														[
-															"tEval",
-															"n",
-															"bodyR",
-															"AA_W",
-															[
-																6,
-																[
-																	7,
-																	"d",
-																	"f32"
-																],
-																["SOFT"]
-															]
-														]
+														7,
+														"d",
+														"f32"
 													],
-													"*",
-													"bright"
+													["GAIN"]
 												]
-											],
+											]]
+										]
+									],
+									[
+										11,
+										[
+											1,
+											"e",
+											">",
+											[
+												6,
+												[
+													7,
+													"d",
+													"u32"
+												],
+												[[5, "0"]]
+											]
+										],
+										[0, [
 											[
 												13,
-												"e",
+												"idx",
 												[
 													6,
 													[
@@ -5413,149 +5561,111 @@ function makeParticleFlowSplatKernel(shape) {
 													],
 													[[
 														1,
-														"w",
-														"*",
 														[
-															6,
+															1,
+															"py",
+															"*",
 															[
-																7,
-																"d",
-																"f32"
-															],
-															["GAIN"]
-														]
+																6,
+																[
+																	7,
+																	"d",
+																	"i32"
+																],
+																["RES"]
+															]
+														],
+														"+",
+														"px"
 													]]
 												]
 											],
 											[
-												11,
+												6,
 												[
-													1,
-													"e",
-													">",
+													7,
+													"std",
+													"atomicAdd"
+												],
+												[[
+													8,
 													[
-														6,
+														7,
 														[
 															7,
-															"d",
-															"u32"
+															"pfLayout",
+															"$"
 														],
-														[[5, "0"]]
-													]
-												],
-												[0, [
-													[
-														13,
-														"idx",
-														[
-															6,
-															[
-																7,
-																"d",
-																"u32"
-															],
-															[[
-																1,
-																[
-																	1,
-																	"py",
-																	"*",
-																	"RES"
-																],
-																"+",
-																"px"
-															]]
-														]
+														"accumE"
 													],
+													"idx"
+												], "e"]
+											],
+											[
+												6,
+												[
+													7,
+													"std",
+													"atomicAdd"
+												],
+												[[
+													8,
 													[
-														6,
+														7,
 														[
 															7,
-															"std",
-															"atomicAdd"
+															"pfLayout",
+															"$"
 														],
-														[[
-															8,
-															[
-																7,
-																[
-																	7,
-																	"pfLayout",
-																	"$"
-																],
-																"accumE"
-															],
-															"idx"
-														], "e"]
+														"accumS"
 													],
+													"idx"
+												], [
+													6,
 													[
-														6,
+														7,
+														"d",
+														"u32"
+													],
+													[[
+														1,
 														[
-															7,
-															"std",
-															"atomicAdd"
+															1,
+															"w",
+															"*",
+															"agitI"
 														],
-														[[
-															8,
-															[
-																7,
-																[
-																	7,
-																	"pfLayout",
-																	"$"
-																],
-																"accumS"
-															],
-															"idx"
-														], [
+														"*",
+														[
 															6,
 															[
 																7,
 																"d",
-																"u32"
+																"f32"
 															],
-															[[
-																1,
-																[
-																	1,
-																	"w",
-																	"*",
-																	"agitI"
-																],
-																"*",
-																[
-																	6,
-																	[
-																		7,
-																		"d",
-																		"f32"
-																	],
-																	["GAIN"]
-																]
-															]]
-														]]
-													]
+															["GAIN"]
+														]
+													]]
 												]]
 											]
 										]]
 									]
 								]]
-							]
-						]]
-					]]]
+							]]]
+						]
+					]]
 				]
 			]],
 			"externalNames": [
 				"pfLayout",
 				"d",
 				"std",
+				"SPLAT_R",
+				"INV_RES",
 				"HL",
 				"EXT",
 				"AA_W",
 				"RES",
-				"SPLAT_WIN",
-				"SPLAT_R",
-				"INV_RES",
 				"SOFT",
 				"weightFn",
 				"GAIN"
@@ -5563,15 +5673,14 @@ function makeParticleFlowSplatKernel(shape) {
 		},
 		externals: () => ({
 			pfLayout,
-			d,
-			std,
+			d: data_exports,
+			std: std_exports,
+			SPLAT_R,
+			INV_RES,
 			HL,
 			EXT,
 			AA_W,
 			RES,
-			SPLAT_WIN,
-			SPLAT_R,
-			INV_RES,
 			SOFT,
 			weightFn,
 			GAIN
@@ -5579,25 +5688,275 @@ function makeParticleFlowSplatKernel(shape) {
 	}) && $.f)({})).$name("particleFlowSplat");
 }
 const particleFlowSplatKernel = makeParticleFlowSplatKernel("streak");
-function makeParticleFlowResolveKernel(colorSpaceMode) {
+function makeParticleFlowResolveKernel(colorSpaceMode, trailsOn) {
 	const mixFn = mixColorsVariants[colorSpaceMode] ?? mixColorsLinear;
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+	const composite = trailsOn ? src_default.fn([
+		vec4f,
+		f32,
+		u32
+	], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((col, curA, idx) => {
 		"use gpu";
-		const prm = pfLayout.$.params;
-		const idx = __tsover_add(__tsover_mul(y, d.u32(RES)), x);
-		const eRaw = d.f32(std.atomicLoad(pfLayout.$.accumE[idx]));
-		const sRaw = d.f32(std.atomicLoad(pfLayout.$.accumS[idx]));
-		const energy = __tsover_mul(eRaw, __tsover_div(1, 255));
-		const agitAvg = __tsover_div(sRaw, std.max(eRaw, 1));
-		const col = mixFn(prm.colA, prm.colB, std.clamp(agitAvg, 0, 1));
-		const curA = __tsover_mul(__tsover_sub(1, std.exp(__tsover_mul(energy, -1.6))), col.w);
 		const prev = pfLayout.$.trailBuf[idx];
-		const prevA = __tsover_mul(prev.w, prm.trails);
+		const prevA = __tsover_mul(prev.w, pfLayout.$.params.trails);
 		const win = curA >= prevA;
-		const outA = std.max(curA, prevA);
-		const outRGB = std.select(d.vec3f(prev.x, prev.y, prev.z), d.vec3f(col.x, col.y, col.z), win);
-		pfLayout.$.trailBuf[idx] = d.vec4f(outRGB.x, outRGB.y, outRGB.z, outA);
-		std.textureStore(pfLayout.$.outTex, d.vec2u(x, y), d.vec4f(outRGB.x, outRGB.y, outRGB.z, outA));
+		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: 1,
+		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,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[
+										7,
+										"prev",
+										"x"
+									],
+									[
+										7,
+										"prev",
+										"y"
+									],
+									[
+										7,
+										"prev",
+										"z"
+									]
+								]
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec3f"
+								],
+								[
+									[
+										7,
+										"col",
+										"x"
+									],
+									[
+										7,
+										"col",
+										"y"
+									],
+									[
+										7,
+										"col",
+										"z"
+									]
+								]
+							],
+							"win"
+						]
+					]
+				],
+				[10, [
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							7,
+							"rgb",
+							"x"
+						],
+						[
+							7,
+							"rgb",
+							"y"
+						],
+						[
+							7,
+							"rgb",
+							"z"
+						],
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							["curA", "prevA"]
+						]
+					]
+				]]
+			]],
+			"externalNames": [
+				"pfLayout",
+				"std",
+				"d"
+			]
+		},
+		externals: () => ({
+			pfLayout,
+			std: std_exports,
+			d: data_exports
+		})
+	}) && $.f)({})).$name("particleFlowTrailComposite") : src_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: 1,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "col"
+				},
+				{
+					"type": "i",
+					"name": "curA"
+				},
+				{
+					"type": "i",
+					"name": "_idx"
+				}
+			],
+			"body": [0, [[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec4f"
+				],
+				[
+					[
+						7,
+						"col",
+						"x"
+					],
+					[
+						7,
+						"col",
+						"y"
+					],
+					[
+						7,
+						"col",
+						"z"
+					],
+					"curA"
+				]
+			]]]],
+			"externalNames": ["d"]
+		},
+		externals: () => ({ d: data_exports })
+	}) && $.f)({})).$name("particleFlowTrailComposite");
+	return src_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: 1,
 		name: void 0,
@@ -5679,6 +6038,35 @@ function makeParticleFlowResolveKernel(colorSpaceMode) {
 						]]
 					]
 				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"atomicStore"
+					],
+					[[
+						8,
+						[
+							7,
+							[
+								7,
+								"pfLayout",
+								"$"
+							],
+							"accumE"
+						],
+						"idx"
+					], [
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[5, "0"]]
+					]]
+				],
 				[
 					13,
 					"sRaw",
@@ -5712,6 +6100,35 @@ function makeParticleFlowResolveKernel(colorSpaceMode) {
 						]]
 					]
 				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"atomicStore"
+					],
+					[[
+						8,
+						[
+							7,
+							[
+								7,
+								"pfLayout",
+								"$"
+							],
+							"accumS"
+						],
+						"idx"
+					], [
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[5, "0"]]
+					]]
+				],
 				[
 					13,
 					"energy",
@@ -5728,55 +6145,81 @@ function makeParticleFlowResolveKernel(colorSpaceMode) {
 					]
 				],
 				[
-					13,
-					"agitAvg",
+					12,
+					"col",
 					[
-						1,
-						"sRaw",
-						"/",
+						6,
 						[
-							6,
-							[
-								7,
-								"std",
-								"max"
-							],
-							["eRaw", [5, "1"]]
-						]
+							7,
+							"d",
+							"vec4f"
+						],
+						[[
+							7,
+							"prm",
+							"colA"
+						]]
 					]
 				],
 				[
-					13,
-					"col",
+					11,
 					[
-						6,
-						"mixFn",
+						1,
+						"eRaw",
+						">",
+						[5, "0"]
+					],
+					[0, [[
+						13,
+						"agitAvg",
 						[
-							[
-								7,
-								"prm",
-								"colA"
-							],
-							[
-								7,
-								"prm",
-								"colB"
-							],
+							1,
+							"sRaw",
+							"/",
 							[
 								6,
 								[
 									7,
 									"std",
-									"clamp"
+									"max"
 								],
+								["eRaw", [5, "1"]]
+							]
+						]
+					], [
+						2,
+						"col",
+						"=",
+						[
+							6,
+							"mixFn",
+							[
 								[
-									"agitAvg",
-									[5, "0"],
-									[5, "1"]
+									7,
+									"prm",
+									"colA"
+								],
+								[
+									7,
+									"prm",
+									"colB"
+								],
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										"agitAvg",
+										[5, "0"],
+										[5, "1"]
+									]
 								]
 							]
 						]
-					]
+					]]]
 				],
 				[
 					13,
@@ -5816,124 +6259,14 @@ function makeParticleFlowResolveKernel(colorSpaceMode) {
 				],
 				[
 					13,
-					"prev",
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"pfLayout",
-								"$"
-							],
-							"trailBuf"
-						],
-						"idx"
-					]
-				],
-				[
-					13,
-					"prevA",
-					[
-						1,
-						[
-							7,
-							"prev",
-							"w"
-						],
-						"*",
-						[
-							7,
-							"prm",
-							"trails"
-						]
-					]
-				],
-				[
-					13,
-					"win",
-					[
-						1,
-						"curA",
-						">=",
-						"prevA"
-					]
-				],
-				[
-					13,
-					"outA",
-					[
-						6,
-						[
-							7,
-							"std",
-							"max"
-						],
-						["curA", "prevA"]
-					]
-				],
-				[
-					13,
-					"outRGB",
+					"out",
 					[
 						6,
+						"composite",
 						[
-							7,
-							"std",
-							"select"
-						],
-						[
-							[
-								6,
-								[
-									7,
-									"d",
-									"vec3f"
-								],
-								[
-									[
-										7,
-										"prev",
-										"x"
-									],
-									[
-										7,
-										"prev",
-										"y"
-									],
-									[
-										7,
-										"prev",
-										"z"
-									]
-								]
-							],
-							[
-								6,
-								[
-									7,
-									"d",
-									"vec3f"
-								],
-								[
-									[
-										7,
-										"col",
-										"x"
-									],
-									[
-										7,
-										"col",
-										"y"
-									],
-									[
-										7,
-										"col",
-										"z"
-									]
-								]
-							],
-							"win"
+							"col",
+							"curA",
+							"idx"
 						]
 					]
 				],
@@ -5960,24 +6293,7 @@ function makeParticleFlowResolveKernel(colorSpaceMode) {
 							"d",
 							"vec4f"
 						],
-						[
-							[
-								7,
-								"outRGB",
-								"x"
-							],
-							[
-								7,
-								"outRGB",
-								"y"
-							],
-							[
-								7,
-								"outRGB",
-								"z"
-							],
-							"outA"
-						]
+						["out"]
 					]
 				],
 				[
@@ -6006,32 +6322,7 @@ function makeParticleFlowResolveKernel(colorSpaceMode) {
 							],
 							["x", "y"]
 						],
-						[
-							6,
-							[
-								7,
-								"d",
-								"vec4f"
-							],
-							[
-								[
-									7,
-									"outRGB",
-									"x"
-								],
-								[
-									7,
-									"outRGB",
-									"y"
-								],
-								[
-									7,
-									"outRGB",
-									"z"
-								],
-								"outA"
-							]
-						]
+						"out"
 					]
 				]
 			]],
@@ -6040,19 +6331,21 @@ function makeParticleFlowResolveKernel(colorSpaceMode) {
 				"d",
 				"RES",
 				"std",
-				"mixFn"
+				"mixFn",
+				"composite"
 			]
 		},
 		externals: () => ({
 			pfLayout,
-			d,
+			d: data_exports,
 			RES,
-			std,
-			mixFn
+			std: std_exports,
+			mixFn,
+			composite
 		})
 	}) && $.f)({})).$name("particleFlowResolve");
 }
-const particleFlowResolveKernel = makeParticleFlowResolveKernel(2);
+const particleFlowResolveKernel = makeParticleFlowResolveKernel(2, false);
 const componentDefinition = {
 	name: "ParticleFlow",
 	boundingBoxDeclaration: { aspectRatio: null },
@@ -6131,6 +6424,7 @@ const componentDefinition = {
 		},
 		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",
@@ -6206,14 +6500,14 @@ const componentDefinition = {
 		const { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
 		const root = gpu?.root;
 		if (!root) return null;
-		const velA = createStateBuffer(root, d.vec4f, FLUID_COUNT);
-		const velB = createStateBuffer(root, d.vec4f, FLUID_COUNT);
-		const pressure = createStateBuffer(root, d.f32, FLUID_COUNT);
-		const divergence = createStateBuffer(root, d.f32, FLUID_COUNT);
-		const particles = createStateBuffer(root, d.vec4f, MAX_PARTICLES);
-		const accumE = createStateBuffer(root, d.atomic(d.u32), RES * RES);
-		const accumS = createStateBuffer(root, d.atomic(d.u32), RES * RES);
-		const trailBuf = createStateBuffer(root, d.vec4f, RES * RES);
+		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
@@ -6308,8 +6602,9 @@ const componentDefinition = {
 		const gradSubtract = mkFluid(particleFlowGradSubtractKernel);
 		const advectVel = mkFluid(particleFlowAdvectVelKernel);
 		const copyVel = mkFluid(particleFlowCopyVelKernel);
+		const trailsCpu = getCpuValue("trails");
 		const splatKernel = makeParticleFlowSplatKernel(getCpuValue("shape") || "streak");
-		const resolveKernel = makeParticleFlowResolveKernel(getCpuValue("colorSpace") ?? 2);
+		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);
@@ -6330,29 +6625,6 @@ const componentDefinition = {
 			},
 			externals: () => ({ particleFlowInitKernel })
 		}) && $.f)({})).with(pfBg);
-		const clearAccum = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
-			"use gpu";
-			particleFlowClearKernel(x, y);
-		}), {
-			v: 1,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "x"
-				}, {
-					"type": "i",
-					"name": "y"
-				}],
-				"body": [0, [[
-					6,
-					"particleFlowClearKernel",
-					["x", "y"]
-				]]],
-				"externalNames": ["particleFlowClearKernel"]
-			},
-			externals: () => ({ particleFlowClearKernel })
-		}) && $.f)({}), { size: [RES, RES] }).with(pfBg);
 		const integrate = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 			"use gpu";
 			particleFlowIntegrateKernel(i);
@@ -6423,6 +6695,7 @@ const componentDefinition = {
 		let ambientTime = 0;
 		let warmup = 0;
 		let initialized = false;
+		const countCap = isMobileGpuViewport() ? COUNT_MAX_MOBILE : MAX_PARTICLES;
 		const num = (key, fallback) => {
 			const v = getCpuValue(key);
 			return typeof v === "number" ? v : fallback;
@@ -6443,8 +6716,8 @@ const componentDefinition = {
 				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), MAX_PARTICLES);
-				const bodyR = Math.min(Math.max(num("size", 1.2), .3), 3) * 1.3 * INV_RES;
+				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 oldMx = prevMx;
 				const oldMy = prevMy;
 				const mx = fp.pointer?.x ?? prevMx;
@@ -6474,8 +6747,8 @@ const componentDefinition = {
 				const colA = getCpuValue("colorA");
 				const colB = getCpuValue("colorB");
 				simU.write({
-					colA: d.vec4f(colA?.x ?? .56, colA?.y ?? .77, colA?.z ?? 1, colA?.w ?? 1),
-					colB: d.vec4f(colB?.x ?? 1, colB?.y ?? .85, colB?.z ?? .56, colB?.w ?? 1),
+					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,
@@ -6510,7 +6783,7 @@ const componentDefinition = {
 				nodes.push(curl, vorticity, divergencePass);
 				for (let iter = 0; iter < JACOBI_ITERS; iter++) nodes.push(jacobi);
 				nodes.push(gradSubtract, advectVel, copyVel);
-				nodes.push(clearAccum, () => integrate.dispatchThreads(count), () => splat.dispatchThreads(count), resolve);
+				nodes.push(() => integrate.dispatchThreads(count), () => splat.dispatchThreads(count), resolve);
 				return nodes;
 			}
 		};
@@ -6522,4 +6795,4 @@ const componentDefinition = {
 	}
 };
 var ParticleFlow_default = componentDefinition;
-export { particleFlowVorticityKernel as _, particleFlowAdvectVelKernel as a, particleFlowCurlKernel as c, particleFlowGradSubtractKernel as d, particleFlowInitKernel as f, particleFlowSplatKernel as g, particleFlowResolveKernel as h, makeParticleFlowSplatKernel as i, particleFlowDivergenceKernel as l, particleFlowJacobiKernel as m, componentDefinition as n, particleFlowClearKernel as o, particleFlowIntegrateKernel as p, makeParticleFlowResolveKernel as r, particleFlowCopyVelKernel as s, ParticleFlow_default as t, particleFlowForceKernel as u };
+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 };