shaders 3.0.448 → 3.0.450

package/dist/core/{Boids-B8QUNxRL.js → Boids-D51U46GF.js}

@@ -1,11 +1,17 @@
-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, ot as hash11, pt as noise_exports, r as AGENT_SHAPES, 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 { Bt as sqrt, Ct as exp, Dt as length, Gt as arrayOf, H as mixColorsLinear, Ot as max, Qt as struct, Rt as sin, St as dot, Tt as floor, U as mixColorsVariants, Ut as data_exports, Wt as atomic, bt as cos, cn as i32, d as ZERO, dt as atomicLoad, et as src_default, ft as atomicStore, in as vec3f, 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, o as hash11, p as noise_exports } 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 MAX_AGENTS = 4096;
-var RES = 1024;
+var COUNT_MAX_MOBILE = 1200;
+var RES = isMobileGpuViewport() ? 640 : 1024;
+var COUNT_CAP = isMobileGpuViewport() ? COUNT_MAX_MOBILE : MAX_AGENTS;
 var INV_RES = 1 / RES;
+var SIZE_REF_RES = 1024;
 var STATE_FORMAT = "rgba16float";
 var SPLAT_R = 16;
-var SPLAT_WIN = 33;
 var AA_W = .75 * INV_RES;
 var TAU = 6.283185307179586;
 var BASE_SPEED = .13;
@@ -15,67 +21,67 @@ var AGIT_GAIN = .4545;
 var AGIT_COOL = 1.3;
 var HARD_GAIN = 637;
 var SOFT_GAIN = 255;
-var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	colA: d.vec4f,
-	colB: d.vec4f,
-	count: d.f32,
-	trails: d.f32,
-	dt: d.f32,
-	aspect: d.f32,
-	domainX: d.f32,
-	maxSpeed: d.f32,
-	maxForce: d.f32,
-	perceptionSq: d.f32,
-	sepRadiusSq: d.f32,
-	sepW: d.f32,
-	aliW: d.f32,
-	cohW: d.f32,
-	cursorX: d.f32,
-	cursorY: d.f32,
-	cursorMode: d.f32,
-	cursorRadius: d.f32,
-	cursorRadiusSq: d.f32,
-	cursorForce: d.f32,
-	bodyR: d.f32,
-	margin: d.f32,
-	turnForce: d.f32,
-	seed: d.f32
+var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	colA: vec4f,
+	colB: vec4f,
+	count: f32,
+	trails: f32,
+	dt: f32,
+	aspect: f32,
+	domainX: f32,
+	maxSpeed: f32,
+	maxForce: f32,
+	perceptionSq: f32,
+	sepRadiusSq: f32,
+	sepW: f32,
+	aliW: f32,
+	cohW: f32,
+	cursorX: f32,
+	cursorY: f32,
+	cursorMode: f32,
+	cursorRadius: f32,
+	cursorRadiusSq: f32,
+	cursorForce: f32,
+	bodyR: f32,
+	margin: f32,
+	turnForce: f32,
+	seed: f32
 }), "SimParams");
-var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	agents: {
-		storage: d.arrayOf(d.vec4f, MAX_AGENTS),
+		storage: arrayOf(vec4f, MAX_AGENTS),
 		access: "mutable"
 	},
 	agit: {
-		storage: d.arrayOf(d.f32, MAX_AGENTS),
+		storage: arrayOf(f32, MAX_AGENTS),
 		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"
 	},
 	params: { uniform: SimParams },
