shaders 3.1.462 → 3.2.464

package/dist/core/MagneticFilings-rWy0FGXl.js

@@ -1,2711 +0,0 @@
-import { Dt as sin, Gt as textureStorage2d, H as mixColorsLinear, Kt as arrayOf, Lt as vec4f, Mt as vec2f, Pt as vec2u, U as mixColorsVariants, Vt as atomic, _t as max, ct as clamp, d as ZERO, dt as dot, et as typegpu_default, ft as exp, gt as length, it as abs, ln as u32, lt as cos, mt as floor, ot as atan2, qt as struct, rt as select, sn as f32 } from "./edges-CV-BHMpI.js";
-import { c as resolveAgentShape, d as atomicStore, i as makeAgentTexelWeightFn, l as atomicAdd, o as orientedShapeOptions, t as AGENT_SHAPES, u as atomicLoad } from "./agents-CxygFSH4.js";
-import { R as textureStore } from "./device-DKcu50_C.js";
-import { i as PI$1, r as HALF_PI$1 } from "./constants-BKlzQFdJ.js";
-import { _ as readAgentFrame, b as worldSplatWindow, f as SIZE_REF_RES, g as makeCpuValueGetter, m as energyCoverageAlpha, p as createAgentSystem, u as FIXED_POINT_GAINS, v as resolveRenderRes } from "./porters-j7yWJYy2.js";
-import { l as hash22, o as hash11 } from "./noise-eXd1Bfrw.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-u-UZrXjj.js";
-var MAX_FILINGS = 12288;
-var RES = resolveRenderRes({
-	desktop: 1024,
-	mobile: 768
-});
-var INV_RES = 1 / RES;
-var STATE_FORMAT = "rgba16float";
-var SPLAT_R = 14;
-var AA_W = .75 * INV_RES;
-var PI = PI$1;
-var HALF_PI = HALF_PI$1;
-var ALIGN_BASE = 45;
-var REST_K = 6;
-var DAMP_MIN = 3;
-var DAMP_SPAN = 9;
-var OMEGA_REF = 6;
-var AGIT_COOL = 1;
-var HOME_K = 2.5;
-var PULL_K = .25;
-var MAX_OFFSET = .12;
-var OVERSCAN = .14;
-var HARD_GAIN = FIXED_POINT_GAINS.HARD;
-var SOFT_GAIN = FIXED_POINT_GAINS.SOFT;
-var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
-	colA: vec4f,
-	colB: vec4f,
-	count: f32,
-	dt: f32,
-	aspect: f32,
-	domainX: f32,
-	cursorX: f32,
-	cursorY: f32,
-	axisX: f32,
-	axisY: f32,
-	fieldType: f32,
-	restMode: f32,
-	strength: f32,
-	reachSq: f32,
-	alignK: f32,
-	damping: f32,
-	restK: f32,
-	pullK: f32,
-	homeK: f32,
-	omegaRef: f32,
-	agitCool: f32,
-	gridCols: f32,
-	cellW: f32,
-	cellH: f32,
-	jitter: f32,
-	bodyR: f32
-}), "SimParams");
-var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(typegpu_default.bindGroupLayout({
-	filings: {
-		storage: arrayOf(vec4f, MAX_FILINGS),
-		access: "mutable"
-	},
-	agit: {
-		storage: arrayOf(f32, MAX_FILINGS),
-		access: "mutable"
-	},
-	accumE: {
-		storage: arrayOf(atomic(u32), RES * RES),
-		access: "mutable"
-	},
-	accumS: {
-		storage: arrayOf(atomic(u32), RES * RES),
-		access: "mutable"
-	},
-	params: { uniform: SimParams },
-	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
-}), "simLayout");
-var homeFn = typegpu_default.fn([
-	f32,
-	f32,
-	f32,
-	f32,
-	f32
-], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi, cols, cellW, cellH, jitter) => {
-	"use gpu";
-	const row = floor(__tsover_div(fi, max(cols, 1)));
-	const col = __tsover_sub(fi, __tsover_mul(row, max(cols, 1)));
-	const h = hash22(vec2f(__tsover_add(__tsover_mul(fi, .7548), .11), __tsover_add(__tsover_mul(fi, 1.3236), 5.31)));
-	const jx = __tsover_mul(__tsover_sub(h.x, .5), jitter);
-	const jy = __tsover_mul(__tsover_sub(h.y, .5), jitter);
-	return vec2f(__tsover_sub(__tsover_mul(__tsover_add(__tsover_add(col, .5), jx), cellW), OVERSCAN), __tsover_sub(__tsover_mul(__tsover_add(__tsover_add(row, .5), jy), cellH), OVERSCAN));
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "fi"
-			},
-			{
-				"type": "i",
-				"name": "cols"
-			},
-			{
-				"type": "i",
-				"name": "cellW"
-			},
-			{
-				"type": "i",
-				"name": "cellH"
-			},
-			{
-				"type": "i",
-				"name": "jitter"
-			}
-		],
-		"body": [0, [
-			[
-				13,
-				"row",
-				[
-					6,
-					"std.floor",
-					[[
-						1,
-						"fi",
-						"/",
-						[
-							6,
-							"std.max",
-							["cols", [5, "1"]]
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"col",
-				[
-					1,
-					"fi",
-					"-",
-					[
-						1,
-						"row",
-						"*",
-						[
-							6,
-							"std.max",
-							["cols", [5, "1"]]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"h",
-				[
-					6,
-					"noise.hash22",
-					[[
-						6,
-						"d.vec2f",
-						[[
-							1,
-							[
-								1,
-								"fi",
-								"*",
-								[5, "0.7548"]
-							],
-							"+",
-							[5, "0.11"]
-						], [
-							1,
-							[
-								1,
-								"fi",
-								"*",
-								[5, "1.3236"]
-							],
-							"+",
-							[5, "5.31"]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"jx",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"h",
-							"x"
-						],
-						"-",
-						[5, "0.5"]
-					],
-					"*",
-					"jitter"
-				]
-			],
-			[
-				13,
-				"jy",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"h",
-							"y"
-						],
-						"-",
-						[5, "0.5"]
-					],
-					"*",
-					"jitter"
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								"col",
-								"+",
-								[5, "0.5"]
-							],
-							"+",
-							"jx"
-						],
-						"*",
-						"cellW"
-					],
-					"-",
-					"OVERSCAN"
-				], [
-					1,
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								"row",
-								"+",
-								[5, "0.5"]
-							],
-							"+",
-							"jy"
-						],
-						"*",
-						"cellH"
-					],
-					"-",
-					"OVERSCAN"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.floor": () => floor,
-		"std.max": () => max,
-		"noise.hash22": () => hash22,
-		"d.vec2f": () => vec2f,
-		"OVERSCAN": () => OVERSCAN
-	}
-}) && $.f)({})).$name("filingsHome");
-var restAngleFn = typegpu_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi, restMode) => {
-	"use gpu";
-	return select(select(__tsover_mul(hash11(__tsover_add(__tsover_mul(fi, 2.3987), .517)), PI), f32(0), restMode > .5), HALF_PI, restMode > 1.5);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "fi"
-		}, {
-			"type": "i",
-			"name": "restMode"
-		}],
-		"body": [0, [
-			[
-				13,
-				"randAng",
-				[
-					1,
-					[
-						6,
-						"noise.hash11",
-						[[
-							1,
-							[
-								1,
-								"fi",
-								"*",
-								[5, "2.3987"]
-							],
-							"+",
-							[5, "0.517"]
-						]]
-					],
-					"*",
-					"PI"
-				]
-			],
-			[
-				13,
-				"a",
-				[
-					6,
-					"std.select",
-					[
-						"randAng",
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							1,
-							"restMode",
-							">",
-							[5, "0.5"]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"std.select",
-				[
-					"a",
-					"HALF_PI",
-					[
-						1,
-						"restMode",
-						">",
-						[5, "1.5"]
-					]
-				]
-			]]
-		]]
-	},
-	externals: {
-		"noise.hash11": () => hash11,
-		"PI": () => PI,
-		"std.select": () => select,
-		"d.f32": () => f32,
-		"HALF_PI": () => HALF_PI
-	}
-}) && $.f)({})).$name("filingsRestAngle");
-const filingsInitKernel = typegpu_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-	"use gpu";
-	const fi = f32(i);
-	const theta0 = __tsover_mul(hash11(__tsover_add(__tsover_mul(fi, 1.618034), .31)), PI);
-	simLayout.$.filings[i] = vec4f(f32(0), f32(0), theta0, f32(0));
-	simLayout.$.agit[i] = f32(0);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "i"
-		}],
-		"body": [0, [
-			[
-				13,
-				"fi",
-				[
-					6,
-					"d.f32",
-					["i"]
-				]
-			],
-			[
-				13,
-				"theta0",
-				[
-					1,
-					[
-						6,
-						"noise.hash11",
-						[[
-							1,
-							[
-								1,
-								"fi",
-								"*",
-								[5, "1.618034"]
-							],
-							"+",
-							[5, "0.31"]
-						]]
-					],
-					"*",
-					"PI"
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"filings"
-					],
-					"i"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						],
-						"theta0",
-						[
-							6,
-							"d.f32",
-							[[5, "0"]]
-						]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"agit"
-					],
-					"i"
-				],
-				"=",
-				[
-					6,
-					"d.f32",
-					[[5, "0"]]
-				]
-			]
-		]]
-	},
-	externals: {
-		"d.f32": () => f32,
-		"noise.hash11": () => hash11,
-		"PI": () => PI,
-		"simLayout": () => simLayout,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("filingsInit");
-function makeFilingsSplatKernel(shape) {
-	const name = resolveAgentShape(shape, "streak");
-	const s = AGENT_SHAPES[name];
-	const weightFn = makeAgentTexelWeightFn(name);
-	const EXT = s.ext;
-	const GAIN = s.soft ? SOFT_GAIN : HARD_GAIN;
-	const tnFn = !(s.kind === 0 && s.hl === 0) ? typegpu_default.fn([
-		f32,
-		f32,
-		vec2f
-	], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ox, oy, dir) => {
-		"use gpu";
-		return vec2f(__tsover_add(__tsover_mul(ox, dir.x), __tsover_mul(oy, dir.y)), __tsover_add(__tsover_mul(ox, -dir.y), __tsover_mul(oy, dir.x)));
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [
-				{
-					"type": "i",
-					"name": "ox"
-				},
-				{
-					"type": "i",
-					"name": "oy"
-				},
-				{
-					"type": "i",
-					"name": "dir"
-				}
-			],
-			"body": [0, [[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					[
-						1,
-						"ox",
-						"*",
-						[
-							7,
-							"dir",
-							"x"
-						]
-					],
-					"+",
-					[
-						1,
-						"oy",
-						"*",
-						[
-							7,
-							"dir",
-							"y"
-						]
-					]
-				], [
-					1,
-					[
-						1,
-						"ox",
-						"*",
-						[
-							4,
-							"-",
-							[
-								7,
-								"dir",
-								"y"
-							]
-						]
-					],
-					"+",
-					[
-						1,
-						"oy",
-						"*",
-						[
-							7,
-							"dir",
-							"x"
-						]
-					]
-				]]
-			]]]]
-		},
-		externals: { "d.vec2f": () => vec2f }
-	}) && $.f)({})).$name("filingsHeadingSpace") : typegpu_default.fn([
-		f32,
-		f32,
-		vec2f
-	], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ox, oy, _dir) => {
-		"use gpu";
-		return vec2f(ox, oy);
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [
-				{
-					"type": "i",
-					"name": "ox"
-				},
-				{
-					"type": "i",
-					"name": "oy"
-				},
-				{
-					"type": "i",
-					"name": "_dir"
-				}
-			],
-			"body": [0, [[10, [
-				6,
-				"d.vec2f",
-				["ox", "oy"]
-			]]]]
-		},
-		externals: { "d.vec2f": () => vec2f }
-	}) && $.f)({})).$name("filingsHeadingSpace");
-	return typegpu_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-		"use gpu";
-		const prm = simLayout.$.params;
-		const st = simLayout.$.filings[i];
-		const home = homeFn(f32(i), prm.gridCols, prm.cellW, prm.cellH, prm.jitter);
-		const pos = vec2f(__tsover_add(home.x, st.x), __tsover_add(home.y, st.y));
-		const theta = st.z;
-		const dir = vec2f(cos(theta), sin(theta));
-		const agitI = clamp(simLayout.$.agit[i], 0, 1);
-		const bodyR = clamp(prm.bodyR, 1e-6, __tsover_mul(f32(SPLAT_R), INV_RES));
-		const bodyRSq = __tsover_mul(bodyR, bodyR);
-		const rWorld = __tsover_add(__tsover_mul(bodyR, EXT), __tsover_mul(AA_W, 2));
-		const extSq = __tsover_mul(rWorld, rWorld);
-		const aspect = max(prm.aspect, 1e-5);
-		const win = worldSplatWindow(pos, rWorld, aspect, f32(RES));
-		if (win.x1 >= win.x0 && win.y1 >= win.y0) for (let py = win.y0; py <= win.y1; py++) {
-			const offY = __tsover_sub(__tsover_mul(__tsover_add(f32(py), .5), INV_RES), pos.y);
-			for (let px = win.x0; px <= win.x1; px++) {
-				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(f32(px), .5), INV_RES), aspect), pos.x);
-				const dSq = __tsover_add(__tsover_mul(offX, offX), __tsover_mul(offY, offY));
-				if (dSq < extSq) {
-					const tn = tnFn(offX, offY, dir);
-					const w = weightFn(__tsover_div(dSq, bodyRSq), tn.x, tn.y, bodyR, AA_W);
-					const e = u32(__tsover_mul(w, f32(GAIN)));
-					if (e > u32(0)) {
-						const idx = u32(__tsover_add(__tsover_mul(py, RES), px));
-						atomicAdd(simLayout.$.accumE[idx], e);
-						if (agitI > 0) atomicAdd(simLayout.$.accumS[idx], u32(__tsover_mul(__tsover_mul(w, agitI), f32(GAIN))));
-					}
-				}
-			}
-		}
-	}), {
-		v: 2,
-		name: void 0,
-		ast: {
-			"params": [{
-				"type": "i",
-				"name": "i"
-			}],
-			"body": [0, [
-				[
-					13,
-					"prm",
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"params"
-					]
-				],
-				[
-					13,
-					"st",
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"simLayout",
-								"$"
-							],
-							"filings"
-						],
-						"i"
-					]
-				],
-				[
-					13,
-					"home",
-					[
-						6,
-						"homeFn",
-						[
-							[
-								6,
-								"d.f32",
-								["i"]
-							],
-							[
-								7,
-								"prm",
-								"gridCols"
-							],
-							[
-								7,
-								"prm",
-								"cellW"
-							],
-							[
-								7,
-								"prm",
-								"cellH"
-							],
-							[
-								7,
-								"prm",
-								"jitter"
-							]
-						]
-					]
-				],
-				[
-					13,
-					"pos",
-					[
-						6,
-						"d.vec2f",
-						[[
-							1,
-							[
-								7,
-								"home",
-								"x"
-							],
-							"+",
-							[
-								7,
-								"st",
-								"x"
-							]
-						], [
-							1,
-							[
-								7,
-								"home",
-								"y"
-							],
-							"+",
-							[
-								7,
-								"st",
-								"y"
-							]
-						]]
-					]
-				],
-				[
-					13,
-					"theta",
-					[
-						7,
-						"st",
-						"z"
-					]
-				],
-				[
-					13,
-					"dir",
-					[
-						6,
-						"d.vec2f",
-						[[
-							6,
-							"std.cos",
-							["theta"]
-						], [
-							6,
-							"std.sin",
-							["theta"]
-						]]
-					]
-				],
-				[
-					13,
-					"agitI",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								8,
-								[
-									7,
-									[
-										7,
-										"simLayout",
-										"$"
-									],
-									"agit"
-								],
-								"i"
-							],
-							[5, "0"],
-							[5, "1"]
-						]
-					]
-				],
-				[
-					13,
-					"bodyR",
-					[
-						6,
-						"std.clamp",
-						[
-							[
-								7,
-								"prm",
-								"bodyR"
-							],
-							[5, "0.000001"],
-							[
-								1,
-								[
-									6,
-									"d.f32",
-									["SPLAT_R"]
-								],
-								"*",
-								"INV_RES"
-							]
-						]
-					]
-				],
-				[
-					13,
-					"bodyRSq",
-					[
-						1,
-						"bodyR",
-						"*",
-						"bodyR"
-					]
-				],
-				[
-					13,
-					"rWorld",
-					[
-						1,
-						[
-							1,
-							"bodyR",
-							"*",
-							"EXT"
-						],
-						"+",
-						[
-							1,
-							"AA_W",
-							"*",
-							[5, "2"]
-						]
-					]
-				],
-				[
-					13,
-					"extSq",
-					[
-						1,
-						"rWorld",
-						"*",
-						"rWorld"
-					]
-				],
-				[
-					13,
-					"aspect",
-					[
-						6,
-						"std.max",
-						[[
-							7,
-							"prm",
-							"aspect"
-						], [5, "0.00001"]]
-					]
-				],
-				[
-					13,
-					"win",
-					[
-						6,
-						"worldSplatWindow",
-						[
-							"pos",
-							"rWorld",
-							"aspect",
-							[
-								6,
-								"d.f32",
-								["RES"]
-							]
-						]
-					]
-				],
-				[
-					11,
-					[
-						3,
-						[
-							1,
-							[
-								7,
-								"win",
-								"x1"
-							],
-							">=",
-							[
-								7,
-								"win",
-								"x0"
-							]
-						],
-						"&&",
-						[
-							1,
-							[
-								7,
-								"win",
-								"y1"
-							],
-							">=",
-							[
-								7,
-								"win",
-								"y0"
-							]
-						]
-					],
-					[0, [[
-						14,
-						[
-							12,
-							"py",
-							[
-								7,
-								"win",
-								"y0"
-							]
-						],
-						[
-							1,
-							"py",
-							"<=",
-							[
-								7,
-								"win",
-								"y1"
-							]
-						],
-						[
-							102,
-							"++",
-							"py"
-						],
-						[0, [[
-							13,
-							"offY",
-							[
-								1,
-								[
-									1,
-									[
-										1,
-										[
-											6,
-											"d.f32",
-											["py"]
-										],
-										"+",
-										[5, "0.5"]
-									],
-									"*",
-									"INV_RES"
-								],
-								"-",
-								[
-									7,
-									"pos",
-									"y"
-								]
-							]
-						], [
-							14,
-							[
-								12,
-								"px",
-								[
-									7,
-									"win",
-									"x0"
-								]
-							],
-							[
-								1,
-								"px",
-								"<=",
-								[
-									7,
-									"win",
-									"x1"
-								]
-							],
-							[
-								102,
-								"++",
-								"px"
-							],
-							[0, [
-								[
-									13,
-									"offX",
-									[
-										1,
-										[
-											1,
-											[
-												1,
-												[
-													1,
-													[
-														6,
-														"d.f32",
-														["px"]
-													],
-													"+",
-													[5, "0.5"]
-												],
-												"*",
-												"INV_RES"
-											],
-											"*",
-											"aspect"
-										],
-										"-",
-										[
-											7,
-											"pos",
-											"x"
-										]
-									]
-								],
-								[
-									13,
-									"dSq",
-									[
-										1,
-										[
-											1,
-											"offX",
-											"*",
-											"offX"
-										],
-										"+",
-										[
-											1,
-											"offY",
-											"*",
-											"offY"
-										]
-									]
-								],
-								[
-									11,
-									[
-										1,
-										"dSq",
-										"<",
-										"extSq"
-									],
-									[0, [
-										[
-											13,
-											"tn",
-											[
-												6,
-												"tnFn",
-												[
-													"offX",
-													"offY",
-													"dir"
-												]
-											]
-										],
-										[
-											13,
-											"w",
-											[
-												6,
-												"weightFn",
-												[
-													[
-														1,
-														"dSq",
-														"/",
-														"bodyRSq"
-													],
-													[
-														7,
-														"tn",
-														"x"
-													],
-													[
-														7,
-														"tn",
-														"y"
-													],
-													"bodyR",
-													"AA_W"
-												]
-											]
-										],
-										[
-											13,
-											"e",
-											[
-												6,
-												"d.u32",
-												[[
-													1,
-													"w",
-													"*",
-													[
-														6,
-														"d.f32",
-														["GAIN"]
-													]
-												]]
-											]
-										],
-										[
-											11,
-											[
-												1,
-												"e",
-												">",
-												[
-													6,
-													"d.u32",
-													[[5, "0"]]
-												]
-											],
-											[0, [
-												[
-													13,
-													"idx",
-													[
-														6,
-														"d.u32",
-														[[
-															1,
-															[
-																1,
-																"py",
-																"*",
-																"RES"
-															],
-															"+",
-															"px"
-														]]
-													]
-												],
-												[
-													6,
-													"std.atomicAdd",
-													[[
-														8,
-														[
-															7,
-															[
-																7,
-																"simLayout",
-																"$"
-															],
-															"accumE"
-														],
-														"idx"
-													], "e"]
-												],
-												[
-													11,
-													[
-														1,
-														"agitI",
-														">",
-														[5, "0"]
-													],
-													[0, [[
-														6,
-														"std.atomicAdd",
-														[[
-															8,
-															[
-																7,
-																[
-																	7,
-																	"simLayout",
-																	"$"
-																],
-																"accumS"
-															],
-															"idx"
-														], [
-															6,
-															"d.u32",
-															[[
-																1,
-																[
-																	1,
-																	"w",
-																	"*",
-																	"agitI"
-																],
-																"*",
-																[
-																	6,
-																	"d.f32",
-																	["GAIN"]
-																]
-															]]
-														]]
-													]]]
-												]
-											]]
-										]
-									]]
-								]
-							]]
-						]]]
-					]]]
-				]
-			]]
-		},
-		externals: {
-			"simLayout": () => simLayout,
-			"homeFn": () => homeFn,
-			"d.f32": () => f32,
-			"d.vec2f": () => vec2f,
-			"std.cos": () => cos,
-			"std.sin": () => sin,
-			"std.clamp": () => clamp,
-			"SPLAT_R": () => SPLAT_R,
-			"INV_RES": () => INV_RES,
-			"EXT": () => EXT,
-			"AA_W": () => AA_W,
-			"std.max": () => max,
-			"worldSplatWindow": () => worldSplatWindow,
-			"RES": () => RES,
-			"tnFn": () => tnFn,
-			"weightFn": () => weightFn,
-			"d.u32": () => u32,
-			"GAIN": () => GAIN,
-			"std.atomicAdd": () => atomicAdd
-		}
-	}) && $.f)({})).$name("filingsSplat");
-}
-const filingsSplatKernel = makeFilingsSplatKernel("streak");
-function makeFilingsResolveKernel(colorSpaceMode) {
-	const mixFn = mixColorsVariants[colorSpaceMode] ?? mixColorsLinear;
-	return typegpu_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, u32(RES)), x);
-		const eRaw = f32(atomicLoad(simLayout.$.accumE[idx]));
-		const sRaw = f32(atomicLoad(simLayout.$.accumS[idx]));
-		atomicStore(simLayout.$.accumE[idx], u32(0));
-		atomicStore(simLayout.$.accumS[idx], u32(0));
-		if (eRaw > 0) {
-			const energy = __tsover_mul(eRaw, __tsover_div(1, 255));
-			const agitAvg = __tsover_div(sRaw, max(eRaw, 1));
-			const col = mixFn(prm.colA, prm.colB, clamp(agitAvg, 0, 1));
-			const a = __tsover_mul(energyCoverageAlpha(energy, 1.6), col.w);
-			textureStore(simLayout.$.outTex, vec2u(x, y), vec4f(col.x, col.y, col.z, a));
-		} else textureStore(simLayout.$.outTex, vec2u(x, y), vec4f(prm.colA.x, prm.colA.y, prm.colA.z, f32(0)));
-	}), {
-		v: 2,
-		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,
-								"d.u32",
-								["RES"]
-							]
-						],
-						"+",
-						"x"
-					]
-				],
-				[
-					13,
-					"eRaw",
-					[
-						6,
-						"d.f32",
-						[[
-							6,
-							"std.atomicLoad",
-							[[
-								8,
-								[
-									7,
-									[
-										7,
-										"simLayout",
-										"$"
-									],
-									"accumE"
-								],
-								"idx"
-							]]
-						]]
-					]
-				],
-				[
-					13,
-					"sRaw",
-					[
-						6,
-						"d.f32",
-						[[
-							6,
-							"std.atomicLoad",
-							[[
-								8,
-								[
-									7,
-									[
-										7,
-										"simLayout",
-										"$"
-									],
-									"accumS"
-								],
-								"idx"
-							]]
-						]]
-					]
-				],
-				[
-					6,
-					"std.atomicStore",
-					[[
-						8,
-						[
-							7,
-							[
-								7,
-								"simLayout",
-								"$"
-							],
-							"accumE"
-						],
-						"idx"
-					], [
-						6,
-						"d.u32",
-						[[5, "0"]]
-					]]
-				],
-				[
-					6,
-					"std.atomicStore",
-					[[
-						8,
-						[
-							7,
-							[
-								7,
-								"simLayout",
-								"$"
-							],
-							"accumS"
-						],
-						"idx"
-					], [
-						6,
-						"d.u32",
-						[[5, "0"]]
-					]]
-				],
-				[
-					11,
-					[
-						1,
-						"eRaw",
-						">",
-						[5, "0"]
-					],
-					[0, [
-						[
-							13,
-							"energy",
-							[
-								1,
-								"eRaw",
-								"*",
-								[
-									1,
-									[5, "1"],
-									"/",
-									[5, "255"]
-								]
-							]
-						],
-						[
-							13,
-							"agitAvg",
-							[
-								1,
-								"sRaw",
-								"/",
-								[
-									6,
-									"std.max",
-									["eRaw", [5, "1"]]
-								]
-							]
-						],
-						[
-							13,
-							"col",
-							[
-								6,
-								"mixFn",
-								[
-									[
-										7,
-										"prm",
-										"colA"
-									],
-									[
-										7,
-										"prm",
-										"colB"
-									],
-									[
-										6,
-										"std.clamp",
-										[
-											"agitAvg",
-											[5, "0"],
-											[5, "1"]
-										]
-									]
-								]
-							]
-						],
-						[
-							13,
-							"a",
-							[
-								1,
-								[
-									6,
-									"energyCoverageAlpha",
-									["energy", [5, "1.6"]]
-								],
-								"*",
-								[
-									7,
-									"col",
-									"w"
-								]
-							]
-						],
-						[
-							6,
-							"std.textureStore",
-							[
-								[
-									7,
-									[
-										7,
-										"simLayout",
-										"$"
-									],
-									"outTex"
-								],
-								[
-									6,
-									"d.vec2u",
-									["x", "y"]
-								],
-								[
-									6,
-									"d.vec4f",
-									[
-										[
-											7,
-											"col",
-											"x"
-										],
-										[
-											7,
-											"col",
-											"y"
-										],
-										[
-											7,
-											"col",
-											"z"
-										],
-										"a"
-									]
-								]
-							]
-						]
-					]],
-					[0, [[
-						6,
-						"std.textureStore",
-						[
-							[
-								7,
-								[
-									7,
-									"simLayout",
-									"$"
-								],
-								"outTex"
-							],
-							[
-								6,
-								"d.vec2u",
-								["x", "y"]
-							],
-							[
-								6,
-								"d.vec4f",
-								[
-									[
-										7,
-										[
-											7,
-											"prm",
-											"colA"
-										],
-										"x"
-									],
-									[
-										7,
-										[
-											7,
-											"prm",
-											"colA"
-										],
-										"y"
-									],
-									[
-										7,
-										[
-											7,
-											"prm",
-											"colA"
-										],
-										"z"
-									],
-									[
-										6,
-										"d.f32",
-										[[5, "0"]]
-									]
-								]
-							]
-						]
-					]]]
-				]
-			]]
-		},
-		externals: {
-			"simLayout": () => simLayout,
-			"d.u32": () => u32,
-			"RES": () => RES,
-			"d.f32": () => f32,
-			"std.atomicLoad": () => atomicLoad,
-			"std.atomicStore": () => atomicStore,
-			"std.max": () => max,
-			"mixFn": () => mixFn,
-			"std.clamp": () => clamp,
-			"energyCoverageAlpha": () => energyCoverageAlpha,
-			"std.textureStore": () => textureStore,
-			"d.vec2u": () => vec2u,
-			"d.vec4f": () => vec4f
-		}
-	}) && $.f)({})).$name("filingsResolve");
-}
-const filingsResolveKernel = makeFilingsResolveKernel(2);
-const filingsUpdateKernel = typegpu_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
-	"use gpu";
-	const prm = simLayout.$.params;
-	const st = simLayout.$.filings[i];
-	let off = vec2f(st.x, st.y);
-	let theta = st.z;
-	let omega = st.w;
-	const dt = prm.dt;
-	const fi = f32(i);
-	const home = homeFn(fi, prm.gridCols, prm.cellW, prm.cellH, prm.jitter);
-	const pos = vec2f(__tsover_add(home.x, off.x), __tsover_add(home.y, off.y));
-	const cursor = vec2f(prm.cursorX, prm.cursorY);
-	const delta = pos.sub(cursor);
-	const r = max(length(delta), 1e-4);
-	const rhat = delta.div(r);
-	const axis = vec2f(prm.axisX, prm.axisY);
-	const mdotr = dot(axis, rhat);
-	const B = select(rhat.mul(__tsover_mul(2, mdotr)).sub(axis), rhat, prm.fieldType > .5);
-	const fieldStr = __tsover_mul(prm.strength, exp(__tsover_mul(__tsover_div(__tsover_mul(r, r), max(prm.reachSq, 1e-6)), -1)));
-	const phiField = atan2(B.y, B.x);
-	const restAngle = restAngleFn(fi, prm.restMode);
-	const torqueField = __tsover_mul(__tsover_mul(prm.alignK, fieldStr), sin(__tsover_mul(2, __tsover_sub(phiField, theta))));
-	const torqueRest = __tsover_mul(prm.restK, sin(__tsover_mul(2, __tsover_sub(restAngle, theta))));
-	omega = __tsover_add(omega, __tsover_mul(__tsover_add(torqueField, torqueRest), dt));
-	omega = __tsover_mul(omega, exp(__tsover_mul(__tsover_mul(prm.damping, dt), -1)));
-	theta = __tsover_add(theta, __tsover_mul(omega, dt));
-	const raw = clamp(__tsover_div(abs(omega), max(prm.omegaRef, 1e-5)), 0, 1);
-	const cooled = __tsover_mul(simLayout.$.agit[i], exp(__tsover_mul(dt, -prm.agitCool)));
-	simLayout.$.agit[i] = max(raw, cooled);
-	const pull = rhat.mul(__tsover_mul(__tsover_mul(prm.pullK, fieldStr), -1));
-	off = off.add(pull.mul(dt));
-	off = off.mul(exp(__tsover_mul(__tsover_mul(prm.homeK, dt), -1)));
-	const offLen = length(off);
-	off = select(off, off.div(max(offLen, 1e-5)).mul(MAX_OFFSET), offLen > MAX_OFFSET);
-	simLayout.$.filings[i] = vec4f(off.x, off.y, theta, omega);
-}), {
-	v: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "i"
-		}],
-		"body": [0, [
-			[
-				13,
-				"prm",
-				[
-					7,
-					[
-						7,
-						"simLayout",
-						"$"
-					],
-					"params"
-				]
-			],
-			[
-				13,
-				"st",
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"filings"
-					],
-					"i"
-				]
-			],
-			[
-				12,
-				"off",
-				[
-					6,
-					"d.vec2f",
-					[[
-						7,
-						"st",
-						"x"
-					], [
-						7,
-						"st",
-						"y"
-					]]
-				]
-			],
-			[
-				12,
-				"theta",
-				[
-					7,
-					"st",
-					"z"
-				]
-			],
-			[
-				12,
-				"omega",
-				[
-					7,
-					"st",
-					"w"
-				]
-			],
-			[
-				13,
-				"dt",
-				[
-					7,
-					"prm",
-					"dt"
-				]
-			],
-			[
-				13,
-				"fi",
-				[
-					6,
-					"d.f32",
-					["i"]
-				]
-			],
-			[
-				13,
-				"home",
-				[
-					6,
-					"homeFn",
-					[
-						"fi",
-						[
-							7,
-							"prm",
-							"gridCols"
-						],
-						[
-							7,
-							"prm",
-							"cellW"
-						],
-						[
-							7,
-							"prm",
-							"cellH"
-						],
-						[
-							7,
-							"prm",
-							"jitter"
-						]
-					]
-				]
-			],
-			[
-				13,
-				"pos",
-				[
-					6,
-					"d.vec2f",
-					[[
-						1,
-						[
-							7,
-							"home",
-							"x"
-						],
-						"+",
-						[
-							7,
-							"off",
-							"x"
-						]
-					], [
-						1,
-						[
-							7,
-							"home",
-							"y"
-						],
-						"+",
-						[
-							7,
-							"off",
-							"y"
-						]
-					]]
-				]
-			],
-			[
-				13,
-				"cursor",
-				[
-					6,
-					"d.vec2f",
-					[[
-						7,
-						"prm",
-						"cursorX"
-					], [
-						7,
-						"prm",
-						"cursorY"
-					]]
-				]
-			],
-			[
-				13,
-				"delta",
-				[
-					6,
-					[
-						7,
-						"pos",
-						"sub"
-					],
-					["cursor"]
-				]
-			],
-			[
-				13,
-				"r",
-				[
-					6,
-					"std.max",
-					[[
-						6,
-						"std.length",
-						["delta"]
-					], [5, "0.0001"]]
-				]
-			],
-			[
-				13,
-				"rhat",
-				[
-					6,
-					[
-						7,
-						"delta",
-						"div"
-					],
-					["r"]
-				]
-			],
-			[
-				13,
-				"axis",
-				[
-					6,
-					"d.vec2f",
-					[[
-						7,
-						"prm",
-						"axisX"
-					], [
-						7,
-						"prm",
-						"axisY"
-					]]
-				]
-			],
-			[
-				13,
-				"mdotr",
-				[
-					6,
-					"std.dot",
-					["axis", "rhat"]
-				]
-			],
-			[
-				13,
-				"dipoleB",
-				[
-					6,
-					[
-						7,
-						[
-							6,
-							[
-								7,
-								"rhat",
-								"mul"
-							],
-							[[
-								1,
-								[5, "2"],
-								"*",
-								"mdotr"
-							]]
-						],
-						"sub"
-					],
-					["axis"]
-				]
-			],
-			[
-				13,
-				"B",
-				[
-					6,
-					"std.select",
-					[
-						"dipoleB",
-						"rhat",
-						[
-							1,
-							[
-								7,
-								"prm",
-								"fieldType"
-							],
-							">",
-							[5, "0.5"]
-						]
-					]
-				]
-			],
-			[
-				13,
-				"fieldStr",
-				[
-					1,
-					[
-						7,
-						"prm",
-						"strength"
-					],
-					"*",
-					[
-						6,
-						"std.exp",
-						[[
-							1,
-							[
-								1,
-								[
-									1,
-									"r",
-									"*",
-									"r"
-								],
-								"/",
-								[
-									6,
-									"std.max",
-									[[
-										7,
-										"prm",
-										"reachSq"
-									], [5, "0.000001"]]
-								]
-							],
-							"*",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						]]
-					]
-				]
-			],
-			[
-				13,
-				"phiField",
-				[
-					6,
-					"std.atan2",
-					[[
-						7,
-						"B",
-						"y"
-					], [
-						7,
-						"B",
-						"x"
-					]]
-				]
-			],
-			[
-				13,
-				"restAngle",
-				[
-					6,
-					"restAngleFn",
-					["fi", [
-						7,
-						"prm",
-						"restMode"
-					]]
-				]
-			],
-			[
-				13,
-				"torqueField",
-				[
-					1,
-					[
-						1,
-						[
-							7,
-							"prm",
-							"alignK"
-						],
-						"*",
-						"fieldStr"
-					],
-					"*",
-					[
-						6,
-						"std.sin",
-						[[
-							1,
-							[5, "2"],
-							"*",
-							[
-								1,
-								"phiField",
-								"-",
-								"theta"
-							]
-						]]
-					]
-				]
-			],
-			[
-				13,
-				"torqueRest",
-				[
-					1,
-					[
-						7,
-						"prm",
-						"restK"
-					],
-					"*",
-					[
-						6,
-						"std.sin",
-						[[
-							1,
-							[5, "2"],
-							"*",
-							[
-								1,
-								"restAngle",
-								"-",
-								"theta"
-							]
-						]]
-					]
-				]
-			],
-			[
-				2,
-				"omega",
-				"=",
-				[
-					1,
-					"omega",
-					"+",
-					[
-						1,
-						[
-							1,
-							"torqueField",
-							"+",
-							"torqueRest"
-						],
-						"*",
-						"dt"
-					]
-				]
-			],
-			[
-				2,
-				"omega",
-				"=",
-				[
-					1,
-					"omega",
-					"*",
-					[
-						6,
-						"std.exp",
-						[[
-							1,
-							[
-								1,
-								[
-									7,
-									"prm",
-									"damping"
-								],
-								"*",
-								"dt"
-							],
-							"*",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						]]
-					]
-				]
-			],
-			[
-				2,
-				"theta",
-				"=",
-				[
-					1,
-					"theta",
-					"+",
-					[
-						1,
-						"omega",
-						"*",
-						"dt"
-					]
-				]
-			],
-			[
-				13,
-				"raw",
-				[
-					6,
-					"std.clamp",
-					[
-						[
-							1,
-							[
-								6,
-								"std.abs",
-								["omega"]
-							],
-							"/",
-							[
-								6,
-								"std.max",
-								[[
-									7,
-									"prm",
-									"omegaRef"
-								], [5, "0.00001"]]
-							]
-						],
-						[5, "0"],
-						[5, "1"]
-					]
-				]
-			],
-			[
-				13,
-				"cooled",
-				[
-					1,
-					[
-						8,
-						[
-							7,
-							[
-								7,
-								"simLayout",
-								"$"
-							],
-							"agit"
-						],
-						"i"
-					],
-					"*",
-					[
-						6,
-						"std.exp",
-						[[
-							1,
-							"dt",
-							"*",
-							[
-								4,
-								"-",
-								[
-									7,
-									"prm",
-									"agitCool"
-								]
-							]
-						]]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"agit"
-					],
-					"i"
-				],
-				"=",
-				[
-					6,
-					"std.max",
-					["raw", "cooled"]
-				]
-			],
-			[
-				13,
-				"pull",
-				[
-					6,
-					[
-						7,
-						"rhat",
-						"mul"
-					],
-					[[
-						1,
-						[
-							1,
-							[
-								7,
-								"prm",
-								"pullK"
-							],
-							"*",
-							"fieldStr"
-						],
-						"*",
-						[
-							4,
-							"-",
-							[5, "1"]
-						]
-					]]
-				]
-			],
-			[
-				2,
-				"off",
-				"=",
-				[
-					6,
-					[
-						7,
-						"off",
-						"add"
-					],
-					[[
-						6,
-						[
-							7,
-							"pull",
-							"mul"
-						],
-						["dt"]
-					]]
-				]
-			],
-			[
-				2,
-				"off",
-				"=",
-				[
-					6,
-					[
-						7,
-						"off",
-						"mul"
-					],
-					[[
-						6,
-						"std.exp",
-						[[
-							1,
-							[
-								1,
-								[
-									7,
-									"prm",
-									"homeK"
-								],
-								"*",
-								"dt"
-							],
-							"*",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"offLen",
-				[
-					6,
-					"std.length",
-					["off"]
-				]
-			],
-			[
-				2,
-				"off",
-				"=",
-				[
-					6,
-					"std.select",
-					[
-						"off",
-						[
-							6,
-							[
-								7,
-								[
-									6,
-									[
-										7,
-										"off",
-										"div"
-									],
-									[[
-										6,
-										"std.max",
-										["offLen", [5, "0.00001"]]
-									]]
-								],
-								"mul"
-							],
-							["MAX_OFFSET"]
-						],
-						[
-							1,
-							"offLen",
-							">",
-							"MAX_OFFSET"
-						]
-					]
-				]
-			],
-			[
-				2,
-				[
-					8,
-					[
-						7,
-						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"filings"
-					],
-					"i"
-				],
-				"=",
-				[
-					6,
-					"d.vec4f",
-					[
-						[
-							7,
-							"off",
-							"x"
-						],
-						[
-							7,
-							"off",
-							"y"
-						],
-						"theta",
-						"omega"
-					]
-				]
-			]
-		]]
-	},
-	externals: {
-		"simLayout": () => simLayout,
-		"d.vec2f": () => vec2f,
-		"d.f32": () => f32,
-		"homeFn": () => homeFn,
-		"std.max": () => max,
-		"std.length": () => length,
-		"std.dot": () => dot,
-		"std.select": () => select,
-		"std.exp": () => exp,
-		"std.atan2": () => atan2,
-		"restAngleFn": () => restAngleFn,
-		"std.sin": () => sin,
-		"std.clamp": () => clamp,
-		"std.abs": () => abs,
-		"MAX_OFFSET": () => MAX_OFFSET,
-		"d.vec4f": () => vec4f
-	}
-}) && $.f)({})).$name("filingsUpdate");
-const componentDefinition = {
-	name: "MagneticFilings",
-	boundingBoxDeclaration: { aspectRatio: null },
-	category: "Interactive",
-	description: "Thousands of tiny iron filings scattered on paper that swing to align with a magnetic field around the cursor, tracing out the field lines — a dipole whose axis follows the cursor's motion draws the classic two-lobed swirl, and every sweep of the magnet sends a glowing wave of filings flipping and settling",
-	requiresRTT: false,
-	requiresChild: false,
-	usesPointer: true,
-	props: {
-		colorA: {
-			default: "#be1ef9",
-			transform: transformColor,
-			description: "Color of filings resting quietly, aligned and still",
-			ui: {
-				type: "color",
-				label: "Rest Color",
-				group: "Colors"
-			}
-		},
-		colorB: {
-			default: "#6326ff",
-			transform: transformColor,
-			description: "Color filings flash toward as they swing and settle — a wave of it follows the moving magnet",
-			ui: {
-				type: "color",
-				label: "Excited Color",
-				group: "Colors"
-			}
-		},
-		colorSpace: {
-			default: "oklab",
-			transform: transformColorSpace,
-			compileTime: true,
-			description: "Color space for the rest→excited color ramp",
-			ui: {
-				type: "select",
-				options: colorSpaceOptions,
-				label: "Color Space",
-				group: "Colors"
-			}
-		},
-		shape: {
-			default: "dot",
-			compileTime: true,
-			description: "How each filing is drawn — a slim streak or arrow reads as a compass needle, a box as a chunky filing, a dot or soft glow for a finer grain",
-			ui: {
-				type: "select",
-				options: orientedShapeOptions,
-				label: "Shape",
-				group: "Filings"
-			}
-		},
-		count: {
-			default: 8e3,
-			description: "Number of iron filings",
-			ui: {
-				type: "range",
-				min: 500,
-				max: 12e3,
-				step: 500,
-				label: "Count",
-				group: "Filings"
-			}
-		},
-		size: {
-			default: 1,
-			description: "Size of each filing",
-			ui: {
-				type: "range",
-				min: .5,
-				max: 3,
-				step: .05,
-				label: "Size",
-				group: "Filings"
-			}
-		},
-		restOrientation: {
-			default: "random",
-			description: "Which way filings point where the field can't reach them — randomly, all horizontal, or all vertical",
-			ui: {
-				type: "select",
-				options: [
-					{
-						label: "Random",
-						value: "random"
-					},
-					{
-						label: "Horizontal",
-						value: "horizontal"
-					},
-					{
-						label: "Vertical",
-						value: "vertical"
-					}
-				],
-				label: "Rest Orientation",
-				group: "Filings"
-			}
-		},
-		fieldType: {
-			default: "dipole",
-			description: "The magnetic field the filings reveal — a dipole (bar-magnet lobes that follow the cursor's motion) or a radial monopole (spokes out from the cursor)",
-			ui: {
-				type: "select",
-				options: [{
-					label: "Dipole",
-					value: "dipole"
-				}, {
-					label: "Radial",
-					value: "radial"
-				}],
-				label: "Field Type",
-				group: "Field"
-			}
-		},
-		strength: {
-			default: 1.7,
-			description: "How strongly the magnet grips the filings — higher snaps more of them into sharp alignment",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 3,
-				step: .01,
-				label: "Strength",
-				group: "Field"
-			}
-		},
-		reach: {
-			default: .6,
-			description: "How far the magnet's influence spreads (in screen heights) — larger reveals more of the field at once",
-			ui: {
-				type: "range",
-				min: .1,
-				max: 1,
-				step: .01,
-				label: "Reach",
-				group: "Field"
-			}
-		},
-		response: {
-			default: .5,
-			description: "How briskly filings swing and settle — low is loose and floppy with a long wobble, high snaps into place quickly",
-			ui: {
-				type: "range",
-				min: 0,
-				max: 1,
-				step: .01,
-				label: "Response",
-				group: "Field"
-			}
-		}
-	},
-	compute: (params) => {
-		const { getCpuValue } = params;
-		if (!params.gpu?.root) return null;
-		const splatKernel = makeFilingsSplatKernel(getCpuValue("shape") || "streak");
-		const resolveKernel = makeFilingsResolveKernel(getCpuValue("colorSpace") ?? 2);
-		const sys = createAgentSystem(params, {
-			layout: simLayout,
-			params: SimParams,
-			maxAgents: MAX_FILINGS,
-			output: {
-				key: "outTex",
-				name: "filingsTexture",
-				size: [RES, RES],
-				format: STATE_FORMAT
-			},
-			countCap: {
-				desktop: MAX_FILINGS,
-				mobile: 6e3
-			},
-			pipelines: {
-				init: {
-					kernel: filingsInitKernel,
-					threads: "max"
-				},
-				update: {
-					kernel: filingsUpdateKernel,
-					threads: "agents"
-				},
-				splat: {
-					kernel: splatKernel,
-					threads: "agents"
-				},
-				resolve: {
-					kernel: resolveKernel,
-					threads: "fixed",
-					size: [RES, RES]
-				}
-			},
-			initStep: "init",
-			program: [
-				"update",
-				"splat",
-				"resolve"
-			]
-		});
-		if (!sys) return null;
-		const g = makeCpuValueGetter(getCpuValue);
-		let lastCx = .5;
-		let lastCy = .5;
-		let axisX = 1;
-		let axisY = 0;
-		return {
-			outputs: sys.outputs,
-			getComputeNodes: (frameParams) => {
-				const { dt, aspect, pointerX, pointerY } = readAgentFrame(frameParams);
-				const domainX = Math.max(aspect, .01);
-				const count = sys.resolveCount(g("count", 5e3));
-				const spanX = domainX + 2 * OVERSCAN;
-				const spanY = 1 + 2 * OVERSCAN;
-				const cols = Math.max(1, Math.round(Math.sqrt(count * (spanX / spanY))));
-				const rows = Math.max(1, Math.ceil(count / cols));
-				const cellW = spanX / cols;
-				const cellH = spanY / rows;
-				const cursorX = pointerX * aspect;
-				const cursorY = pointerY;
-				const mvx = cursorX - lastCx;
-				const mvy = cursorY - lastCy;
-				const mvLen = Math.hypot(mvx, mvy);
-				if (mvLen > .001 && mvLen < .25) {
-					const nx = mvx / mvLen;
-					const ny = mvy / mvLen;
-					axisX += (nx - axisX) * .1;
-					axisY += (ny - axisY) * .1;
-					const al = Math.hypot(axisX, axisY) || 1;
-					axisX /= al;
-					axisY /= al;
-				}
-				lastCx = cursorX;
-				lastCy = cursorY;
-				const fieldType = (getCpuValue("fieldType") ?? "dipole") === "radial" ? 1 : 0;
-				const restStr = getCpuValue("restOrientation") ?? "random";
-				const restMode = restStr === "horizontal" ? 1 : restStr === "vertical" ? 2 : 0;
-				const strength = g("strength", 1);
-				const reach = g("reach", .35);
-				const response = Math.min(Math.max(g("response", .5), 0), 1);
-				const colA = getCpuValue("colorA");
-				const colB = getCpuValue("colorB");
-				const bodyR = Math.min(Math.max(g("size", 1), .5), 3) * 1.7 / SIZE_REF_RES;
-				sys.writeParams({
-					colA: vec4f(colA?.x ?? .522, colA?.y ?? .573, colA?.z ?? .639, colA?.w ?? 1),
-					colB: vec4f(colB?.x ?? 1, colB?.y ?? .616, colB?.z ?? .361, colB?.w ?? 1),
-					count,
-					dt,
-					aspect,
-					domainX,
-					cursorX,
-					cursorY,
-					axisX,
-					axisY,
-					fieldType,
-					restMode,
-					strength,
-					reachSq: reach * reach,
-					alignK: ALIGN_BASE,
-					damping: DAMP_MIN + response * DAMP_SPAN,
-					restK: REST_K,
-					pullK: PULL_K,
-					homeK: HOME_K,
-					omegaRef: OMEGA_REF,
-					agitCool: AGIT_COOL,
-					gridCols: cols,
-					cellW,
-					cellH,
-					jitter: .85,
-					bodyR
-				});
-				return sys.frame({ count });
-			}
-		};
-	},
-	fragment: ({ ctx, computeOutputs }) => {
-		const filingsField = computeOutputs?.filingsTexture;
-		if (!filingsField) return ZERO;
-		return filingsField.sample(ctx.uv, "linearClamp");
-	}
-};
-var MagneticFilings_default = componentDefinition;
-export { filingsSplatKernel as a, makeFilingsSplatKernel as c, filingsResolveKernel as i, componentDefinition as n, filingsUpdateKernel as o, filingsInitKernel as r, makeFilingsResolveKernel as s, MagneticFilings_default as t };