shaders 3.0.448 → 3.0.449

package/dist/core/{Liquify-gNsuR7aA.js → Liquify-CJwl6Wef.js}

@@ -1,58 +1,59 @@
-import { Bt as ZERO, Gt as expr, Ht as call, J as std, Lt as sampleRemappedExpr, Tn as d, X as createGuardedCompute, Z as createStateBuffer, cn as unpremultiplyAlpha, jt as composeEdgeRemapExpr, n as tgpu } from "./coords-BkIjixe_.js";
-import { s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Gt as textureStorage2d, N as unpremultiplyAlpha, Ut as arrayOf, Vt as data_exports, Xt as struct, _t as clamp, an as f32, at as textureStore, c as sampleRemappedExpr, d as ZERO, et as src_default, g as expr, in as vec4f, n as composeEdgeRemapExpr, nt as std_exports, p as call, pt as select, sn as u32, tn as vec2u, xt as exp } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var GRID_SIZE = 64;
 var CELL_COUNT = GRID_SIZE * GRID_SIZE;
 var GRID_MAX = GRID_SIZE - 1;
 var STATE_FORMAT = "rgba16float";
-var springLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var springLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	readBuf: {
-		storage: d.arrayOf(d.vec4f, CELL_COUNT),
+		storage: arrayOf(vec4f, CELL_COUNT),
 		access: "readonly"
 	},
 	writeBuf: {
-		storage: d.arrayOf(d.vec4f, CELL_COUNT),
+		storage: arrayOf(vec4f, CELL_COUNT),
 		access: "mutable"
 	},
-	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-		cursorX: d.f32,
-		cursorY: d.f32,
-		dirX: d.f32,
-		dirY: d.f32,
-		clampedSpeed: d.f32,
-		dt: d.f32,
-		subDt: d.f32,
-		stiffness: d.f32,
-		dampFactor: d.f32,
-		radius: d.f32,
-		aspect: d.f32
+	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+		cursorX: f32,
+		cursorY: f32,
+		dirX: f32,
+		dirY: f32,
+		clampedSpeed: f32,
+		dt: f32,
+		subDt: f32,
+		stiffness: f32,
+		dampFactor: f32,
+		radius: f32,
+		aspect: f32
 	}), "uniform") }
 }), "springLayout");
-var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	srcBuf: {
-		storage: d.arrayOf(d.vec4f, CELL_COUNT),
+		storage: arrayOf(vec4f, CELL_COUNT),
 		access: "readonly"
 	},