-	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "simLayout");
-var safeSteer = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dir, vel, maxSpeed, maxForce) => {
+var safeSteer = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dir, vel, maxSpeed, maxForce) => {
 	"use gpu";
-	const len = std.length(dir);
-	const steer = std.select(d.vec2f(0, 0), dir.div(std.max(len, 1e-5)).mul(maxSpeed), len > 1e-5).sub(vel);
-	const sl = std.length(steer);
-	return std.select(steer, steer.div(std.max(sl, 1e-5)).mul(maxForce), sl > maxForce);
+	const len = length(dir);
+	const steer = select(vec2f(0, 0), dir.div(max(len, 1e-5)).mul(maxSpeed), len > 1e-5).sub(vel);
+	const sl = length(steer);
+	return select(steer, steer.div(max(sl, 1e-5)).mul(maxForce), sl > maxForce);
 }), {
 	v: 1,
 	name: void 0,
@@ -238,30 +244,30 @@ var safeSteer = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const boidsInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+const boidsInitKernel = src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 	"use gpu";
 	const prm = simLayout.$.params;
-	const fi = d.f32(i);
+	const fi = f32(i);
 	const sd = __tsover_mul(prm.seed, 13.137);
-	const flocks = std.max(std.floor(__tsover_div(prm.count, 250)), d.f32(3));
-	const c = __tsover_sub(fi, __tsover_mul(std.floor(__tsover_div(fi, flocks)), flocks));
-	const rc = hash33(d.vec3f(__tsover_add(__tsover_add(__tsover_mul(c, 7.1315), sd), .71), __tsover_add(__tsover_add(__tsover_mul(c, 3.7719), sd), 4.17), __tsover_add(__tsover_add(__tsover_mul(c, 9.4103), sd), 9.03)));
+	const flocks = max(floor(__tsover_div(prm.count, 250)), f32(3));
+	const c = __tsover_sub(fi, __tsover_mul(floor(__tsover_div(fi, flocks)), flocks));
+	const rc = hash33(vec3f(__tsover_add(__tsover_add(__tsover_mul(c, 7.1315), sd), .71), __tsover_add(__tsover_add(__tsover_mul(c, 3.7719), sd), 4.17), __tsover_add(__tsover_add(__tsover_mul(c, 9.4103), sd), 9.03)));
 	const ang = __tsover_mul(rc.z, TAU);
-	const hd = d.vec2f(std.cos(ang), std.sin(ang));
-	const center = d.vec2f(__tsover_mul(__tsover_add(.12, __tsover_mul(rc.x, .76)), prm.domainX), __tsover_add(.12, __tsover_mul(rc.y, .76)));
-	const ra = hash33(d.vec3f(__tsover_add(__tsover_add(__tsover_mul(fi, 1.6180339), sd), .71), __tsover_add(__tsover_add(__tsover_mul(fi, 2.7182818), sd), 4.17), __tsover_add(__tsover_add(__tsover_mul(fi, 3.1415926), sd), 9.03)));
+	const hd = vec2f(cos(ang), sin(ang));
+	const center = vec2f(__tsover_mul(__tsover_add(.12, __tsover_mul(rc.x, .76)), prm.domainX), __tsover_add(.12, __tsover_mul(rc.y, .76)));
+	const ra = hash33(vec3f(__tsover_add(__tsover_add(__tsover_mul(fi, 1.6180339), sd), .71), __tsover_add(__tsover_add(__tsover_mul(fi, 2.7182818), sd), 4.17), __tsover_add(__tsover_add(__tsover_mul(fi, 3.1415926), sd), 9.03)));
 	const t = __tsover_mul(__tsover_sub(ra.x, .5), .6);
 	const n = __tsover_mul(__tsover_sub(ra.y, .5), .16);
-	const px = std.clamp(__tsover_sub(__tsover_add(center.x, __tsover_mul(hd.x, t)), __tsover_mul(hd.y, n)), 0, prm.domainX);
-	const py = std.clamp(__tsover_add(__tsover_add(center.y, __tsover_mul(hd.y, t)), __tsover_mul(hd.x, n)), 0, 1);
+	const px = clamp(__tsover_sub(__tsover_add(center.x, __tsover_mul(hd.x, t)), __tsover_mul(hd.y, n)), 0, prm.domainX);
+	const py = clamp(__tsover_add(__tsover_add(center.y, __tsover_mul(hd.y, t)), __tsover_mul(hd.x, n)), 0, 1);
 	const jAng = __tsover_add(ang, __tsover_mul(__tsover_sub(ra.z, .5), .5));
 	const sp = __tsover_mul(prm.maxSpeed, __tsover_add(.75, __tsover_mul(ra.y, .25)));
-	simLayout.$.agents[i] = d.vec4f(px, py, __tsover_mul(std.cos(jAng), sp), __tsover_mul(std.sin(jAng), sp));
-	simLayout.$.agit[i] = d.f32(0);
+	simLayout.$.agents[i] = vec4f(px, py, __tsover_mul(cos(jAng), sp), __tsover_mul(sin(jAng), sp));
+	simLayout.$.agit[i] = f32(0);
 }), {
 	v: 1,
 	name: void 0,
@@ -896,168 +902,63 @@ const boidsInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__T
 	},
 	externals: () => ({
 		simLayout,
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports,
 		TAU
 	})
 }) && $.f)({})).$name("boidsInit");
