shaders 3.0.441 → 3.0.443

package/dist/core/MagneticFilings-BlNWPVwS.js

@@ -0,0 +1,3118 @@
+import { J as std, Rt as ZERO, X as createGuardedCompute, Z as createStateBuffer, bn as d, c as orientedShapeOptions, ct as hash22, dn as mixColorsVariants, 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-0A7CojvN.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-P50Uo_Ju.js";
+var MAX_FILINGS = 12288;
+var RES = 1024;
+var INV_RES = 1 / RES;
+var STATE_FORMAT = "rgba16float";
+var SPLAT_R = 14;
+var SPLAT_WIN = 29;
+var AA_W = .75 * INV_RES;
+var PI = 3.141592653589793;
+var HALF_PI = 1.5707963267948966;
+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 = 637;
+var SOFT_GAIN = 255;
+var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
+	colA: d.vec4f,
+	colB: d.vec4f,
+	count: d.f32,
+	dt: d.f32,
+	aspect: d.f32,
+	domainX: d.f32,
+	cursorX: d.f32,
+	cursorY: d.f32,
+	axisX: d.f32,
+	axisY: d.f32,
+	fieldType: d.f32,
+	restMode: d.f32,
+	strength: d.f32,
+	reachSq: d.f32,
+	alignK: d.f32,
+	damping: d.f32,
+	restK: d.f32,
+	pullK: d.f32,
+	homeK: d.f32,
+	omegaRef: d.f32,
+	agitCool: d.f32,
+	gridCols: d.f32,
+	cellW: d.f32,
+	cellH: d.f32,
+	jitter: d.f32,
+	bodyR: d.f32
+}), "SimParams");
+var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+	filings: {
+		storage: d.arrayOf(d.vec4f, MAX_FILINGS),
+		access: "mutable"
+	},
+	agit: {
+		storage: d.arrayOf(d.f32, MAX_FILINGS),
+		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"
+	},
+	params: { uniform: SimParams },
+	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+}), "simLayout");
+var homeFn = tgpu.fn([
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32,
+	d.f32
+], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi, cols, cellW, cellH, jitter) => {
+	"use gpu";
+	const row = std.floor(__tsover_div(fi, std.max(cols, 1)));
+	const col = __tsover_sub(fi, __tsover_mul(row, std.max(cols, 1)));
+	const h = hash22(d.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 d.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: 1,
+	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,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					[[
+						1,
+						"fi",
+						"/",
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							["cols", [5, "1"]]
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"col",
+				[
+					1,
+					"fi",
+					"-",
+					[
+						1,
+						"row",
+						"*",
+						[
+							6,
+							[
+								7,
+								"std",
+								"max"
+							],
+							["cols", [5, "1"]]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"h",
+				[
+					6,
+					[
+						7,
+						"noise",
+						"hash22"
+					],
+					[[
+						6,
+						[
+							7,
+							"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,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"col",
+								"+",
+								[5, "0.5"]
+							],
+							"+",
+							"jx"
+						],
+						"*",
+						"cellW"
+					],
+					"-",
+					"OVERSCAN"
+				], [
+					1,
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"row",
+								"+",
+								[5, "0.5"]
+							],
+							"+",
+							"jy"
+						],
+						"*",
+						"cellH"
+					],
+					"-",
+					"OVERSCAN"
+				]]
+			]]
+		]],
+		"externalNames": [
+			"std",
+			"noise",
+			"d",
+			"OVERSCAN"
+		]
+	},
+	externals: () => ({
+		std,
+		noise: noise_exports,
+		d,
+		OVERSCAN
+	})
+}) && $.f)({})).$name("filingsHome");
+var restAngleFn = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fi, restMode) => {
+	"use gpu";
+	const randAng = __tsover_mul(hash11(__tsover_add(__tsover_mul(fi, 2.3987), .517)), PI);
+	const a = std.select(randAng, d.f32(0), restMode > .5);
+	return std.select(a, HALF_PI, restMode > 1.5);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "fi"
+		}, {
+			"type": "i",
+			"name": "restMode"
+		}],
+		"body": [0, [
+			[
+				13,
+				"randAng",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"noise",
+							"hash11"
+						],
+						[[
+							1,
+							[
+								1,
+								"fi",
+								"*",
+								[5, "2.3987"]
+							],
+							"+",
+							[5, "0.517"]
+						]]
+					],
+					"*",
+					"PI"
+				]
+			],
+			[
+				13,
+				"a",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"randAng",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							1,
+							"restMode",
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"select"
+				],
+				[
+					"a",
+					"HALF_PI",
+					[
+						1,
+						"restMode",
+						">",
+						[5, "1.5"]
+					]
+				]
+			]]
+		]],
+		"externalNames": [
+			"noise",
+			"PI",
+			"std",
+			"d",
+			"HALF_PI"
+		]
+	},
+	externals: () => ({
+		noise: noise_exports,
+		PI,
+		std,
+		d,
+		HALF_PI
+	})
+}) && $.f)({})).$name("filingsRestAngle");
+const filingsInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+	"use gpu";
+	const fi = d.f32(i);
+	const theta0 = __tsover_mul(hash11(__tsover_add(__tsover_mul(fi, 1.618034), .31)), PI);
+	simLayout.$.filings[i] = d.vec4f(d.f32(0), d.f32(0), theta0, d.f32(0));
+	simLayout.$.agit[i] = d.f32(0);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "i"
+		}],
+		"body": [0, [
+			[
+				13,
+				"fi",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["i"]
+				]
+			],
+			[
+				13,
+				"theta0",
+				[
+					1,
+					[
+						6,
+						[
+							7,
+							"noise",
+							"hash11"
+						],
+						[[
+							1,
+							[
+								1,
+								"fi",
+								"*",
+								[5, "1.618034"]
+							],
+							"+",
+							[5, "0.31"]
+						]]
+					],
+					"*",
+					"PI"
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"filings"
+					],
+					"i"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						],
+						"theta0",
+						[
+							6,
+							[
+								7,
+								"d",
+								"f32"
+							],
+							[[5, "0"]]
+						]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"agit"
+					],
+					"i"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					[[5, "0"]]
+				]
+			]
+		]],
+		"externalNames": [
+			"d",
+			"noise",
+			"PI",
+			"simLayout"
+		]
+	},
+	externals: () => ({
+		d,
+		noise: noise_exports,
+		PI,
+		simLayout
+	})
+}) && $.f)({})).$name("filingsInit");
+const filingsClearAccumKernel = 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("filingsClearAccum");
+function makeFilingsSplatKernel(shape) {
+	const name = resolveAgentShape(shape, "streak");
+	const s = AGENT_SHAPES[name];
+	const weightFn = makeAgentWeightFn(name);
+	const SOFT = s.soft;
+	const EXT = 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 st = simLayout.$.filings[i];
+		const home = homeFn(d.f32(i), prm.gridCols, prm.cellW, prm.cellH, prm.jitter);
+		const pos = d.vec2f(__tsover_add(home.x, st.x), __tsover_add(home.y, st.y));
+		const theta = st.z;
+		const dir = d.vec2f(std.cos(theta), std.sin(theta));
+		const agitI = std.clamp(simLayout.$.agit[i], 0, 1);
+		const bodyR = std.max(prm.bodyR, 1e-6);
+		const extSq = __tsover_mul(__tsover_add(__tsover_mul(bodyR, EXT), __tsover_mul(AA_W, 2)), __tsover_add(__tsover_mul(bodyR, EXT), __tsover_mul(AA_W, 2)));
+		const txf = __tsover_mul(__tsover_div(pos.x, std.max(prm.aspect, 1e-5)), d.f32(RES));
+		const tyf = __tsover_mul(pos.y, d.f32(RES));
+		const cxi = d.i32(std.floor(txf));
+		const cyi = d.i32(std.floor(tyf));
+		for (let ky = 0; ky < SPLAT_WIN; ky++) for (let kx = 0; kx < SPLAT_WIN; kx++) {
+			const px = __tsover_sub(__tsover_add(cxi, kx), SPLAT_R);
+			const py = __tsover_sub(__tsover_add(cyi, ky), SPLAT_R);
+			if (px >= 0 && px < RES && py >= 0 && py < RES) {
+				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(d.f32(px), .5), INV_RES), prm.aspect), pos.x);
+				const offY = __tsover_sub(__tsover_mul(__tsover_add(d.f32(py), .5), INV_RES), pos.y);
+				if (__tsover_add(__tsover_mul(offX, offX), __tsover_mul(offY, offY)) < extSq) {
+					const w = weightFn(__tsover_add(__tsover_mul(offX, dir.x), __tsover_mul(offY, dir.y)), __tsover_add(__tsover_mul(offX, -dir.y), __tsover_mul(offY, dir.x)), bodyR, AA_W, d.f32(SOFT));
+					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,
+					"st",
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"filings"
+						],
+						"i"
+					]
+				],
+				[
+					13,
+					"home",
+					[
+						6,
+						"homeFn",
+						[
+							[
+								6,
+								[
+									7,
+									"d",
+									"f32"
+								],
+								["i"]
+							],
+							[
+								7,
+								"prm",
+								"gridCols"
+							],
+							[
+								7,
+								"prm",
+								"cellW"
+							],
+							[
+								7,
+								"prm",
+								"cellH"
+							],
+							[
+								7,
+								"prm",
+								"jitter"
+							]
+						]
+					]
+				],
+				[
+					13,
+					"pos",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							1,
+							[
+								7,
+								"home",
+								"x"
+							],
+							"+",
+							[
+								7,
+								"st",
+								"x"
+							]
+						], [
+							1,
+							[
+								7,
+								"home",
+								"y"
+							],
+							"+",
+							[
+								7,
+								"st",
+								"y"
+							]
+						]]
+					]
+				],
+				[
+					13,
+					"theta",
+					[
+						7,
+						"st",
+						"z"
+					]
+				],
+				[
+					13,
+					"dir",
+					[
+						6,
+						[
+							7,
+							"d",
+							"vec2f"
+						],
+						[[
+							6,
+							[
+								7,
+								"std",
+								"cos"
+							],
+							["theta"]
+						], [
+							6,
+							[
+								7,
+								"std",
+								"sin"
+							],
+							["theta"]
+						]]
+					]
+				],
+				[
+					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,
+					"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"
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								[[
+									7,
+									"prm",
+									"aspect"
+								], [5, "0.00001"]]
+							]
+						],
+						"*",
+						[
+							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,
+												"w",
+												[
+													6,
+													"weightFn",
+													[
+														"t",
+														"n",
+														"bodyR",
+														"AA_W",
+														[
+															6,
+															[
+																7,
+																"d",
+																"f32"
+															],
+															["SOFT"]
+														]
+													]
+												]
+											],
+											[
+												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",
+				"homeFn",
+				"d",
+				"std",
+				"EXT",
+				"AA_W",
+				"RES",
+				"SPLAT_WIN",
+				"SPLAT_R",
+				"INV_RES",
+				"weightFn",
+				"SOFT",
+				"GAIN"
+			]
+		},
+		externals: () => ({
+			simLayout,
+			homeFn,
+			d,
+			std,
+			EXT,
+			AA_W,
+			RES,
+			SPLAT_WIN,
+			SPLAT_R,
+			INV_RES,
+			weightFn,
+			SOFT,
+			GAIN
+		})
+	}) && $.f)({})).$name("filingsSplat");
+}
+const filingsSplatKernel = makeFilingsSplatKernel("streak");
+function makeFilingsResolveKernel(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 a = __tsover_mul(__tsover_sub(1, std.exp(__tsover_mul(energy, -1.6))), col.w);
+		std.textureStore(simLayout.$.outTex, d.vec2u(x, y), d.vec4f(col.x, col.y, col.z, a));
+	}), {
+		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,
+					"a",
+					[
+						1,
+						[
+							1,
+							[5, "1"],
+							"-",
+							[
+								6,
+								[
+									7,
+									"std",
+									"exp"
+								],
+								[[
+									1,
+									"energy",
+									"*",
+									[
+										4,
+										"-",
+										[5, "1.6"]
+									]
+								]]
+							]
+						],
+						"*",
+						[
+							7,
+							"col",
+							"w"
+						]
+					]
+				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"textureStore"
+					],
+					[
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"outTex"
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec2u"
+							],
+							["x", "y"]
+						],
+						[
+							6,
+							[
+								7,
+								"d",
+								"vec4f"
+							],
+							[
+								[
+									7,
+									"col",
+									"x"
+								],
+								[
+									7,
+									"col",
+									"y"
+								],
+								[
+									7,
+									"col",
+									"z"
+								],
+								"a"
+							]
+						]
+					]
+				]
+			]],
+			"externalNames": [
+				"simLayout",
+				"d",
+				"RES",
+				"std",
+				"mixFn"
+			]
+		},
+		externals: () => ({
+			simLayout,
+			d,
+			RES,
+			std,
+			mixFn
+		})
+	}) && $.f)({})).$name("filingsResolve");
+}
+const filingsResolveKernel = makeFilingsResolveKernel(2);
+const filingsUpdateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+	"use gpu";
+	const prm = simLayout.$.params;
+	const st = simLayout.$.filings[i];
+	let off = d.vec2f(st.x, st.y);
+	let theta = st.z;
+	let omega = st.w;
+	const dt = prm.dt;
+	const fi = d.f32(i);
+	const home = homeFn(fi, prm.gridCols, prm.cellW, prm.cellH, prm.jitter);
+	const pos = d.vec2f(__tsover_add(home.x, off.x), __tsover_add(home.y, off.y));
+	const cursor = d.vec2f(prm.cursorX, prm.cursorY);
+	const delta = pos.sub(cursor);
+	const r = std.max(std.length(delta), 1e-4);
+	const rhat = delta.div(r);
+	const axis = d.vec2f(prm.axisX, prm.axisY);
+	const mdotr = std.dot(axis, rhat);
+	const dipoleB = rhat.mul(__tsover_mul(2, mdotr)).sub(axis);
+	const B = std.select(dipoleB, rhat, prm.fieldType > .5);
+	const fieldStr = __tsover_mul(prm.strength, std.exp(__tsover_mul(__tsover_div(__tsover_mul(r, r), std.max(prm.reachSq, 1e-6)), -1)));
+	const phiField = std.atan2(B.y, B.x);
+	const restAngle = restAngleFn(fi, prm.restMode);
+	const torqueField = __tsover_mul(__tsover_mul(prm.alignK, fieldStr), std.sin(__tsover_mul(2, __tsover_sub(phiField, theta))));
+	const torqueRest = __tsover_mul(prm.restK, std.sin(__tsover_mul(2, __tsover_sub(restAngle, theta))));
+	omega = __tsover_add(omega, __tsover_mul(__tsover_add(torqueField, torqueRest), dt));
+	omega = __tsover_mul(omega, std.exp(__tsover_mul(__tsover_mul(prm.damping, dt), -1)));
+	theta = __tsover_add(theta, __tsover_mul(omega, dt));
+	const raw = std.clamp(__tsover_div(std.abs(omega), std.max(prm.omegaRef, 1e-5)), 0, 1);
+	const cooled = __tsover_mul(simLayout.$.agit[i], std.exp(__tsover_mul(dt, -prm.agitCool)));
+	simLayout.$.agit[i] = std.max(raw, cooled);
+	const pull = rhat.mul(__tsover_mul(__tsover_mul(prm.pullK, fieldStr), -1));
+	off = off.add(pull.mul(dt));
+	off = off.mul(std.exp(__tsover_mul(__tsover_mul(prm.homeK, dt), -1)));
+	const offLen = std.length(off);
+	off = std.select(off, off.div(std.max(offLen, 1e-5)).mul(MAX_OFFSET), offLen > MAX_OFFSET);
+	simLayout.$.filings[i] = d.vec4f(off.x, off.y, theta, omega);
+}), {
+	v: 1,
+	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,
+					[
+						7,
+						"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,
+					[
+						7,
+						"d",
+						"f32"
+					],
+					["i"]
+				]
+			],
+			[
+				13,
+				"home",
+				[
+					6,
+					"homeFn",
+					[
+						"fi",
+						[
+							7,
+							"prm",
+							"gridCols"
+						],
+						[
+							7,
+							"prm",
+							"cellW"
+						],
+						[
+							7,
+							"prm",
+							"cellH"
+						],
+						[
+							7,
+							"prm",
+							"jitter"
+						]
+					]
+				]
+			],
+			[
+				13,
+				"pos",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						1,
+						[
+							7,
+							"home",
+							"x"
+						],
+						"+",
+						[
+							7,
+							"off",
+							"x"
+						]
+					], [
+						1,
+						[
+							7,
+							"home",
+							"y"
+						],
+						"+",
+						[
+							7,
+							"off",
+							"y"
+						]
+					]]
+				]
+			],
+			[
+				13,
+				"cursor",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						7,
+						"prm",
+						"cursorX"
+					], [
+						7,
+						"prm",
+						"cursorY"
+					]]
+				]
+			],
+			[
+				13,
+				"delta",
+				[
+					6,
+					[
+						7,
+						"pos",
+						"sub"
+					],
+					["cursor"]
+				]
+			],
+			[
+				13,
+				"r",
+				[
+					6,
+					[
+						7,
+						"std",
+						"max"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"length"
+						],
+						["delta"]
+					], [5, "0.0001"]]
+				]
+			],
+			[
+				13,
+				"rhat",
+				[
+					6,
+					[
+						7,
+						"delta",
+						"div"
+					],
+					["r"]
+				]
+			],
+			[
+				13,
+				"axis",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec2f"
+					],
+					[[
+						7,
+						"prm",
+						"axisX"
+					], [
+						7,
+						"prm",
+						"axisY"
+					]]
+				]
+			],
+			[
+				13,
+				"mdotr",
+				[
+					6,
+					[
+						7,
+						"std",
+						"dot"
+					],
+					["axis", "rhat"]
+				]
+			],
+			[
+				13,
+				"dipoleB",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							[
+								7,
+								"rhat",
+								"mul"
+							],
+							[[
+								1,
+								[5, "2"],
+								"*",
+								"mdotr"
+							]]
+						],
+						"sub"
+					],
+					["axis"]
+				]
+			],
+			[
+				13,
+				"B",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"dipoleB",
+						"rhat",
+						[
+							1,
+							[
+								7,
+								"prm",
+								"fieldType"
+							],
+							">",
+							[5, "0.5"]
+						]
+					]
+				]
+			],
+			[
+				13,
+				"fieldStr",
+				[
+					1,
+					[
+						7,
+						"prm",
+						"strength"
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									1,
+									"r",
+									"*",
+									"r"
+								],
+								"/",
+								[
+									6,
+									[
+										7,
+										"std",
+										"max"
+									],
+									[[
+										7,
+										"prm",
+										"reachSq"
+									], [5, "0.000001"]]
+								]
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"phiField",
+				[
+					6,
+					[
+						7,
+						"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,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						[[
+							1,
+							[5, "2"],
+							"*",
+							[
+								1,
+								"phiField",
+								"-",
+								"theta"
+							]
+						]]
+					]
+				]
+			],
+			[
+				13,
+				"torqueRest",
+				[
+					1,
+					[
+						7,
+						"prm",
+						"restK"
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"sin"
+						],
+						[[
+							1,
+							[5, "2"],
+							"*",
+							[
+								1,
+								"restAngle",
+								"-",
+								"theta"
+							]
+						]]
+					]
+				]
+			],
+			[
+				2,
+				"omega",
+				"=",
+				[
+					1,
+					"omega",
+					"+",
+					[
+						1,
+						[
+							1,
+							"torqueField",
+							"+",
+							"torqueRest"
+						],
+						"*",
+						"dt"
+					]
+				]
+			],
+			[
+				2,
+				"omega",
+				"=",
+				[
+					1,
+					"omega",
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									7,
+									"prm",
+									"damping"
+								],
+								"*",
+								"dt"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]]
+					]
+				]
+			],
+			[
+				2,
+				"theta",
+				"=",
+				[
+					1,
+					"theta",
+					"+",
+					[
+						1,
+						"omega",
+						"*",
+						"dt"
+					]
+				]
+			],
+			[
+				13,
+				"raw",
+				[
+					6,
+					[
+						7,
+						"std",
+						"clamp"
+					],
+					[
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"abs"
+								],
+								["omega"]
+							],
+							"/",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								[[
+									7,
+									"prm",
+									"omegaRef"
+								], [5, "0.00001"]]
+							]
+						],
+						[5, "0"],
+						[5, "1"]
+					]
+				]
+			],
+			[
+				13,
+				"cooled",
+				[
+					1,
+					[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"agit"
+						],
+						"i"
+					],
+					"*",
+					[
+						6,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							"dt",
+							"*",
+							[
+								4,
+								"-",
+								[
+									7,
+									"prm",
+									"agitCool"
+								]
+							]
+						]]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"agit"
+					],
+					"i"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"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,
+						[
+							7,
+							"std",
+							"exp"
+						],
+						[[
+							1,
+							[
+								1,
+								[
+									7,
+									"prm",
+									"homeK"
+								],
+								"*",
+								"dt"
+							],
+							"*",
+							[
+								4,
+								"-",
+								[5, "1"]
+							]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"offLen",
+				[
+					6,
+					[
+						7,
+						"std",
+						"length"
+					],
+					["off"]
+				]
+			],
+			[
+				2,
+				"off",
+				"=",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"off",
+						[
+							6,
+							[
+								7,
+								[
+									6,
+									[
+										7,
+										"off",
+										"div"
+									],
+									[[
+										6,
+										[
+											7,
+											"std",
+											"max"
+										],
+										["offLen", [5, "0.00001"]]
+									]]
+								],
+								"mul"
+							],
+							["MAX_OFFSET"]
+						],
+						[
+							1,
+							"offLen",
+							">",
+							"MAX_OFFSET"
+						]
+					]
+				]
+			],
+			[
+				2,
+				[
+					8,
+					[
+						7,
+						[
+							7,
+							"simLayout",
+							"$"
+						],
+						"filings"
+					],
+					"i"
+				],
+				"=",
+				[
+					6,
+					[
+						7,
+						"d",
+						"vec4f"
+					],
+					[
+						[
+							7,
+							"off",
+							"x"
+						],
+						[
+							7,
+							"off",
+							"y"
+						],
+						"theta",
+						"omega"
+					]
+				]
+			]
+		]],
+		"externalNames": [
+			"simLayout",
+			"d",
+			"homeFn",
+			"std",
+			"restAngleFn",
+			"MAX_OFFSET"
+		]
+	},
+	externals: () => ({
+		simLayout,
+		d,
+		homeFn,
+		std,
+		restAngleFn,
+		MAX_OFFSET
+	})
+}) && $.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 { gpu, getCpuValue, registerComputeTexture, onCleanup } = params;
+		const root = gpu?.root;
+		if (!root) return null;
+		const filings = createStateBuffer(root, d.vec4f, MAX_FILINGS);
+		const agitBuf = createStateBuffer(root, d.f32, MAX_FILINGS);
+		const accumE = createStateBuffer(root, d.atomic(d.u32), RES * RES);
+		const accumS = createStateBuffer(root, d.atomic(d.u32), 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 filingsTexture = registerComputeTexture(outTex);
+		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(SimParams), "paramsU");
+		const simBg = root.createBindGroup(simLayout, {
+			filings,
+			agit: agitBuf,
+			accumE,
+			accumS,
+			params: paramsU.buffer,
+			outTex
+		});
+		const splatKernel = makeFilingsSplatKernel(getCpuValue("shape") || "streak");
+		const resolveKernel = makeFilingsResolveKernel(getCpuValue("colorSpace") ?? 2);
+		const init = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+			"use gpu";
+			filingsInitKernel(i);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "i"
+				}],
+				"body": [0, [[
+					6,
+					"filingsInitKernel",
+					["i"]
+				]]],
+				"externalNames": ["filingsInitKernel"]
+			},
+			externals: () => ({ filingsInitKernel })
+		}) && $.f)({})).with(simBg);
+		const clearAccum = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+			"use gpu";
+			filingsClearAccumKernel(x, y);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "x"
+				}, {
+					"type": "i",
+					"name": "y"
+				}],
+				"body": [0, [[
+					6,
+					"filingsClearAccumKernel",
+					["x", "y"]
+				]]],
+				"externalNames": ["filingsClearAccumKernel"]
+			},
+			externals: () => ({ filingsClearAccumKernel })
+		}) && $.f)({}), { size: [RES, RES] }).with(simBg);
+		const update = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+			"use gpu";
+			filingsUpdateKernel(i);
+		}), {
+			v: 1,
+			name: void 0,
+			ast: {
+				"params": [{
+					"type": "i",
+					"name": "i"
+				}],
+				"body": [0, [[
+					6,
+					"filingsUpdateKernel",
+					["i"]
+				]]],
+				"externalNames": ["filingsUpdateKernel"]
+			},
+			externals: () => ({ filingsUpdateKernel })
+		}) && $.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 lastCx = .5;
+		let lastCy = .5;
+		let axisX = 1;
+		let axisY = 0;
+		return {
+			outputs: { filingsTexture },
+			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", 5e3)), 16), MAX_FILINGS);
+				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 = (fp.pointer?.x ?? .5) * aspect;
+				const cursorY = fp.pointer?.y ?? .5;
+				const mvx = cursorX - lastCx;
+				const mvy = cursorY - lastCy;
+				const mvLen = Math.hypot(mvx, mvy);
+				if (mvLen > .001) {
+					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 * INV_RES;
+				paramsU.write({
+					colA: d.vec4f(colA?.x ?? .522, colA?.y ?? .573, colA?.z ?? .639, colA?.w ?? 1),
+					colB: d.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
+				});
+				const nodes = [];
+				if (!initialized) {
+					initialized = true;
+					nodes.push(() => init.dispatchThreads(MAX_FILINGS));
+				}
+				nodes.push(clearAccum, () => update.dispatchThreads(count), () => splat.dispatchThreads(count), resolve);
+				return nodes;
+			}
+		};
+	},
+	fragment: ({ ctx, computeOutputs }) => {
+		const filingsField = computeOutputs?.filingsTexture;
+		if (!filingsField) return ZERO;
+		return filingsField.sample(ctx.uv, "linearClamp");
+	}
+};
+var MagneticFilings_default = componentDefinition;
+export { filingsResolveKernel as a, makeFilingsResolveKernel as c, filingsInitKernel as i, makeFilingsSplatKernel as l, componentDefinition as n, filingsSplatKernel as o, filingsClearAccumKernel as r, filingsUpdateKernel as s, MagneticFilings_default as t };