shaders 3.0.448 → 3.0.449

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

@@ -1,5 +1,8 @@
-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 { $t as vec2f, Ct as floor, Et as max, Gt as textureStorage2d, H as mixColorsLinear, Ht as atomic, Ot as mix, Rt as sqrt, Tt as length, U as mixColorsVariants, Ut as arrayOf, Vt as data_exports, Wt as texture2d, Xt as struct, _t as clamp, an as f32, at as textureStore, d as ZERO, dt as atomicStore, et as src_default, in as vec4f, it as textureLoad, lt as atomicAdd, mt as abs, nn as vec3f, nt as std_exports, on as i32, pt as select, sn as u32, tn as vec2u, ut as atomicLoad, wt as fract, xt as exp } from "./edges-BXNBKxSN.js";
+import { l as hash33, p as noise_exports, r as curl22z } from "./noise-wTSHXgFz.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { a as makeAgentWeightFn, c as resolveAgentShape, o as orientedShapeOptions, t as AGENT_SHAPES } from "./agents-Bv3--qPL.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;
@@ -25,83 +28,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 +209,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 +518,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 +814,34 @@ 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 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);
 	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), __tsover_mul(amb.x, af)), __tsover_add(__tsover_add(vel.y, fy), __tsover_mul(amb.y, af)), vel.z, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -1482,30 +1485,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 +1999,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 +2260,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 +2549,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 +3211,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 +3372,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,15 +3531,15 @@ 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) => {
+const particleFlowClearKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
 	"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 idx = __tsover_add(__tsover_mul(y, u32(RES)), x);
+	atomicStore(pfLayout.$.accumE[idx], u32(0));
+	atomicStore(pfLayout.$.accumS[idx], u32(0));
 }), {
 	v: 1,
 	name: void 0,
@@ -3639,53 +3642,53 @@ const particleFlowClearKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) =>
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		RES,
-		std,
+		std: std_exports,
 		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) => {
+const particleFlowIntegrateKernel = 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 pos = vec2f(a.x, a.y);
 	const dt = prm.dt;
-	const aspect = std.max(prm.aspect, 1e-5);
+	const aspect = max(prm.aspect, 1e-5);
 	const uvx = __tsover_div(pos.x, aspect);
 	const uvy = pos.y;
-	const NF = d.f32(N);
+	const NF = 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 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 = 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 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, 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);
+	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,
@@ -4586,8 +4589,8 @@ const particleFlowIntegrateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (gl
 	},
 	externals: () => ({
 		pfLayout,
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		N,
 		INERTIA_RATE,
 		R2A,
@@ -4603,41 +4606,40 @@ function makeParticleFlowSplatKernel(shape) {
 	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 bodyR = max(prm.bodyR, 1e-6);
 		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));
+		const txf = __tsover_mul(__tsover_div(pos.x, max(prm.aspect, 1e-5)), f32(RES));
+		const tyf = __tsover_mul(pos.y, f32(RES));
+		const cxi = i32(floor(txf));
+		const cyi = i32(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);
+				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(f32(px), .5), INV_RES), prm.aspect), pos.x);
+				const offY = __tsover_sub(__tsover_mul(__tsover_add(f32(py), .5), INV_RES), pos.y);
 				if (__tsover_add(__tsover_mul(offX, offX), __tsover_mul(offY, offY)) < 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 w = __tsover_mul(weightFn(tEval, n, bodyR, AA_W, f32(SOFT)), bright);
+					const e = u32(__tsover_mul(w, f32(GAIN)));
+					if (e > u32(0)) {
+						const idx = u32(__tsover_add(__tsover_mul(py, RES), px));
+						atomicAdd(pfLayout.$.accumE[idx], e);
+						atomicAdd(pfLayout.$.accumS[idx], u32(__tsover_mul(__tsover_mul(w, agitI), f32(GAIN))));
 					}
 				}
 			}
@@ -5563,8 +5565,8 @@ function makeParticleFlowSplatKernel(shape) {
 		},
 		externals: () => ({
 			pfLayout,
-			d,
-			std,
+			d: data_exports,
+			std: std_exports,
 			HL,
 			EXT,
 			AA_W,
@@ -5581,23 +5583,23 @@ function makeParticleFlowSplatKernel(shape) {
 const particleFlowSplatKernel = makeParticleFlowSplatKernel("streak");
 function makeParticleFlowResolveKernel(colorSpaceMode) {
 	const mixFn = mixColorsVariants[colorSpaceMode] ?? mixColorsLinear;
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+	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, d.u32(RES)), x);
-		const eRaw = d.f32(std.atomicLoad(pfLayout.$.accumE[idx]));
-		const sRaw = d.f32(std.atomicLoad(pfLayout.$.accumS[idx]));
+		const idx = __tsover_add(__tsover_mul(y, u32(RES)), x);
+		const eRaw = f32(atomicLoad(pfLayout.$.accumE[idx]));
+		const sRaw = f32(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 agitAvg = __tsover_div(sRaw, max(eRaw, 1));
+		const 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 prev = pfLayout.$.trailBuf[idx];
 		const prevA = __tsover_mul(prev.w, prm.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 outA = max(curA, prevA);
+		const outRGB = select(vec3f(prev.x, prev.y, prev.z), vec3f(col.x, col.y, col.z), win);
+		pfLayout.$.trailBuf[idx] = vec4f(outRGB.x, outRGB.y, outRGB.z, outA);
+		textureStore(pfLayout.$.outTex, vec2u(x, y), vec4f(outRGB.x, outRGB.y, outRGB.z, outA));
 	}), {
 		v: 1,
 		name: void 0,
@@ -6045,9 +6047,9 @@ function makeParticleFlowResolveKernel(colorSpaceMode) {
 		},
 		externals: () => ({
 			pfLayout,
-			d,
+			d: data_exports,
 			RES,
-			std,
+			std: std_exports,
 			mixFn
 		})
 	}) && $.f)({})).$name("particleFlowResolve");
@@ -6206,14 +6208,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
@@ -6474,8 +6476,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,