-const boidsClearAccumKernel = tgpu.fn([d.u32, d.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(simLayout.$.accumE[idx], d.u32(0));
-	std.atomicStore(simLayout.$.accumS[idx], d.u32(0));
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "x"
-		}, {
-			"type": "i",
-			"name": "y"
-		}],
-		"body": [0, [
-			[
-				13,
-				"idx",
-				[
-					1,
-					[
-						1,
-						"y",
-						"*",
-						[
-							6,
-							[
-								7,
-								"d",
-								"u32"
-							],
-							["RES"]
-						]
-					],
-					"+",
-					"x"
-				]
-			],
-			[
-				6,
-				[
-					7,
-					"std",
-					"atomicStore"
-				],
-				[[
-					8,
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"accumE"
-					],
-					"idx"
-				], [
-					6,
-					[
-						7,
-						"d",
-						"u32"
-					],
-					[[5, "0"]]
-				]]
-			],
-			[
-				6,
-				[
-					7,
-					"std",
-					"atomicStore"
-				],
-				[[
-					8,
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"accumS"
-					],
-					"idx"
-				], [
-					6,
-					[
-						7,
-						"d",
-						"u32"
-					],
-					[[5, "0"]]
-				]]
-			]
-		]],
-		"externalNames": [
-			"d",
-			"RES",
-			"std",
-			"simLayout"
-		]
-	},
-	externals: () => ({
-		d,
-		RES,
-		std,
-		simLayout
-	})
-}) && $.f)({})).$name("boidsClearAccum");
 function makeBoidsSplatKernel(shape) {
 	const name = resolveAgentShape(shape, "arrow");
 	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 = simLayout.$.params;
 		const a = simLayout.$.agents[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(simLayout.$.agit[i], 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(simLayout.$.agit[i], 0, 1);
+		const agitGain = __tsover_mul(agitI, f32(GAIN));
+		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, prm.aspect), 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 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(simLayout.$.accumE[idx], e);
-						std.atomicAdd(simLayout.$.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_div(__tsover_add(__tsover_mul(tEval, tEval), __tsover_mul(n, n)), __tsover_mul(bodyR, bodyR));
+					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(simLayout.$.accumE[idx], e);
+						if (agitI > 0) atomicAdd(simLayout.$.accumS[idx], u32(__tsover_mul(w, agitGain)));
 					}
 				}
 			}