-	dispTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	dispTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "outputLayout");
-const springKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const springKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	if (cx > d.u32(0) && cx < d.u32(GRID_MAX) && cy > d.u32(0) && cy < d.u32(GRID_MAX)) {
+	if (cx > u32(0) && cx < u32(GRID_MAX) && cy > u32(0) && cy < u32(GRID_MAX)) {
 		const p = springLayout.$.params;
-		const gs = d.u32(GRID_SIZE);
+		const gs = u32(GRID_SIZE);
 		const idx = __tsover_add(__tsover_mul(cy, gs), cx);
 		const current = springLayout.$.readBuf[idx];
 		const dispX = current.x;
 		const dispY = current.y;
 		const velX = current.z;
 		const velY = current.w;
-		const nL = springLayout.$.readBuf[__tsover_sub(idx, d.u32(1))];
-		const nR = springLayout.$.readBuf[__tsover_add(idx, d.u32(1))];
+		const nL = springLayout.$.readBuf[__tsover_sub(idx, u32(1))];
+		const nR = springLayout.$.readBuf[__tsover_add(idx, u32(1))];
 		const nU = springLayout.$.readBuf[__tsover_sub(idx, gs)];
 		const nD = springLayout.$.readBuf[__tsover_add(idx, gs)];
-		const nUL = springLayout.$.readBuf[__tsover_sub(__tsover_sub(idx, gs), d.u32(1))];
-		const nUR = springLayout.$.readBuf[__tsover_add(__tsover_sub(idx, gs), d.u32(1))];
-		const nDL = springLayout.$.readBuf[__tsover_sub(__tsover_add(idx, gs), d.u32(1))];
-		const nDR = springLayout.$.readBuf[__tsover_add(__tsover_add(idx, gs), d.u32(1))];
+		const nUL = springLayout.$.readBuf[__tsover_sub(__tsover_sub(idx, gs), u32(1))];
+		const nUR = springLayout.$.readBuf[__tsover_add(__tsover_sub(idx, gs), u32(1))];
+		const nDL = springLayout.$.readBuf[__tsover_sub(__tsover_add(idx, gs), u32(1))];
+		const nDR = springLayout.$.readBuf[__tsover_add(__tsover_add(idx, gs), u32(1))];
 		let fx = __tsover_mul(p.stiffness, __tsover_add(__tsover_add(__tsover_add(__tsover_sub(nL.x, dispX), __tsover_sub(nR.x, dispX)), __tsover_sub(nU.x, dispX)), __tsover_sub(nD.x, dispX)));
 		let fy = __tsover_mul(p.stiffness, __tsover_add(__tsover_add(__tsover_add(__tsover_sub(nL.y, dispY), __tsover_sub(nR.y, dispY)), __tsover_sub(nU.y, dispY)), __tsover_sub(nD.y, dispY)));
 		const shearK = __tsover_mul(p.stiffness, .35);
@@ -63,22 +64,22 @@ const springKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis
 		let newVelX = __tsover_add(__tsover_mul(velX, p.dampFactor), __tsover_mul(fx, p.subDt));
 		let newVelY = __tsover_add(__tsover_mul(velY, p.dampFactor), __tsover_mul(fy, p.subDt));
 		if (p.clampedSpeed > .01) {
-			const cellX = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(GRID_SIZE));
-			const cellY = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(GRID_SIZE));
-			const ddx = std.select(__tsover_sub(cellX, p.cursorX), __tsover_mul(__tsover_sub(cellX, p.cursorX), p.aspect), p.aspect >= 1);
-			const ddy = std.select(__tsover_div(__tsover_sub(cellY, p.cursorY), p.aspect), __tsover_sub(cellY, p.cursorY), p.aspect >= 1);
+			const cellX = __tsover_div(__tsover_add(f32(cx), .5), f32(GRID_SIZE));
+			const cellY = __tsover_div(__tsover_add(f32(cy), .5), f32(GRID_SIZE));
+			const ddx = select(__tsover_sub(cellX, p.cursorX), __tsover_mul(__tsover_sub(cellX, p.cursorX), p.aspect), p.aspect >= 1);
+			const ddy = select(__tsover_div(__tsover_sub(cellY, p.cursorY), p.aspect), __tsover_sub(cellY, p.cursorY), p.aspect >= 1);
 			const distSq = __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy));
 			const influenceRadius = __tsover_mul(p.radius, 3);
 			if (distSq < __tsover_mul(influenceRadius, influenceRadius)) {
-				const influence = std.exp(__tsover_mul(__tsover_div(distSq, __tsover_mul(p.radius, p.radius)), -1));
+				const influence = exp(__tsover_mul(__tsover_div(distSq, __tsover_mul(p.radius, p.radius)), -1));
 				const forceMag = __tsover_mul(__tsover_mul(__tsover_mul(influence, p.clampedSpeed), p.dt), 2);
 				newVelX = __tsover_add(newVelX, __tsover_mul(p.dirX, forceMag));
 				newVelY = __tsover_add(newVelY, __tsover_mul(p.dirY, forceMag));
 			}
 		}
-		const newDispX = std.clamp(__tsover_add(dispX, __tsover_mul(newVelX, p.subDt)), -.5, .5);
-		const newDispY = std.clamp(__tsover_add(dispY, __tsover_mul(newVelY, p.subDt)), -.5, .5);
-		springLayout.$.writeBuf[idx] = d.vec4f(newDispX, newDispY, newVelX, newVelY);
+		const newDispX = clamp(__tsover_add(dispX, __tsover_mul(newVelX, p.subDt)), -.5, .5);
+		const newDispY = clamp(__tsover_add(dispY, __tsover_mul(newVelY, p.subDt)), -.5, .5);
+		springLayout.$.writeBuf[idx] = vec4f(newDispX, newDispY, newVelX, newVelY);
 	}
 }), {
 	v: 1,
@@ -1337,18 +1338,18 @@ const springKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		GRID_MAX,
 		springLayout,
 		GRID_SIZE,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("liquifySpring");
-const outputKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const outputKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(GRID_SIZE)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(GRID_SIZE)), cx);
 	const cell = outputLayout.$.srcBuf[idx];
