shaders 3.0.442 → 3.0.444

package/dist/core/Boids-BWJXVflR.js

@@ -0,0 +1,4509 @@
+import { J as std, Rt as ZERO, X as createGuardedCompute, Z as createStateBuffer, bn as d, c as orientedShapeOptions, dn as mixColorsVariants, lt as hash33, n as tgpu, ot as hash11, pt as noise_exports, r as AGENT_SHAPES, s as makeAgentWeightFn, u as resolveAgentShape, un as mixColorsLinear } from "./coords-CLqRuQwC.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+var MAX_AGENTS = 4096;
+var RES = 1024;
+var INV_RES = 1 / RES;
+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;
+var FORCE_RATIO = 3.5;
+var AGIT_REST = 1.5;
+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
+}), "SimParams");
+var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	agents: {
+		storage: d.arrayOf(d.vec4f, MAX_AGENTS),
+		access: "mutable"
+	},
+	agit: {
+		storage: d.arrayOf(d.f32, MAX_AGENTS),
+		access: "mutable"
+	},
+	accumE: {
+		storage: d.arrayOf(d.atomic(d.u32), RES * RES),
+		access: "mutable"
+	},
+	accumS: {
+		storage: d.arrayOf(d.atomic(d.u32), RES * RES),
+		access: "mutable"
+	},
+	trailBuf: {
+		storage: d.arrayOf(d.vec4f, RES * RES),
+		access: "mutable"
+	},
+	params: { uniform: SimParams },
+	outTex: { storageTexture: d.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) => {
+	"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);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "dir"
+			},
+			{
+				"type": "i",
+				"name": "vel"
+			},
+			{
+				"type": "i",
+				"name": "maxSpeed"
+			},
+			{
+				"type": "i",
+				"name": "maxForce"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"len",
+				[
+					6,
+					[
+						7,
+						"std",
+						"length"
+					],
+					["dir"]
+				]
+			],
+			[
+				13,
+				"desired",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[5, "0"], [5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"dir",
+										"div"
+									],
+									[[
+										6,
+										[
+											7,
+											"std",
+											"max"
+										],
+										["len", [5, "0.00001"]]
+									]]
+								],
+								"mul"
+							],
+							["maxSpeed"]
+						],
+						[
+							1,
+							"len",
+							">",
+							[5, "0.00001"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"steer",
+				[
+					6,
+					[
+						7,
+						"desired",
+						"sub"
+					],
+					["vel"]
+				]
+			],
+			[
+				13,
+				"sl",
+				[
+					6,
+					[
+						7,
+						"std",
+						"length"
+					],
+					["steer"]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					"steer",
+					[
+						6,
+						[
+							7,
+							[
+								6,
+								[
+									7,
+									"steer",
+									"div"
+								],
+								[[
+									6,
+									[
+										7,
+										"std",
+										"max"
+									],
+									["sl", [5, "0.00001"]]
+								]]
+							],
+							"mul"
+						],
+						["maxForce"]
+					],
+					[
+						1,
+						"sl",
+						">",
+						"maxForce"
+					]
+				]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std,
+		d
+	})
+}) && $.f)({}));
+const boidsInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+	"use gpu";
+	const prm = simLayout.$.params;
+	const fi = d.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 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 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 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);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "i"
+		}],
+		"body": [0, [
+			[
+				13,
+				"prm",
+				[
+					7,
+					[
+						7,
+						"simLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"fi",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["i"]
+				]
+			],
+			[
+				13,
+				"sd",
+				[
+					1,
+					[
+						7,
+						"prm",
+						"seed"
+					],
+					"*",
+					[5, "13.137"]
+				]
+			],
+			[
+				13,
+				"flocks",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"floor"
+						],
+						[[
+							1,
+							[
+								7,
+								"prm",
+								"count"
+							],
+							"/",
+							[5, "250"]
+						]]
+					], [
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[5, "3"]]
+					]]
+				]
+			],
+			[
+				13,
+				"c",
+				[
+					1,
+					"fi",
+					"-",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"fi",
+								"/",
+								"flocks"
+							]]
+						],
+						"*",
+						"flocks"
+					]
+				]
+			],
+			[
+				13,
+				"rc",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"hash33"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"c",
+										"*",
+										[5, "7.1315"]
+									],
+									"+",
+									"sd"
+								],
+								"+",
+								[5, "0.71"]
+							],
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"c",
+										"*",
+										[5, "3.7719"]
+									],
+									"+",
+									"sd"
+								],
+								"+",
+								[5, "4.17"]
+							],
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"c",
+										"*",
+										[5, "9.4103"]
+									],
+									"+",
+									"sd"
+								],
+								"+",
+								[5, "9.03"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"ang",
+				[
+					1,
+					[
+						7,
+						"rc",
+						"z"
+					],
+					"*",
+					"TAU"
+				]
+			],
+			[
+				13,
+				"hd",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"cos"
+						],
+						["ang"]
+					], [
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						["ang"]
+					]]
+				]
+			],
+			[
+				13,
+				"center",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							1,
+							[5, "0.12"],
+							"+",
+							[
+								1,
+								[
+									7,
+									"rc",
+									"x"
+								],
+								"*",
+								[5, "0.76"]
+							]
+						],
+						"*",
+						[
+							7,
+							"prm",
+							"domainX"
+						]
+					], [
+						1,
+						[5, "0.12"],
+						"+",
+						[
+							1,
+							[
+								7,
+								"rc",
+								"y"
+							],
+							"*",
+							[5, "0.76"]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"ra",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"hash33"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec3f"
+						],
+						[
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"fi",
+										"*",
+										[5, "1.6180339"]
+									],
+									"+",
+									"sd"
+								],
+								"+",
+								[5, "0.71"]
+							],
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"fi",
+										"*",
+										[5, "2.7182818"]
+									],
+									"+",
+									"sd"
+								],
+								"+",
+								[5, "4.17"]
+							],
+							[
+								1,
+								[
+									1,
+									[
+										1,
+										"fi",
+										"*",
+										[5, "3.1415926"]
+									],
+									"+",
+									"sd"
+								],
+								"+",
+								[5, "9.03"]
+							]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"t",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"ra",
+							"x"
+						],
+						"-",
+						[5, "0.5"]
+					],
+					"*",
+					[5, "0.6"]
+				]
+			],
+			[
+				13,
+				"n",
+				[
+					1,
+					[
+						1,
+						[
+							7,
+							"ra",
+							"y"
+						],
+						"-",
+						[5, "0.5"]
+					],
+					"*",
+					[5, "0.16"]
+				]
+			],
+			[
+				13,
+				"px",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"center",
+									"x"
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"hd",
+										"x"
+									],
+									"*",
+									"t"
+								]
+							],
+							"-",
+							[
+								1,
+								[
+									7,
+									"hd",
+									"y"
+								],
+								"*",
+								"n"
+							]
+						],
+						[5, "0"],
+						[
+							7,
+							"prm",
+							"domainX"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"py",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								[
+									7,
+									"center",
+									"y"
+								],
+								"+",
+								[
+									1,
+									[
+										7,
+										"hd",
+										"y"
+									],
+									"*",
+									"t"
+								]
+							],
+							"+",
+							[
+								1,
+								[
+									7,
+									"hd",
+									"x"
+								],
+								"*",
+								"n"
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"jAng",
+				[
+					1,
+					"ang",
+					"+",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"ra",
+								"z"
+							],
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						[5, "0.5"]
+					]
+				]
+			],
+			[
+				13,
+				"sp",
+				[
+					1,
+					[
+						7,
+						"prm",
+						"maxSpeed"
+					],
+					"*",
+					[
+						1,
+						[5, "0.75"],
+						"+",
+						[
+							1,
+							[
+								7,
+								"ra",
+								"y"
+							],
+							"*",
+							[5, "0.25"]
+						]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"agents"
+					],
+					"i"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"px",
+						"py",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"cos"
+								],
+								["jAng"]
+							],
+							"*",
+							"sp"
+						],
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"sin"
+								],
+								["jAng"]
+							],
+							"*",
+							"sp"
+						]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"agit"
+					],
+					"i"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			]
+		]],
+		"externalNames": [
+			"simLayout",
+			"d",
+			"std",
+			"noise",
+			"TAU"
+		]
+	},
+	externals: () => ({
+		simLayout,
+		d,
+		std,
+		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 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) => {
+		"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 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 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))));
+					}
+				}
+			}
+		}
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "i"
+			}],
+			"body": [0, [
+				[
+					13,
+					"prm",
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"a",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"agents"
+						],
+						"i"
+					]
+				],
+				[
+					13,
+					"pos",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							7,
+							"a",
+							"x"
+						], [
+							7,
+							"a",
+							"y"
+						]]
+					]
+				],
+				[
+					13,
+					"vel",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							7,
+							"a",
+							"z"
+						], [
+							7,
+							"a",
+							"w"
+						]]
+					]
+				],
+				[
+					13,
+					"spd",
+					[
+						6,
+						[
+							7,
+							"std",
+							"length"
+						],
+						["vel"]
+					]
+				],
+				[
+					13,
+					"dir",
+					[
+						6,
+						[
+							7,
+							"std",
+							"select"
+						],
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"vec2f"
+								],
+								[[5, "1"], [5, "0"]]
+							],
+							[
+								6,
+								[
+									7,
+									"vel",
+									"div"
+								],
+								[[
+									6,
+									[
+										7,
+										"std",
+										"max"
+									],
+									["spd", [5, "0.00001"]]
+								]]
+							],
+							[
+								1,
+								"spd",
+								">",
+								[5, "0.00001"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"agitI",
+					[
+						6,
+						[
+							7,
+							"std",
+							"clamp"
+						],
+						[
+							[
+								8,
+								[
+									7,
+									[
+										7,
+										"simLayout",
+										"$"
+									],
+									"agit"
+								],
+								"i"
+							],
+							[5, "0"],
+							[5, "1"]
+						]
+					]
+				],
+				[
+					13,
+					"bodyR",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"prm",
+							"bodyR"
+						], [5, "0.000001"]]
+					]
+				],
+				[
+					13,
+					"hl",
+					[
+						1,
+						"bodyR",
+						"*",
+						"HL"
+					]
+				],
+				[
+					13,
+					"extSq",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"bodyR",
+								"*",
+								"EXT"
+							],
+							"+",
+							[
+								1,
+								"AA_W",
+								"*",
+								[5, "2"]
+							]
+						],
+						"*",
+						[
+							1,
+							[
+								1,
+								"bodyR",
+								"*",
+								"EXT"
+							],
+							"+",
+							[
+								1,
+								"AA_W",
+								"*",
+								[5, "2"]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"txf",
+					[
+						1,
+						[
+							1,
+							[
+								7,
+								"pos",
+								"x"
+							],
+							"/",
+							[
+								7,
+								"prm",
+								"aspect"
+							]
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["RES"]
+						]
+					]
+				],
+				[
+					13,
+					"tyf",
+					[
+						1,
+						[
+							7,
+							"pos",
+							"y"
+						],
+						"*",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							["RES"]
+						]
+					]
+				],
+				[
+					13,
+					"cxi",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							["txf"]
+						]]
+					]
+				],
+				[
+					13,
+					"cyi",
+					[
+						6,
+						[
+							7,
+							"d",
+							"i32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							["tyf"]
+						]]
+					]
+				],
+				[
+					14,
+					[
+						12,
+						"ky",
+						[5, "0"]
+					],
+					[
+						1,
+						"ky",
+						"<",
+						"SPLAT_WIN"
+					],
+					[
+						102,
+						"++",
+						"ky"
+					],
+					[0, [[
+						14,
+						[
+							12,
+							"kx",
+							[5, "0"]
+						],
+						[
+							1,
+							"kx",
+							"<",
+							"SPLAT_WIN"
+						],
+						[
+							102,
+							"++",
+							"kx"
+						],
+						[0, [
+							[
+								13,
+								"px",
+								[
+									1,
+									[
+										1,
+										"cxi",
+										"+",
+										"kx"
+									],
+									"-",
+									"SPLAT_R"
+								]
+							],
+							[
+								13,
+								"py",
+								[
+									1,
+									[
+										1,
+										"cyi",
+										"+",
+										"ky"
+									],
+									"-",
+									"SPLAT_R"
+								]
+							],
+							[
+								11,
+								[
+									3,
+									[
+										3,
+										[
+											3,
+											[
+												1,
+												"px",
+												">=",
+												[5, "0"]
+											],
+											"&&",
+											[
+												1,
+												"px",
+												"<",
+												"RES"
+											]
+										],
+										"&&",
+										[
+											1,
+											"py",
+											">=",
+											[5, "0"]
+										]
+									],
+									"&&",
+									[
+										1,
+										"py",
+										"<",
+										"RES"
+									]
+								],
+								[0, [
+									[
+										13,
+										"offX",
+										[
+											1,
+											[
+												1,
+												[
+													1,
+													[
+														1,
+														[
+															6,
+															[
+																7,
+																"d",
+																"f32"
+															],
+															["px"]
+														],
+														"+",
+														[5, "0.5"]
+													],
+													"*",
+													"INV_RES"
+												],
+												"*",
+												[
+													7,
+													"prm",
+													"aspect"
+												]
+											],
+											"-",
+											[
+												7,
+												"pos",
+												"x"
+											]
+										]
+									],
+									[
+										13,
+										"offY",
+										[
+											1,
+											[
+												1,
+												[
+													1,
+													[
+														6,
+														[
+															7,
+															"d",
+															"f32"
+														],
+														["py"]
+													],
+													"+",
+													[5, "0.5"]
+												],
+												"*",
+												"INV_RES"
+											],
+											"-",
+											[
+												7,
+												"pos",
+												"y"
+											]
+										]
+									],
+									[
+										11,
+										[
+											1,
+											[
+												1,
+												[
+													1,
+													"offX",
+													"*",
+													"offX"
+												],
+												"+",
+												[
+													1,
+													"offY",
+													"*",
+													"offY"
+												]
+											],
+											"<",
+											"extSq"
+										],
+										[0, [
+											[
+												13,
+												"t",
+												[
+													1,
+													[
+														1,
+														"offX",
+														"*",
+														[
+															7,
+															"dir",
+															"x"
+														]
+													],
+													"+",
+													[
+														1,
+														"offY",
+														"*",
+														[
+															7,
+															"dir",
+															"y"
+														]
+													]
+												]
+											],
+											[
+												13,
+												"n",
+												[
+													1,
+													[
+														1,
+														"offX",
+														"*",
+														[
+															4,
+															"-",
+															[
+																7,
+																"dir",
+																"y"
+															]
+														]
+													],
+													"+",
+													[
+														1,
+														"offY",
+														"*",
+														[
+															7,
+															"dir",
+															"x"
+														]
+													]
+												]
+											],
+											[
+												13,
+												"tGlow",
+												[
+													1,
+													"t",
+													"-",
+													[
+														6,
+														[
+															7,
+															"std",
+															"clamp"
+														],
+														[
+															"t",
+															[
+																4,
+																"-",
+																"hl"
+															],
+															"hl"
+														]
+													]
+												]
+											],
+											[
+												13,
+												"tEval",
+												[
+													6,
+													[
+														7,
+														"std",
+														"select"
+													],
+													[
+														"t",
+														"tGlow",
+														[
+															1,
+															[
+																6,
+																[
+																	7,
+																	"d",
+																	"f32"
+																],
+																["SOFT"]
+															],
+															">",
+															[5, "0.5"]
+														]
+													]
+												]
+											],
+											[
+												13,
+												"tk",
+												[
+													6,
+													[
+														7,
+														"std",
+														"clamp"
+													],
+													[
+														[
+															1,
+															[
+																1,
+																"hl",
+																"-",
+																"t"
+															],
+															"/",
+															[
+																6,
+																[
+																	7,
+																	"std",
+																	"max"
+																],
+																[[
+																	1,
+																	"hl",
+																	"*",
+																	[5, "2"]
+																], [5, "0.000001"]]
+															]
+														],
+														[5, "0"],
+														[5, "1"]
+													]
+												]
+											],
+											[
+												13,
+												"bright",
+												[
+													1,
+													[5, "1"],
+													"-",
+													[
+														1,
+														[
+															1,
+															[5, "0.55"],
+															"*",
+															"tk"
+														],
+														"*",
+														[
+															6,
+															[
+																7,
+																"d",
+																"f32"
+															],
+															["SOFT"]
+														]
+													]
+												]
+											],
+											[
+												13,
+												"w",
+												[
+													1,
+													[
+														6,
+														"weightFn",
+														[
+															"tEval",
+															"n",
+															"bodyR",
+															"AA_W",
+															[
+																6,
+																[
+																	7,
+																	"d",
+																	"f32"
+																],
+																["SOFT"]
+															]
+														]
+													],
+													"*",
+													"bright"
+												]
+											],
+											[
+												13,
+												"e",
+												[
+													6,
+													[
+														7,
+														"d",
+														"u32"
+													],
+													[[
+														1,
+														"w",
+														"*",
+														[
+															6,
+															[
+																7,
+																"d",
+																"f32"
+															],
+															["GAIN"]
+														]
+													]]
+												]
+											],
+											[
+												11,
+												[
+													1,
+													"e",
+													">",
+													[
+														6,
+														[
+															7,
+															"d",
+															"u32"
+														],
+														[[5, "0"]]
+													]
+												],
+												[0, [
+													[
+														13,
+														"idx",
+														[
+															6,
+															[
+																7,
+																"d",
+																"u32"
+															],
+															[[
+																1,
+																[
+																	1,
+																	"py",
+																	"*",
+																	"RES"
+																],
+																"+",
+																"px"
+															]]
+														]
+													],
+													[
+														6,
+														[
+															7,
+															"std",
+															"atomicAdd"
+														],
+														[[
+															8,
+															[
+																7,
+																[
+																	7,
+																	"simLayout",
+																	"$"
+																],
+																"accumE"
+															],
+															"idx"
+														], "e"]
+													],
+													[
+														6,
+														[
+															7,
+															"std",
+															"atomicAdd"
+														],
+														[[
+															8,
+															[
+																7,
+																[
+																	7,
+																	"simLayout",
+																	"$"
+																],
+																"accumS"
+															],
+															"idx"
+														], [
+															6,
+															[
+																7,
+																"d",
+																"u32"
+															],
+															[[
+																1,
+																[
+																	1,
+																	"w",
+																	"*",
+																	"agitI"
+																],
+																"*",
+																[
+																	6,
+																	[
+																		7,
+																		"d",
+																		"f32"
+																	],
+																	["GAIN"]
+																]
+															]]
+														]]
+													]
+												]]
+											]
+										]]
+									]
+								]]
+							]
+						]]
+					]]]
+				]
+			]],
+			"externalNames": [
+				"simLayout",
+				"d",
+				"std",
+				"HL",
+				"EXT",
+				"AA_W",
+				"RES",
+				"SPLAT_WIN",
+				"SPLAT_R",
+				"INV_RES",
+				"SOFT",
+				"weightFn",
+				"GAIN"
+			]
+		},
+		externals: () => ({
+			simLayout,
+			d,
+			std,
+			HL,
+			EXT,
+			AA_W,
+			RES,
+			SPLAT_WIN,
+			SPLAT_R,
+			INV_RES,
+			SOFT,
+			weightFn,
+			GAIN
+		})
+	}) && $.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) => {
+		"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 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 = 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));
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [{
+				"type": "i",
+				"name": "x"
+			}, {
+				"type": "i",
+				"name": "y"
+			}],
+			"body": [0, [
+				[
+					13,
+					"prm",
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"params"
+					]
+				],
+				[
+					13,
+					"idx",
+					[
+						1,
+						[
+							1,
+							"y",
+							"*",
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["RES"]
+							]
+						],
+						"+",
+						"x"
+					]
+				],
+				[
+					13,
+					"eRaw",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"atomicLoad"
+							],
+							[[
+								8,
+								[
+									7,
+									[
+										7,
+										"simLayout",
+										"$"
+									],
+									"accumE"
+								],
+								"idx"
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"sRaw",
+					[
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"atomicLoad"
+							],
+							[[
+								8,
+								[
+									7,
+									[
+										7,
+										"simLayout",
+										"$"
+									],
+									"accumS"
+								],
+								"idx"
+							]]
+						]]
+					]
+				],
+				[
+					13,
+					"energy",
+					[
+						1,
+						"eRaw",
+						"*",
+						[
+							1,
+							[5, "1"],
+							"/",
+							[5, "255"]
+						]
+					]
+				],
+				[
+					13,
+					"agitAvg",
+					[
+						1,
+						"sRaw",
+						"/",
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							["eRaw", [5, "1"]]
+						]
+					]
+				],
+				[
+					13,
+					"col",
+					[
+						6,
+						"mixFn",
+						[
+							[
+								7,
+								"prm",
+								"colA"
+							],
+							[
+								7,
+								"prm",
+								"colB"
+							],
+							[
+								6,
+								[
+									7,
+									"std",
+									"clamp"
+								],
+								[
+									"agitAvg",
+									[5, "0"],
+									[5, "1"]
+								]
+							]
+						]
+					]
+				],
+				[
+					13,
+					"curA",
+					[
+						1,
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								6,
+								[
+									7,
+									"std",
+									"exp"
+								],
+								[[
+									1,
+									"energy",
+									"*",
+									[
+										4,
+										"-",
+										[5, "1.6"]
+									]
+								]]
+							]
+						],
+						"*",
+						[
+							7,
+							"col",
+							"w"
+						]
+					]
+				],
+				[
+					13,
+					"prev",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"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",
+					[
+						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"
+						]
+					]
+				],
+				[
+					2,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"trailBuf"
+						],
+						"idx"
+					],
+					"=",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec4f"
+						],
+						[
+							[
+								7,
+								"outRGB",
+								"x"
+							],
+							[
+								7,
+								"outRGB",
+								"y"
+							],
+							[
+								7,
+								"outRGB",
+								"z"
+							],
+							"outA"
+						]
+					]
+				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureStore"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"outTex"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["x", "y"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec4f"
+							],
+							[
+								[
+									7,
+									"outRGB",
+									"x"
+								],
+								[
+									7,
+									"outRGB",
+									"y"
+								],
+								[
+									7,
+									"outRGB",
+									"z"
+								],
+								"outA"
+							]
+						]
+					]
+				]
+			]],
+			"externalNames": [
+				"simLayout",
+				"d",
+				"RES",
+				"std",
+				"mixFn"
+			]
+		},
+		externals: () => ({
+			simLayout,
+			d,
+			RES,
+			std,
+			mixFn
+		})
+	}) && $.f)({})).$name("boidsResolve");
+}
+const boidsResolveKernel = makeBoidsResolveKernel(2);
+const boidsUpdateKernel = tgpu.fn([d.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);
+	const dt = prm.dt;
+	const sVar = __tsover_add(.82, __tsover_mul(hash11(__tsover_add(__tsover_mul(d.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);
+	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);
+		const off = pos.sub(opos);
+		const dsq = std.dot(off, off);
+		if (dsq > 1e-7 && dsq < prm.perceptionSq) {
+			ali = ali.add(d.vec2f(other.z, other.w));
+			coh = coh.add(opos);
+			nCount = __tsover_add(nCount, 1);
+			if (dsq < prm.sepRadiusSq) {
+				sep = sep.add(off.div(dsq));
+				sCount = __tsover_add(sCount, 1);
+			}
+		}
+	}
+	let accel = d.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);
+		accel = accel.add(aliSteer.mul(prm.aliW)).add(cohSteer.mul(prm.cohW));
+	}
+	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);
+		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);
+			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);
+	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);
+	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);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "i"
+		}],
+		"body": [0, [
+			[
+				13,
+				"prm",
+				[
+					7,
+					[
+						7,
+						"simLayout",
+						"$"
+					],
+					"params"
+				]
+			],
+			[
+				13,
+				"self",
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"agents"
+					],
+					"i"
+				]
+			],
+			[
+				12,
+				"pos",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						7,
+						"self",
+						"x"
+					], [
+						7,
+						"self",
+						"y"
+					]]
+				]
+			],
+			[
+				12,
+				"vel",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						7,
+						"self",
+						"z"
+					], [
+						7,
+						"self",
+						"w"
+					]]
+				]
+			],
+			[
+				13,
+				"dt",
+				[
+					7,
+					"prm",
+					"dt"
+				]
+			],
+			[
+				13,
+				"sVar",
+				[
+					1,
+					[5, "0.82"],
+					"+",
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"noise",
+								"hash11"
+							],
+							[[
+								1,
+								[
+									1,
+									[
+										6,
+										[
+											7,
+											"d",
+											"f32"
+										],
+										["i"]
+									],
+									"*",
+									[5, "0.61803"]
+								],
+								"+",
+								[5, "0.13"]
+							]]
+						],
+						"*",
+						[5, "0.4"]
+					]
+				]
+			],
+			[
+				13,
+				"maxSpeedI",
+				[
+					1,
+					[
+						7,
+						"prm",
+						"maxSpeed"
+					],
+					"*",
+					"sVar"
+				]
+			],
+			[
+				12,
+				"sep",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[5, "0"], [5, "0"]]
+				]
+			],
+			[
+				12,
+				"ali",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[5, "0"], [5, "0"]]
+				]
+			],
+			[
+				12,
+				"coh",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[5, "0"], [5, "0"]]
+				]
+			],
+			[
+				12,
+				"nCount",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				12,
+				"sCount",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			],
+			[
+				14,
+				[
+					12,
+					"j",
+					[5, "0"]
+				],
+				[
+					1,
+					"j",
+					"<",
+					"MAX_AGENTS"
+				],
+				[
+					102,
+					"++",
+					"j"
+				],
+				[0, [
+					[
+						11,
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["j"]
+							],
+							">=",
+							[
+								7,
+								"prm",
+								"count"
+							]
+						],
+						[0, [[17]]]
+					],
+					[
+						13,
+						"other",
+						[
+							8,
+							[
+								7,
+								[
+									7,
+									"simLayout",
+									"$"
+								],
+								"agents"
+							],
+							[
+								6,
+								[
+									7,
+									"d",
+									"u32"
+								],
+								["j"]
+							]
+						]
+					],
+					[
+						13,
+						"opos",
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[
+								7,
+								"other",
+								"x"
+							], [
+								7,
+								"other",
+								"y"
+							]]
+						]
+					],
+					[
+						13,
+						"off",
+						[
+							6,
+							[
+								7,
+								"pos",
+								"sub"
+							],
+							["opos"]
+						]
+					],
+					[
+						13,
+						"dsq",
+						[
+							6,
+							[
+								7,
+								"std",
+								"dot"
+							],
+							["off", "off"]
+						]
+					],
+					[
+						11,
+						[
+							3,
+							[
+								1,
+								"dsq",
+								">",
+								[5, "1e-7"]
+							],
+							"&&",
+							[
+								1,
+								"dsq",
+								"<",
+								[
+									7,
+									"prm",
+									"perceptionSq"
+								]
+							]
+						],
+						[0, [
+							[
+								2,
+								"ali",
+								"=",
+								[
+									6,
+									[
+										7,
+										"ali",
+										"add"
+									],
+									[[
+										6,
+										[
+											7,
+											"d",
+											"vec2f"
+										],
+										[[
+											7,
+											"other",
+											"z"
+										], [
+											7,
+											"other",
+											"w"
+										]]
+									]]
+								]
+							],
+							[
+								2,
+								"coh",
+								"=",
+								[
+									6,
+									[
+										7,
+										"coh",
+										"add"
+									],
+									["opos"]
+								]
+							],
+							[
+								2,
+								"nCount",
+								"=",
+								[
+									1,
+									"nCount",
+									"+",
+									[5, "1"]
+								]
+							],
+							[
+								11,
+								[
+									1,
+									"dsq",
+									"<",
+									[
+										7,
+										"prm",
+										"sepRadiusSq"
+									]
+								],
+								[0, [[
+									2,
+									"sep",
+									"=",
+									[
+										6,
+										[
+											7,
+											"sep",
+											"add"
+										],
+										[[
+											6,
+											[
+												7,
+												"off",
+												"div"
+											],
+											["dsq"]
+										]]
+									]
+								], [
+									2,
+									"sCount",
+									"=",
+									[
+										1,
+										"sCount",
+										"+",
+										[5, "1"]
+									]
+								]]]
+							]
+						]]
+					]
+				]]
+			],
+			[
+				12,
+				"accel",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[5, "0"], [5, "0"]]
+				]
+			],
+			[
+				11,
+				[
+					1,
+					"nCount",
+					">",
+					[5, "0.5"]
+				],
+				[0, [
+					[
+						13,
+						"aliSteer",
+						[
+							6,
+							"safeSteer",
+							[
+								[
+									6,
+									[
+										7,
+										"ali",
+										"div"
+									],
+									["nCount"]
+								],
+								"vel",
+								"maxSpeedI",
+								[
+									7,
+									"prm",
+									"maxForce"
+								]
+							]
+						]
+					],
+					[
+						13,
+						"cohSteer",
+						[
+							6,
+							"safeSteer",
+							[
+								[
+									6,
+									[
+										7,
+										[
+											6,
+											[
+												7,
+												"coh",
+												"div"
+											],
+											["nCount"]
+										],
+										"sub"
+									],
+									["pos"]
+								],
+								"vel",
+								"maxSpeedI",
+								[
+									7,
+									"prm",
+									"maxForce"
+								]
+							]
+						]
+					],
+					[
+						2,
+						"accel",
+						"=",
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"accel",
+										"add"
+									],
+									[[
+										6,
+										[
+											7,
+											"aliSteer",
+											"mul"
+										],
+										[[
+											7,
+											"prm",
+											"aliW"
+										]]
+									]]
+								],
+								"add"
+							],
+							[[
+								6,
+								[
+									7,
+									"cohSteer",
+									"mul"
+								],
+								[[
+									7,
+									"prm",
+									"cohW"
+								]]
+							]]
+						]
+					]
+				]]
+			],
+			[
+				11,
+				[
+					1,
+					"sCount",
+					">",
+					[5, "0.5"]
+				],
+				[0, [[
+					2,
+					"accel",
+					"=",
+					[
+						6,
+						[
+							7,
+							"accel",
+							"add"
+						],
+						[[
+							6,
+							[
+								7,
+								[
+									6,
+									"safeSteer",
+									[
+										"sep",
+										"vel",
+										"maxSpeedI",
+										[
+											7,
+											"prm",
+											"maxForce"
+										]
+									]
+								],
+								"mul"
+							],
+							[[
+								7,
+								"prm",
+								"sepW"
+							]]
+						]]
+					]
+				]]]
+			],
+			[
+				11,
+				[
+					1,
+					[
+						7,
+						"prm",
+						"cursorMode"
+					],
+					">",
+					[5, "0.5"]
+				],
+				[0, [
+					[
+						13,
+						"cd",
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"d",
+										"vec2f"
+									],
+									[[
+										7,
+										"prm",
+										"cursorX"
+									], [
+										7,
+										"prm",
+										"cursorY"
+									]]
+								],
+								"sub"
+							],
+							["pos"]
+						]
+					],
+					[
+						13,
+						"cdsq",
+						[
+							6,
+							[
+								7,
+								"std",
+								"dot"
+							],
+							["cd", "cd"]
+						]
+					],
+					[
+						11,
+						[
+							3,
+							[
+								1,
+								"cdsq",
+								">",
+								[5, "1e-7"]
+							],
+							"&&",
+							[
+								1,
+								"cdsq",
+								"<",
+								[
+									7,
+									"prm",
+									"cursorRadiusSq"
+								]
+							]
+						],
+						[0, [
+							[
+								13,
+								"cdist",
+								[
+									6,
+									[
+										7,
+										"std",
+										"sqrt"
+									],
+									["cdsq"]
+								]
+							],
+							[
+								13,
+								"falloff",
+								[
+									1,
+									[5, "1"],
+									"-",
+									[
+										1,
+										"cdist",
+										"/",
+										[
+											6,
+											[
+												7,
+												"std",
+												"max"
+											],
+											[[
+												7,
+												"prm",
+												"cursorRadius"
+											], [5, "0.00001"]]
+										]
+									]
+								]
+							],
+							[
+								13,
+								"sign",
+								[
+									6,
+									[
+										7,
+										"std",
+										"select"
+									],
+									[
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[5, "1"]]
+										],
+										[
+											6,
+											[
+												7,
+												"d",
+												"f32"
+											],
+											[[
+												4,
+												"-",
+												[5, "1"]
+											]]
+										],
+										[
+											1,
+											[
+												7,
+												"prm",
+												"cursorMode"
+											],
+											">",
+											[5, "1.5"]
+										]
+									]
+								]
+							],
+							[
+								2,
+								"accel",
+								"=",
+								[
+									6,
+									[
+										7,
+										"accel",
+										"add"
+									],
+									[[
+										6,
+										[
+											7,
+											[
+												6,
+												[
+													7,
+													"cd",
+													"div"
+												],
+												["cdist"]
+											],
+											"mul"
+										],
+										[[
+											1,
+											[
+												1,
+												"sign",
+												"*",
+												"falloff"
+											],
+											"*",
+											[
+												7,
+												"prm",
+												"cursorForce"
+											]
+										]]
+									]]
+								]
+							]
+						]]
+					]
+				]]
+			],
+			[
+				13,
+				"m",
+				[
+					7,
+					"prm",
+					"margin"
+				]
+			],
+			[
+				13,
+				"tf",
+				[
+					7,
+					"prm",
+					"turnForce"
+				]
+			],
+			[
+				2,
+				"accel",
+				"=",
+				[
+					6,
+					[
+						7,
+						"accel",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"select"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								"tf",
+								[
+									1,
+									[
+										7,
+										"pos",
+										"x"
+									],
+									"<",
+									"m"
+								]
+							]
+						], [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]]
+					]]
+				]
+			],
+			[
+				2,
+				"accel",
+				"=",
+				[
+					6,
+					[
+						7,
+						"accel",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"select"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									4,
+									"-",
+									"tf"
+								],
+								[
+									1,
+									[
+										7,
+										"pos",
+										"x"
+									],
+									">",
+									[
+										1,
+										[
+											7,
+											"prm",
+											"domainX"
+										],
+										"-",
+										"m"
+									]
+								]
+							]
+						], [
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]]
+					]]
+				]
+			],
+			[
+				2,
+				"accel",
+				"=",
+				[
+					6,
+					[
+						7,
+						"accel",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						], [
+							6,
+							[
+								7,
+								"std",
+								"select"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								"tf",
+								[
+									1,
+									[
+										7,
+										"pos",
+										"y"
+									],
+									"<",
+									"m"
+								]
+							]
+						]]
+					]]
+				]
+			],
+			[
+				2,
+				"accel",
+				"=",
+				[
+					6,
+					[
+						7,
+						"accel",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						], [
+							6,
+							[
+								7,
+								"std",
+								"select"
+							],
+							[
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									[[5, "0"]]
+								],
+								[
+									4,
+									"-",
+									"tf"
+								],
+								[
+									1,
+									[
+										7,
+										"pos",
+										"y"
+									],
+									">",
+									[
+										1,
+										[5, "1"],
+										"-",
+										"m"
+									]
+								]
+							]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"effort",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"std",
+							"length"
+						],
+						["accel"]
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"prm",
+							"maxForce"
+						], [5, "0.00001"]]
+					]
+				]
+			],
+			[
+				13,
+				"raw",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								1,
+								"effort",
+								"-",
+								"AGIT_REST"
+							],
+							"*",
+							"AGIT_GAIN"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"cooled",
+				[
+					1,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"agit"
+						],
+						"i"
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							"dt",
+							"*",
+							[
+								4,
+								"-",
+								"AGIT_COOL"
+							]
+						]]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"agit"
+					],
+					"i"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					["raw", "cooled"]
+				]
+			],
+			[
+				2,
+				"vel",
+				"=",
+				[
+					6,
+					[
+						7,
+						"vel",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"accel",
+							"mul"
+						],
+						["dt"]
+					]]
+				]
+			],
+			[
+				13,
+				"spd",
+				[
+					6,
+					[
+						7,
+						"std",
+						"length"
+					],
+					["vel"]
+				]
+			],
+			[
+				13,
+				"clamped",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						"spd",
+						[
+							1,
+							"maxSpeedI",
+							"*",
+							[5, "0.35"]
+						],
+						"maxSpeedI"
+					]
+				]
+			],
+			[
+				2,
+				"vel",
+				"=",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"vel",
+								"div"
+							],
+							[[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								["spd", [5, "0.00001"]]
+							]]
+						],
+						"mul"
+					],
+					["clamped"]
+				]
+			],
+			[
+				2,
+				"pos",
+				"=",
+				[
+					6,
+					[
+						7,
+						"pos",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"vel",
+							"mul"
+						],
+						["dt"]
+					]]
+				]
+			],
+			[
+				13,
+				"hitX",
+				[
+					3,
+					[
+						1,
+						[
+							7,
+							"pos",
+							"x"
+						],
+						"<",
+						[5, "0"]
+					],
+					"||",
+					[
+						1,
+						[
+							7,
+							"pos",
+							"x"
+						],
+						">",
+						[
+							7,
+							"prm",
+							"domainX"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"hitY",
+				[
+					3,
+					[
+						1,
+						[
+							7,
+							"pos",
+							"y"
+						],
+						"<",
+						[5, "0"]
+					],
+					"||",
+					[
+						1,
+						[
+							7,
+							"pos",
+							"y"
+						],
+						">",
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"nvx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							7,
+							"vel",
+							"x"
+						],
+						[
+							1,
+							[
+								7,
+								"vel",
+								"x"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "0.6"]
+							]
+						],
+						"hitX"
+					]
+				]
+			],
+			[
+				13,
+				"nvy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						[
+							7,
+							"vel",
+							"y"
+						],
+						[
+							1,
+							[
+								7,
+								"vel",
+								"y"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "0.6"]
+							]
+						],
+						"hitY"
+					]
+				]
+			],
+			[
+				13,
+				"cx",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							7,
+							"pos",
+							"x"
+						],
+						[5, "0"],
+						[
+							7,
+							"prm",
+							"domainX"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"cy",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							7,
+							"pos",
+							"y"
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"agents"
+					],
+					"i"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						"cx",
+						"cy",
+						"nvx",
+						"nvy"
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"simLayout",
+			"d",
+			"noise",
+			"MAX_AGENTS",
+			"std",
+			"safeSteer",
+			"AGIT_REST",
+			"AGIT_GAIN",
+			"AGIT_COOL"
+		]
+	},
+	externals: () => ({
+		simLayout,
+		d,
+		noise: noise_exports,
+		MAX_AGENTS,
+		std,
+		safeSteer,
+		AGIT_REST,
+		AGIT_GAIN,
+		AGIT_COOL
+	})
+}) && $.f)({})).$name("boidsUpdate");
+const componentDefinition = {
+	name: "Boids",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Interactive",
+	description: "A living murmuration of hundreds of flocking agents drawn as crisp arrows, streaks, dots or glowing comets — separation, alignment and cohesion drive fluid, splitting-and-merging ribbons, agents flash toward an excited color when scattered, and the cursor acts as an attractor or a predator",
+	requiresRTT: false,
+	requiresChild: false,
+	usesPointer: true,
+	props: {
+		colorA: {
+			default: "#8ec5ff",
+			transform: transformColor,
+			description: "Color of agents cruising calmly with the flock",
+			ui: {
+				type: "color",
+				label: "Rest Color",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#ff7ad9",
+			transform: transformColor,
+			description: "Color agents flash toward when agitated — scattering from the predator cursor or banking through a hard turn",
+			ui: {
+				type: "color",
+				label: "Excited Color",
+				group: "Colors"
+			}
+		},
+		colorSpace: {
+			default: "oklab",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for the rest→excited color ramp",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		},
+		agentShape: {
+			default: "arrow",
+			compileTime: true,
+			description: "What each agent is drawn as — a hard-edged arrow, streak or square pointing along its heading, a plain dot, or a soft glowing comet",
+			ui: {
+				type: "select",
+				options: orientedShapeOptions,
+				label: "Shape",
+				group: "Flock"
+			}
+		},
+		count: {
+			default: 2e3,
+			description: "Number of flocking agents",
+			ui: {
+				type: "range",
+				min: 100,
+				max: 4e3,
+				step: 100,
+				label: "Count",
+				group: "Flock"
+			}
+		},
+		speed: {
+			default: 2,
+			description: "Overall cruising speed of the flock",
+			ui: {
+				type: "range",
+				min: .2,
+				max: 5,
+				step: .1,
+				label: "Speed",
+				group: "Flock"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Re-rolls the flock's starting formation — each value spawns the murmuration in a different arrangement",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Flock"
+			}
+		},
+		size: {
+			default: 1.5,
+			description: "Size of each agent",
+			ui: {
+				type: "range",
+				min: .5,
+				max: 3,
+				step: .05,
+				label: "Size",
+				group: "Flock"
+			}
+		},
+		trails: {
+			default: 0,
+			description: "How long each agent's motion trail persists — 0 draws crisp agents, 1 leaves long ribbons",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Trails",
+				group: "Flock"
+			}
+		},
+		separation: {
+			default: 1.7,
+			description: "How strongly agents steer away from crowding their neighbours",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Separation",
+				group: "Flocking"
+			}
+		},
+		alignment: {
+			default: 1.5,
+			description: "How strongly agents match their neighbours' heading — the driver of coherent murmuration ribbons",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Alignment",
+				group: "Flocking"
+			}
+		},
+		cohesion: {
+			default: 1,
+			description: "How strongly agents steer toward the local center of the flock",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Cohesion",
+				group: "Flocking"
+			}
+		},
+		perception: {
+			default: .12,
+			description: "How far each agent can sense its neighbours (in screen heights) — larger sees bigger, smoother flocks",
+			ui: {
+				type: "range",
+				min: .05,
+				max: .35,
+				step: .01,
+				label: "Perception",
+				group: "Flocking"
+			}
+		},
+		cursorMode: {
+			default: "repel",
+			description: "How the flock reacts to the cursor",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "None",
+						value: "none"
+					},
+					{
+						label: "Attract",
+						value: "attract"
+					},
+					{
+						label: "Predator",
+						value: "repel"
+					}
+				],
+				label: "Cursor",
+				group: "Interaction"
+			}
+		},
+		cursorStrength: {
+			default: 1.5,
+			description: "Strength of the cursor's pull or push on the flock",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 3,
+				step: .01,
+				label: "Cursor Strength",
+				group: "Interaction"
+			}
+		}
+	},
+	compute: (params) => {
+		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 outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
+			size: [RES, RES],
+			format: STATE_FORMAT
+		}).$usage("storage", "sampled"), "outTex");
+		onCleanup(() => outTex.destroy());
+		const boidsTexture = registerComputeTexture(outTex);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(SimParams), "paramsU");
+		const simBg = root.createBindGroup(simLayout, {
+			agents,
+			agit: agitBuf,
+			accumE,
+			accumS,
+			trailBuf,
+			params: paramsU.buffer,
+			outTex
+		});
+		const splatKernel = makeBoidsSplatKernel(getCpuValue("agentShape") || "arrow");
+		const resolveKernel = makeBoidsResolveKernel(getCpuValue("colorSpace") ?? 2);
+		const init = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+			"use gpu";
+			boidsInitKernel(i);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "i"
+				}],
+				"body": [0, [[
+					6,
+					"boidsInitKernel",
+					["i"]
+				]]],
+				"externalNames": ["boidsInitKernel"]
+			},
+			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);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "i"
+				}],
+				"body": [0, [[
+					6,
+					"boidsUpdateKernel",
+					["i"]
+				]]],
+				"externalNames": ["boidsUpdateKernel"]
+			},
+			externals: () => ({ boidsUpdateKernel })
+		}) && $.f)({})).with(simBg);
+		const splat = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+			"use gpu";
+			splatKernel(i);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "i"
+				}],
+				"body": [0, [[
+					6,
+					"splatKernel",
+					["i"]
+				]]],
+				"externalNames": ["splatKernel"]
+			},
+			externals: () => ({ splatKernel })
+		}) && $.f)({})).with(simBg);
+		const resolve = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+			"use gpu";
+			resolveKernel(x, y);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "x"
+				}, {
+					"type": "i",
+					"name": "y"
+				}],
+				"body": [0, [[
+					6,
+					"resolveKernel",
+					["x", "y"]
+				]]],
+				"externalNames": ["resolveKernel"]
+			},
+			externals: () => ({ resolveKernel })
+		}) && $.f)({}), { size: [RES, RES] }).with(simBg);
+		let initialized = false;
+		let lastSeed = 0;
+		return {
+			outputs: { boidsTexture },
+			getComputeNodes: (frameParams) => {
+				const fp = frameParams;
+				const dt = Math.min(Math.max(fp.deltaTime ?? .016, .001), .033);
+				const h = fp.dimensions?.height ?? 0;
+				const aspect = h > 0 ? (fp.dimensions?.width ?? 0) / h : 16 / 9;
+				const domainX = Math.max(aspect, .01);
+				const g = (key, fallback) => {
+					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 seed = g("seed", 0);
+				const maxSpeed = BASE_SPEED * g("speed", 2);
+				const maxForce = maxSpeed * FORCE_RATIO;
+				const perception = g("perception", .12);
+				const cursorModeStr = getCpuValue("cursorMode") ?? "repel";
+				const cursorMode = cursorModeStr === "attract" ? 1 : cursorModeStr === "repel" ? 2 : 0;
+				const cursorX = (fp.pointer?.x ?? .5) * aspect;
+				const cursorY = fp.pointer?.y ?? .5;
+				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;
+				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),
+					count,
+					trails: Math.min(Math.max(g("trails", .35), 0), 1) * .92,
+					dt,
+					aspect,
+					domainX,
+					maxSpeed,
+					maxForce,
+					perceptionSq: perception * perception,
+					sepRadiusSq: perception * .5 * (perception * .5),
+					sepW: g("separation", 1.7),
+					aliW: g("alignment", 1.5),
+					cohW: g("cohesion", 1),
+					cursorX,
+					cursorY,
+					cursorMode,
+					cursorRadius,
+					cursorRadiusSq: cursorRadius * cursorRadius,
+					cursorForce: g("cursorStrength", 1.5) * maxSpeed * 12,
+					bodyR,
+					margin: .07,
+					turnForce: maxSpeed * 2.2,
+					seed
+				});
+				const nodes = [];
+				if (!initialized || seed !== lastSeed) {
+					initialized = true;
+					lastSeed = seed;
+					nodes.push(() => init.dispatchThreads(MAX_AGENTS));
+				}
+				nodes.push(clearAccum, () => update.dispatchThreads(count), () => splat.dispatchThreads(count), resolve);
+				return nodes;
+			}
+		};
+	},
+	fragment: ({ ctx, computeOutputs }) => {
+		const boidsField = computeOutputs?.boidsTexture;
+		if (!boidsField) return ZERO;
+		return boidsField.sample(ctx.uv, "linearClamp");
+	}
+};
+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 };