@@ -1233,7 +1134,25 @@ function makeBoidsSplatKernel(shape) {
 				],
 				[
 					13,
-					"bodyR",
+					"agitGain",
+					[
+						1,
+						"agitI",
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["GAIN"]
+						]
+					]
+				],
+				[
+					13,
+					"aspect",
 					[
 						6,
 						[
@@ -1244,8 +1163,42 @@ function makeBoidsSplatKernel(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"
+							]
+						]
 					]
 				],
 				[
@@ -1260,44 +1213,34 @@ function makeBoidsSplatKernel(shape) {
 				],
 				[
 					13,
-					"extSq",
+					"radW",
 					[
 						1,
 						[
 							1,
-							[
-								1,
-								"bodyR",
-								"*",
-								"EXT"
-							],
-							"+",
-							[
-								1,
-								"AA_W",
-								"*",
-								[5, "2"]
-							]
+							"bodyR",
+							"*",
+							"EXT"
 						],
-						"*",
+						"+",
 						[
 							1,
-							[
-								1,
-								"bodyR",
-								"*",
-								"EXT"
-							],
-							"+",
-							[
-								1,
-								"AA_W",
-								"*",
-								[5, "2"]
-							]
+							"AA_W",
+							"*",
+							[5, "2"]
 						]
 					]
 				],
+				[
+					13,
+					"extSq",
+					[
+						1,
+						"radW",
+						"*",
+						"radW"
+					]
+				],
 				[
 					13,
 					"txf",
@@ -1311,11 +1254,7 @@ function makeBoidsSplatKernel(shape) {
 								"x"
 							],
 							"/",
-							[
-								7,
-								"prm",
-								"aspect"
-							]
+							"aspect"
 						],
 						"*",
 						[
@@ -1394,423 +1333,590 @@ function makeBoidsSplatKernel(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",
-								[
-									1,
-									[
-										1,
-										"cxi",
-										"+",
-										"kx"
-									],
-									"-",
-									"SPLAT_R"
-								]
+								7,
+								"std",
+								"ceil"
 							],
-							[
-								13,
-								"py",
+							[[
+								1,
+								"radW",
+								"*",
 								[
-									1,
+									6,
 									[
-										1,
-										"cyi",
-										"+",
-										"ky"
+										7,
+										"d",
+										"f32"
 									],
-									"-",
-									"SPLAT_R"
+									["RES"]
 								]
-							],
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"radX",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							6,
 							[
-								11,
+								7,
+								"std",
+								"ceil"
+							],
+							[[
+								1,
 								[
-									3,
+									1,
+									"radW",
+									"*",
 									[
-										3,
+										6,
 										[
-											3,
-											[
-												1,
-												"px",
-												">=",
-												[5, "0"]
-											],
-											"&&",
-											[
-												1,
-												"px",
-												"<",
-												"RES"
-											]
+											7,
+											"d",
+											"f32"
 										],
-										"&&",
-										[
-											1,
-											"py",
-											">=",
-											[5, "0"]
-										]
-									],
-									"&&",
-									[
-										1,
-										"py",
-										"<",
-										"RES"
+										["RES"]
 									]
 								],
-								[0, [
+								"/",
+								"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,
+								[
+									1,
 									[
-										13,
-										"offX",
+										1,
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											["py"]
+										],
+										"+",
+										[5, "0.5"]
+									],
+									"*",
+									"INV_RES"
+								],
+								"-",
+								[
+									7,
+									"pos",
+									"y"
+								]
+							]
+						],
+						[
+							13,
+							"offYSq",
+							[
+								1,
+								"offY",
+								"*",
+								"offY"
+							]
+						],
+						[
+							14,
+							[
+								12,
+								"px",
+								"x0"
+							],
+							[
+								1,
+								"px",
+								"<=",
+								"x1"
+							],
+							[
+								102,
+								"++",
+								"px"
+							],
+							[0, [[
+								13,
+								"offX",
+								[
+									1,
+									[
+										1,
 										[
 											1,
 											[
 												1,
 												[
-													1,
+													6,
 													[
-														1,
-														[
-															6,
-															[
-																7,
-																"d",
-																"f32"
-															],
-															["px"]
-														],
-														"+",
-														[5, "0.5"]
+														7,
+														"d",
+														"f32"
 													],
-													"*",
-													"INV_RES"
+													["px"]
 												],
+												"+",
+												[5, "0.5"]
+											],
+											"*",
+											"INV_RES"
+										],
+										"*",
+										"aspect"
+									],
+									"-",
+									[
+										7,
+										"pos",
+										"x"
+									]
+								]
+							], [
+								11,
+								[
+									1,
+									[
+										1,
+										[
+											1,
+											"offX",
+											"*",
+											"offX"
+										],
+										"+",
+										"offYSq"
+									],
+									"<",
+									"extSq"
+								],
+								[0, [
+									[
+										13,
+										"t",
+										[
+											1,
+											[
+												1,
+												"offX",
 												"*",
 												[
 													7,
-													"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"
 												]
 											],
+											"/",
 											[
-												13,
-												"bright",
+												1,
+												"bodyR",
+												"*",
+												"bodyR"
+											]
+										]
+									],
+									[
+										13,
+										"w",
+										[
+											1,
+											[
+												6,
+												"weightFn",
 												[
-													1,
-													[5, "1"],
-													"-",
-													[
-														1,
-														[
-															1,
-															[5, "0.55"],
-															"*",
-															"tk"
-														],
-														"*",
-														[
-															6,
-															[
-																7,
-																"d",
-																"f32"
-															],
-															["SOFT"]
-														]
-													]
+													"qEval",
+													"tEval",
+													"n",
+													"bodyR",
+													"AA_W"
 												]
 											],
-											[
-												13,
+											"*",
+											"bright"
+										]
+									],
+									[
+										13,
+										"e",
+										[
+											6,
+											[
+												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,
 													[
@@ -1820,191 +1926,153 @@ function makeBoidsSplatKernel(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"
+															"simLayout",
+															"$"
 														],
-														[[5, "0"]]
-													]
+														"accumE"
+													],
+													"idx"
+												], "e"]
+											],
+											[
+												11,
+												[
+													1,
+													"agitI",
+													">",
+													[5, "0"]
 												],
-												[0, [
+												[0, [[
+													6,
 													[
-														13,
-														"idx",
-														[
-															6,
-															[
-																7,
-																"d",
-																"u32"
-															],
-															[[
-																1,
-																[
-																	1,
-																	"py",
-																	"*",
-																	"RES"
-																],
-																"+",
-																"px"
-															]]
-														]
+														7,
+														"std",
+														"atomicAdd"
 													],
-													[
-														6,
+													[[
+														8,
 														[
 															7,
-															"std",
-															"atomicAdd"
-														],
-														[[
-															8,
 															[
 																7,
-																[
-																	7,
-																	"simLayout",
-																	"$"
-																],
-																"accumE"
+																"simLayout",
+																"$"
 															],
-															"idx"
-														], "e"]
-													],
-													[
+															"accumS"
+														],
+														"idx"
+													], [
 														6,
 														[
 															7,
-															"std",
-															"atomicAdd"
+															"d",
+															"u32"
 														],
 														[[
-															8,
-															[
-																7,
-																[
-																	7,
-																	"simLayout",
-																	"$"
-																],
-																"accumS"
-															],
-															"idx"
-														], [
-															6,
-															[
-																7,
-																"d",
-																"u32"
-															],
-															[[
-																1,
-																[
-																	1,
-																	"w",
-																	"*",
-																	"agitI"
-																],
-																"*",
-																[
-																	6,
-																	[
-																		7,
-																		"d",
-																		"f32"
-																	],
-																	["GAIN"]
-																]
-															]]
+															1,
+															"w",
+															"*",
+															"agitGain"
 														]]
-													]
-												]]
+													]]
+												]]]
 											]
 										]]
 									]
 								]]
-							]
-						]]
-					]]]
+							]]]
+						]
+					]]
 				]
 			]],
 			"externalNames": [
 				"simLayout",
 				"d",
 				"std",
+				"GAIN",
+				"SPLAT_R",
+				"INV_RES",
 				"HL",
 				"EXT",
 				"AA_W",
 				"RES",
-				"SPLAT_WIN",
-				"SPLAT_R",
-				"INV_RES",
 				"SOFT",
-				"weightFn",
-				"GAIN"
+				"weightFn"
 			]
 		},
 		externals: () => ({
 			simLayout,
-			d,
-			std,
+			d: data_exports,
+			std: std_exports,
+			GAIN,
+			SPLAT_R,
+			INV_RES,
 			HL,
 			EXT,
 			AA_W,
 			RES,
-			SPLAT_WIN,
-			SPLAT_R,
-			INV_RES,
 			SOFT,
-			weightFn,
-			GAIN
+			weightFn
 		})
 	}) && $.f)({})).$name("boidsSplat");
 }
 const boidsSplatKernel = makeBoidsSplatKernel("arrow");
 function makeBoidsResolveKernel(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 = simLayout.$.params;
-		const idx = __tsover_add(__tsover_mul(y, d.u32(RES)), x);
-		const eRaw = d.f32(std.atomicLoad(simLayout.$.accumE[idx]));
-		const sRaw = d.f32(std.atomicLoad(simLayout.$.accumS[idx]));
+		const idx = __tsover_add(__tsover_mul(y, u32(RES)), x);
+		const eRaw = f32(atomicLoad(simLayout.$.accumE[idx]));
+		atomicStore(simLayout.$.accumE[idx], u32(0));
+		const sRaw = f32(atomicLoad(simLayout.$.accumS[idx]));
+		atomicStore(simLayout.$.accumS[idx], u32(0));
 		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);