-	std.textureStore(outputLayout.$.dispTex, d.vec2u(cx, cy), d.vec4f(cell.x, cell.y, 0, 1));
+	textureStore(outputLayout.$.dispTex, vec2u(cx, cy), vec4f(cell.x, cell.y, 0, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -1460,21 +1461,21 @@ const outputKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		GRID_SIZE,
 		outputLayout,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("liquifyOutput");
-const liquifyOffsetUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, disp, intensity) => {
+const liquifyOffsetUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, disp, intensity) => {
 	"use gpu";
 	const scaled = disp.mul(__tsover_mul(intensity, .1));
 	const maxDisp = .15;
-	const clamped = std.clamp(scaled, d.vec2f(-maxDisp, -maxDisp), d.vec2f(maxDisp, maxDisp));
+	const clamped = clamp(scaled, vec2f(-maxDisp, -maxDisp), vec2f(maxDisp, maxDisp));
 	return uv.sub(clamped);
 }), {
 	v: 1,
@@ -1572,8 +1573,8 @@ const liquifyOffsetUV = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {
@@ -1667,26 +1668,26 @@ const componentDefinition = {
 		const { gpu, registerComputeTexture, getCpuValue, onCleanup, onResize, dimensions } = params;
 		const root = gpu?.root;
 		if (!root) return null;
-		const bufferA = createStateBuffer(root, d.vec4f, CELL_COUNT);
-		const bufferB = createStateBuffer(root, d.vec4f, CELL_COUNT);
+		const bufferA = createStateBuffer(root, vec4f, CELL_COUNT);
+		const bufferB = createStateBuffer(root, vec4f, CELL_COUNT);
 		const dispTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [GRID_SIZE, GRID_SIZE],
 			format: STATE_FORMAT
 		}).$usage("storage", "sampled"), "dispTex");
 		onCleanup(() => dispTex.destroy());
 		const displacement = registerComputeTexture(dispTex);
-		const springParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(d.struct({
-			cursorX: d.f32,
-			cursorY: d.f32,
-			dirX: d.f32,
-			dirY: d.f32,
-			clampedSpeed: d.f32,
-			dt: d.f32,
-			subDt: d.f32,
-			stiffness: d.f32,
-			dampFactor: d.f32,
-			radius: d.f32,
-			aspect: d.f32
+		const springParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
+			cursorX: f32,
+			cursorY: f32,
+			dirX: f32,
+			dirY: f32,
+			clampedSpeed: f32,
+			dt: f32,
+			subDt: f32,
+			stiffness: f32,
+			dampFactor: f32,
+			radius: f32,
+			aspect: f32
 		})), "springParams");
 		let curW = Math.max(1, Math.round(dimensions.width));
 		let curH = Math.max(1, Math.round(dimensions.height));

package/dist/core/{MagneticFilings-CQ7zHEow.js → MagneticFilings-DAOFLjAQ.js}

@@ -1,5 +1,8 @@
-import { Bt as ZERO, J as std, Tn as d, X as createGuardedCompute, Z as createStateBuffer, c as orientedShapeOptions, ct as hash22, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, ot as hash11, pt as noise_exports, r as AGENT_SHAPES, s as makeAgentWeightFn, u as resolveAgentShape } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Ct as floor, Et as max, Gt as textureStorage2d, H as mixColorsLinear, Ht as atomic, It as sin, Tt as length, U as mixColorsVariants, Ut as arrayOf, Vt as data_exports, Xt as struct, _t as clamp, an as f32, at as textureStore, bt as dot, d as ZERO, dt as atomicStore, et as src_default, gt as atan2, in as vec4f, lt as atomicAdd, mt as abs, nt as std_exports, on as i32, pt as select, sn as u32, tn as vec2u, ut as atomicLoad, vt as cos, xt as exp } from "./edges-BXNBKxSN.js";
+import { c as hash22, o as hash11, p as noise_exports } from "./noise-wTSHXgFz.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { a as makeAgentWeightFn, c as resolveAgentShape, o as orientedShapeOptions, t as AGENT_SHAPES } from "./agents-Bv3--qPL.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var MAX_FILINGS = 12288;
 var RES = 1024;
 var INV_RES = 1 / RES;