+		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 prev = simLayout.$.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);
-		simLayout.$.trailBuf[idx] = d.vec4f(outRGB.x, outRGB.y, outRGB.z, outA);
-		std.textureStore(simLayout.$.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);
+		simLayout.$.trailBuf[idx] = vec4f(outRGB.x, outRGB.y, outRGB.z, outA);
+		textureStore(simLayout.$.outTex, vec2u(x, y), vec4f(outRGB.x, outRGB.y, outRGB.z, outA));
 	}), {
 		v: 1,
 		name: void 0,
@@ -2086,6 +2154,35 @@ function makeBoidsResolveKernel(colorSpaceMode) {
 						]]
 					]
 				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"atomicStore"
+					],
+					[[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"accumE"
+						],
+						"idx"
+					], [
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[5, "0"]]
+					]]
+				],
 				[
 					13,
 					"sRaw",
@@ -2119,6 +2216,35 @@ function makeBoidsResolveKernel(colorSpaceMode) {
 						]]
 					]
 				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"atomicStore"
+					],
+					[[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"accumS"
+						],
+						"idx"
+					], [
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[5, "0"]]
+					]]
+				],
 				[
 					13,
 					"energy",
@@ -2135,55 +2261,81 @@ function makeBoidsResolveKernel(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",
+							[
+								[
+									7,
+									"prm",
+									"colA"
 								],
 								[
-									"agitAvg",
-									[5, "0"],
-									[5, "1"]
+									7,
+									"prm",
+									"colB"
+								],
+								[
+									6,
+									[
+										7,
+										"std",
+										"clamp"
+									],
+									[
+										"agitAvg",
+										[5, "0"],
+										[5, "1"]
+									]
 								]
 							]
 						]
-					]
+					]]]
 				],
 				[
 					13,
@@ -2452,36 +2604,36 @@ function makeBoidsResolveKernel(colorSpaceMode) {
 		},
 		externals: () => ({
 			simLayout,
-			d,
+			d: data_exports,
 			RES,
-			std,
+			std: std_exports,
 			mixFn
 		})
 	}) && $.f)({})).$name("boidsResolve");
 }
 const boidsResolveKernel = makeBoidsResolveKernel(2);
-const boidsUpdateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+const boidsUpdateKernel = src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 	"use gpu";
 	const prm = simLayout.$.params;
 	const self = simLayout.$.agents[i];
-	let pos = d.vec2f(self.x, self.y);
-	let vel = d.vec2f(self.z, self.w);
+	let pos = vec2f(self.x, self.y);
+	let vel = vec2f(self.z, self.w);
 	const dt = prm.dt;
-	const sVar = __tsover_add(.82, __tsover_mul(hash11(__tsover_add(__tsover_mul(d.f32(i), .61803), .13)), .4));
+	const sVar = __tsover_add(.82, __tsover_mul(hash11(__tsover_add(__tsover_mul(f32(i), .61803), .13)), .4));
 	const maxSpeedI = __tsover_mul(prm.maxSpeed, sVar);
-	let sep = d.vec2f(0, 0);
-	let ali = d.vec2f(0, 0);
-	let coh = d.vec2f(0, 0);
-	let nCount = d.f32(0);
-	let sCount = d.f32(0);
+	let sep = vec2f(0, 0);
+	let ali = vec2f(0, 0);
+	let coh = vec2f(0, 0);
+	let nCount = f32(0);
+	let sCount = f32(0);
 	for (let j = 0; j < MAX_AGENTS; j++) {
-		if (d.f32(j) >= prm.count) break;
-		const other = simLayout.$.agents[d.u32(j)];
-		const opos = d.vec2f(other.x, other.y);
+		if (f32(j) >= prm.count) break;
+		const other = simLayout.$.agents[u32(j)];
+		const opos = vec2f(other.x, other.y);
 		const off = pos.sub(opos);
-		const dsq = std.dot(off, off);
+		const dsq = dot(off, off);
 		if (dsq > 1e-7 && dsq < prm.perceptionSq) {
-			ali = ali.add(d.vec2f(other.z, other.w));
+			ali = ali.add(vec2f(other.z, other.w));
 			coh = coh.add(opos);
 			nCount = __tsover_add(nCount, 1);
 			if (dsq < prm.sepRadiusSq) {
@@ -2490,7 +2642,7 @@ const boidsUpdateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis._
 			}
 		}
 	}
-	let accel = d.vec2f(0, 0);
+	let accel = vec2f(0, 0);
 	if (nCount > .5) {
 		const aliSteer = safeSteer(ali.div(nCount), vel, maxSpeedI, prm.maxForce);
 		const cohSteer = safeSteer(coh.div(nCount).sub(pos), vel, maxSpeedI, prm.maxForce);
@@ -2498,37 +2650,37 @@ const boidsUpdateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis._
 	}
 	if (sCount > .5) accel = accel.add(safeSteer(sep, vel, maxSpeedI, prm.maxForce).mul(prm.sepW));
 	if (prm.cursorMode > .5) {
-		const cd = d.vec2f(prm.cursorX, prm.cursorY).sub(pos);
-		const cdsq = std.dot(cd, cd);
+		const cd = vec2f(prm.cursorX, prm.cursorY).sub(pos);
+		const cdsq = dot(cd, cd);
 		if (cdsq > 1e-7 && cdsq < prm.cursorRadiusSq) {
-			const cdist = std.sqrt(cdsq);
-			const falloff = __tsover_sub(1, __tsover_div(cdist, std.max(prm.cursorRadius, 1e-5)));
-			const sign = std.select(d.f32(1), d.f32(-1), prm.cursorMode > 1.5);
+			const cdist = sqrt(cdsq);
+			const falloff = __tsover_sub(1, __tsover_div(cdist, max(prm.cursorRadius, 1e-5)));
+			const sign = select(f32(1), f32(-1), prm.cursorMode > 1.5);
 			accel = accel.add(cd.div(cdist).mul(__tsover_mul(__tsover_mul(sign, falloff), prm.cursorForce)));
 		}
 	}
 	const m = prm.margin;
 	const tf = prm.turnForce;