@@ -21,68 +24,68 @@ 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
+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))(tgpu.bindGroupLayout({
+var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	filings: {
-		storage: d.arrayOf(d.vec4f, MAX_FILINGS),
+		storage: arrayOf(vec4f, MAX_FILINGS),
 		access: "mutable"
 	},
 	agit: {
-		storage: d.arrayOf(d.f32, MAX_FILINGS),
+		storage: arrayOf(f32, MAX_FILINGS),
 		access: "mutable"
 	},
 	accumE: {
-		storage: d.arrayOf(d.atomic(d.u32), RES * RES),
+		storage: arrayOf(atomic(u32), RES * RES),
 		access: "mutable"
 	},
 	accumS: {
-		storage: d.arrayOf(d.atomic(d.u32), RES * RES),
+		storage: arrayOf(atomic(u32), RES * RES),
 		access: "mutable"
 	},
 	params: { uniform: SimParams },
-	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	outTex: { storageTexture: 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) => {
+var homeFn = src_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 = 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 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 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));
+	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: 1,
 	name: void 0,
@@ -296,17 +299,15 @@ var homeFn = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		noise: noise_exports,
-		d,
+		d: data_exports,
 		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) => {
+var restAngleFn = src_default.fn([f32, f32], 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);
+	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: 1,
 	name: void 0,
@@ -407,17 +408,17 @@ var restAngleFn = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (global
 	externals: () => ({
 		noise: noise_exports,
 		PI,
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		HALF_PI
 	})
 }) && $.f)({})).$name("filingsRestAngle");
-const filingsInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+const filingsInitKernel = src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 	"use gpu";
-	const fi = d.f32(i);
+	const fi = 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);
+	simLayout.$.filings[i] = vec4f(f32(0), f32(0), theta0, f32(0));
+	simLayout.$.agit[i] = f32(0);
 }), {
 	v: 1,
 	name: void 0,
@@ -558,17 +559,17 @@ const filingsInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis._
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		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) => {
+const filingsClearAccumKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(y, d.u32(RES)), x);
-	std.atomicStore(simLayout.$.accumE[idx], d.u32(0));
-	std.atomicStore(simLayout.$.accumS[idx], d.u32(0));
+	const idx = __tsover_add(__tsover_mul(y, u32(RES)), x);
+	atomicStore(simLayout.$.accumE[idx], u32(0));
+	atomicStore(simLayout.$.accumS[idx], u32(0));
 }), {
 	v: 1,
 	name: void 0,
@@ -671,9 +672,9 @@ const filingsClearAccumKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) =>
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		RES,
-		std,
+		std: std_exports,
 		simLayout
 	})
 }) && $.f)({})).$name("filingsClearAccum");
@@ -684,34 +685,34 @@ function makeFilingsSplatKernel(shape) {
 	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) => {
+	return src_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(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 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 = 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 dir = vec2f(cos(theta), sin(theta));
+		const agitI = clamp(simLayout.$.agit[i], 0, 1);
+		const bodyR = 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));
+		const txf = __tsover_mul(__tsover_div(pos.x, max(prm.aspect, 1e-5)), f32(RES));
+		const tyf = __tsover_mul(pos.y, f32(RES));
+		const cxi = i32(floor(txf));
+		const cyi = i32(floor(tyf));
 		for (let ky = 0; ky < SPLAT_WIN; ky++) for (let kx = 0; kx < SPLAT_WIN; kx++) {
 			const px = __tsover_sub(__tsover_add(cxi, kx), SPLAT_R);
 			const py = __tsover_sub(__tsover_add(cyi, ky), SPLAT_R);
 			if (px >= 0 && px < RES && py >= 0 && py < RES) {
-				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(d.f32(px), .5), INV_RES), prm.aspect), pos.x);
-				const offY = __tsover_sub(__tsover_mul(__tsover_add(d.f32(py), .5), INV_RES), pos.y);
+				const offX = __tsover_sub(__tsover_mul(__tsover_mul(__tsover_add(f32(px), .5), INV_RES), prm.aspect), pos.x);
+				const offY = __tsover_sub(__tsover_mul(__tsover_add(f32(py), .5), INV_RES), pos.y);
 				if (__tsover_add(__tsover_mul(offX, offX), __tsover_mul(offY, offY)) < extSq) {
-					const 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))));
+					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, f32(SOFT));
+					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);
+						atomicAdd(simLayout.$.accumS[idx], u32(__tsover_mul(__tsover_mul(w, agitI), f32(GAIN))));
 					}
 				}
 			}
@@ -1509,8 +1510,8 @@ function makeFilingsSplatKernel(shape) {
 		externals: () => ({
 			simLayout,
 			homeFn,
-			d,
-			std,
+			d: data_exports,
+			std: std_exports,
 			EXT,
 			AA_W,
 			RES,
@@ -1526,17 +1527,17 @@ function makeFilingsSplatKernel(shape) {
 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) => {
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
 		"use gpu";
 		const prm = simLayout.$.params;
-		const idx = __tsover_add(__tsover_mul(y, d.u32(RES)), x);
-		const eRaw = d.f32(std.atomicLoad(simLayout.$.accumE[idx]));
-		const sRaw = d.f32(std.atomicLoad(simLayout.$.accumS[idx]));
+		const idx = __tsover_add(__tsover_mul(y, u32(RES)), x);
+		const eRaw = f32(atomicLoad(simLayout.$.accumE[idx]));
+		const sRaw = f32(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));
+		const agitAvg = __tsover_div(sRaw, max(eRaw, 1));
+		const col = mixFn(prm.colA, prm.colB, clamp(agitAvg, 0, 1));
+		const a = __tsover_mul(__tsover_sub(1, exp(__tsover_mul(energy, -1.6))), col.w);
+		textureStore(simLayout.$.outTex, vec2u(x, y), vec4f(col.x, col.y, col.z, a));
 	}), {
 		v: 1,
 		name: void 0,
@@ -1818,50 +1819,49 @@ function makeFilingsResolveKernel(colorSpaceMode) {
 		},
 		externals: () => ({
 			simLayout,
-			d,
+			d: data_exports,
 			RES,
-			std,
+			std: std_exports,
 			mixFn
 		})
 	}) && $.f)({})).$name("filingsResolve");
 }
 const filingsResolveKernel = makeFilingsResolveKernel(2);
-const filingsUpdateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+const filingsUpdateKernel = src_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 = d.vec2f(st.x, st.y);
+	let off = vec2f(st.x, st.y);
 	let theta = st.z;
 	let omega = st.w;
 	const dt = prm.dt;
-	const fi = d.f32(i);
+	const fi = 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 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 = std.max(std.length(delta), 1e-4);
+	const r = max(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 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), std.sin(__tsover_mul(2, __tsover_sub(phiField, theta))));
-	const torqueRest = __tsover_mul(prm.restK, std.sin(__tsover_mul(2, __tsover_sub(restAngle, theta))));
+	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, std.exp(__tsover_mul(__tsover_mul(prm.damping, dt), -1)));
+	omega = __tsover_mul(omega, 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 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(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);
+	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: 1,
 	name: void 0,
@@ -2731,9 +2731,9 @@ const filingsUpdateKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis
 	},
 	externals: () => ({
 		simLayout,
-		d,
+		d: data_exports,
 		homeFn,
-		std,
+		std: std_exports,
 		restAngleFn,
 		MAX_OFFSET
 	})
@@ -2894,10 +2894,10 @@ const componentDefinition = {
 		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 filings = createStateBuffer(root, vec4f, MAX_FILINGS);
+		const agitBuf = createStateBuffer(root, f32, MAX_FILINGS);
+		const accumE = createStateBuffer(root, atomic(u32), RES * RES);
+		const accumS = createStateBuffer(root, atomic(u32), RES * RES);
 		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [RES, RES],
 			format: STATE_FORMAT
@@ -3071,8 +3071,8 @@ const componentDefinition = {
 				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),
+					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,