-	accel = accel.add(d.vec2f(std.select(d.f32(0), tf, pos.x < m), d.f32(0)));
-	accel = accel.add(d.vec2f(std.select(d.f32(0), -tf, pos.x > __tsover_sub(prm.domainX, m)), d.f32(0)));
-	accel = accel.add(d.vec2f(d.f32(0), std.select(d.f32(0), tf, pos.y < m)));
-	accel = accel.add(d.vec2f(d.f32(0), std.select(d.f32(0), -tf, pos.y > __tsover_sub(1, m))));
-	const effort = __tsover_div(std.length(accel), std.max(prm.maxForce, 1e-5));
-	const raw = std.clamp(__tsover_mul(__tsover_sub(effort, AGIT_REST), AGIT_GAIN), 0, 1);
-	const cooled = __tsover_mul(simLayout.$.agit[i], std.exp(__tsover_mul(dt, -AGIT_COOL)));
-	simLayout.$.agit[i] = std.max(raw, cooled);
+	accel = accel.add(vec2f(select(f32(0), tf, pos.x < m), f32(0)));
+	accel = accel.add(vec2f(select(f32(0), -tf, pos.x > __tsover_sub(prm.domainX, m)), f32(0)));
+	accel = accel.add(vec2f(f32(0), select(f32(0), tf, pos.y < m)));
+	accel = accel.add(vec2f(f32(0), select(f32(0), -tf, pos.y > __tsover_sub(1, m))));
+	const effort = __tsover_div(length(accel), max(prm.maxForce, 1e-5));
+	const raw = clamp(__tsover_mul(__tsover_sub(effort, AGIT_REST), AGIT_GAIN), 0, 1);
+	const cooled = __tsover_mul(simLayout.$.agit[i], exp(__tsover_mul(dt, -AGIT_COOL)));
+	simLayout.$.agit[i] = max(raw, cooled);
 	vel = vel.add(accel.mul(dt));
-	const spd = std.length(vel);
-	const clamped = std.clamp(spd, __tsover_mul(maxSpeedI, .35), maxSpeedI);
-	vel = vel.div(std.max(spd, 1e-5)).mul(clamped);
+	const spd = length(vel);
+	const clamped = clamp(spd, __tsover_mul(maxSpeedI, .35), maxSpeedI);
+	vel = vel.div(max(spd, 1e-5)).mul(clamped);
 	pos = pos.add(vel.mul(dt));
 	const hitX = pos.x < 0 || pos.x > prm.domainX;
 	const hitY = pos.y < 0 || pos.y > 1;
-	const nvx = std.select(vel.x, __tsover_mul(vel.x, -.6), hitX);
-	const nvy = std.select(vel.y, __tsover_mul(vel.y, -.6), hitY);
-	const cx = std.clamp(pos.x, 0, prm.domainX);
-	const cy = std.clamp(pos.y, 0, 1);
-	simLayout.$.agents[i] = d.vec4f(cx, cy, nvx, nvy);
+	const nvx = select(vel.x, __tsover_mul(vel.x, -.6), hitX);
+	const nvy = select(vel.y, __tsover_mul(vel.y, -.6), hitY);
+	const cx = clamp(pos.x, 0, prm.domainX);
+	const cy = clamp(pos.y, 0, 1);
+	simLayout.$.agents[i] = vec4f(cx, cy, nvx, nvy);
 }), {
 	v: 1,
 	name: void 0,
@@ -4096,10 +4248,10 @@ const boidsUpdateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis._
 	},
 	externals: () => ({
 		simLayout,
-		d,
+		d: data_exports,
 		noise: noise_exports,
 		MAX_AGENTS,
-		std,
+		std: std_exports,
 		safeSteer,
 		AGIT_REST,
 		AGIT_GAIN,
@@ -4306,11 +4458,11 @@ const componentDefinition = {
 		const { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
 		const root = gpu?.root;
 		if (!root) return null;
-		const agents = createStateBuffer(root, d.vec4f, MAX_AGENTS);
-		const agitBuf = createStateBuffer(root, d.f32, MAX_AGENTS);
-		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 agents = createStateBuffer(root, vec4f, MAX_AGENTS);
+		const agitBuf = createStateBuffer(root, f32, MAX_AGENTS);
+		const accumE = createStateBuffer(root, atomic(u32), RES * RES);
+		const accumS = createStateBuffer(root, atomic(u32), RES * RES);
+		const trailBuf = createStateBuffer(root, vec4f, RES * RES);
 		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [RES, RES],
 			format: STATE_FORMAT
@@ -4349,29 +4501,6 @@ const componentDefinition = {
 			},
 			externals: () => ({ boidsInitKernel })
 		}) && $.f)({})).with(simBg);
-		const clearAccum = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
-			"use gpu";
-			boidsClearAccumKernel(x, y);
-		}), {
-			v: 1,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "x"
-				}, {
-					"type": "i",
-					"name": "y"
-				}],
-				"body": [0, [[
-					6,
-					"boidsClearAccumKernel",
-					["x", "y"]
-				]]],
-				"externalNames": ["boidsClearAccumKernel"]
-			},
-			externals: () => ({ boidsClearAccumKernel })
-		}) && $.f)({}), { size: [RES, RES] }).with(simBg);
 		const update = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 			"use gpu";
 			boidsUpdateKernel(i);
@@ -4449,7 +4578,7 @@ const componentDefinition = {
 					const v = getCpuValue(key);
 					return typeof v === "number" ? v : fallback;
 				};
-				const count = Math.min(Math.max(Math.round(g("count", 2e3)), 16), MAX_AGENTS);
+				const count = Math.min(Math.max(Math.round(g("count", 2e3)), 16), COUNT_CAP);
 				const seed = g("seed", 0);
 				const maxSpeed = BASE_SPEED * g("speed", 2);
 				const maxForce = maxSpeed * FORCE_RATIO;
@@ -4461,10 +4590,10 @@ const componentDefinition = {
 				const cursorRadius = .22;
 				const colA = getCpuValue("colorA");
 				const colB = getCpuValue("colorB");
-				const bodyR = Math.min(Math.max(g("size", 1.5), .5), 3) * 2 * INV_RES;
+				const bodyR = Math.min(Math.max(g("size", 1.5), .5), 3) * 2 / SIZE_REF_RES;
 				paramsU.write({
-					colA: d.vec4f(colA?.x ?? .56, colA?.y ?? .77, colA?.z ?? 1, colA?.w ?? 1),
-					colB: d.vec4f(colB?.x ?? 1, colB?.y ?? .48, colB?.z ?? .85, colB?.w ?? 1),
+					colA: vec4f(colA?.x ?? .56, colA?.y ?? .77, colA?.z ?? 1, colA?.w ?? 1),
+					colB: vec4f(colB?.x ?? 1, colB?.y ?? .48, colB?.z ?? .85, colB?.w ?? 1),
 					count,
 					trails: Math.min(Math.max(g("trails", .35), 0), 1) * .92,
 					dt,
@@ -4494,7 +4623,7 @@ const componentDefinition = {
 					lastSeed = seed;
 					nodes.push(() => init.dispatchThreads(MAX_AGENTS));
 				}
-				nodes.push(clearAccum, () => update.dispatchThreads(count), () => splat.dispatchThreads(count), resolve);
+				nodes.push(() => update.dispatchThreads(count), () => splat.dispatchThreads(count), resolve);
 				return nodes;
 			}
 		};
@@ -4506,4 +4635,4 @@ const componentDefinition = {
 	}
 };
 var Boids_default = componentDefinition;
-export { boidsSplatKernel as a, makeBoidsResolveKernel as c, boidsResolveKernel as i, makeBoidsSplatKernel as l, boidsClearAccumKernel as n, boidsUpdateKernel as o, boidsInitKernel as r, componentDefinition as s, Boids_default as t };
+export { boidsUpdateKernel as a, makeBoidsSplatKernel as c, boidsSplatKernel as i, boidsInitKernel as n, componentDefinition as o, boidsResolveKernel as r, makeBoidsResolveKernel as s, Boids_default as t };