shaders 3.0.447 → 3.0.449

package/dist/core/{ParticleField-q7COY9YT.js → ParticleField-DDO-Tk9X.js}

@@ -1,4 +1,8 @@
-import { Bt as ZERO, J as std, Tn as d, X as createGuardedCompute, Z as createStateBuffer, a as cursorFalloff, i as agents_exports, l as pointShapeOptions, n as tgpu, o as cursorMagnet, pt as noise_exports, r as AGENT_SHAPES, s as makeAgentWeightFn, st as hash12, u as resolveAgentShape, x as isMobileGpuViewport } from "./coords-BkIjixe_.js";
+import { $t as vec2f, Ct as floor, Dt as min, Et as max, Gt as textureStorage2d, Ht as atomic, It as sin, Lt as smoothstep, Ot as mix, Tt as length, Ut as arrayOf, Vt as data_exports, Wt as texture2d, 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, in as vec4f, it as textureLoad, lt as atomicAdd, nn as vec3f, nt as std_exports, on as i32, pt as select, rt as textureDimensions, sn as u32, tn as vec2u, ut as atomicLoad, vt as cos, xt as exp } from "./edges-BXNBKxSN.js";
+import { p as noise_exports, s as hash12 } from "./noise-wTSHXgFz.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { t as isMobileGpuViewport } from "./device-BODv_4aH.js";
+import { a as makeAgentWeightFn, c as resolveAgentShape, i as cursorMagnet, n as agents_exports, r as cursorFalloff, s as pointShapeOptions, t as AGENT_SHAPES } from "./agents-Bv3--qPL.js";
 var GRID_DIM_MAX = 256;
 var MAX_PARTICLES = GRID_DIM_MAX * GRID_DIM_MAX;
 var COUNT_MAX = 4e4;
@@ -17,69 +21,69 @@ var DRAG = 4.2;
 var MAX_SPEED = 4;
 var CURSOR_FORCE_K = 10;
 var CURSOR_ZFORCE_K = 4;
-var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	rowX: d.vec4f,
-	rowY: d.vec4f,
-	rowZ: d.vec4f,
-	dt: d.f32,
-	time: d.f32,
-	snap: d.f32,
-	gridW: d.f32,
-	gridH: d.f32,
-	outW: d.f32,
-	outH: d.f32,
-	depth: d.f32,
-	dragMul: d.f32,
-	wobbleAmp: d.f32,
-	depthShading: d.f32,
-	spacing: d.f32,
-	particleSize: d.f32,
-	aspect: d.f32,
-	zoom: d.f32,
-	transX: d.f32,
-	transY: d.f32,
-	pointerX: d.f32,
-	pointerY: d.f32,
-	cursorForce: d.f32,
-	cursorZForce: d.f32,
-	cursorRadSq: d.f32
+var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	rowX: vec4f,
+	rowY: vec4f,
+	rowZ: vec4f,
+	dt: f32,
+	time: f32,
+	snap: f32,
+	gridW: f32,
+	gridH: f32,
+	outW: f32,
+	outH: f32,
+	depth: f32,
+	dragMul: f32,
+	wobbleAmp: f32,
+	depthShading: f32,
+	spacing: f32,
+	particleSize: f32,
+	aspect: f32,
+	zoom: f32,
+	transX: f32,
+	transY: f32,
+	pointerX: f32,
+	pointerY: f32,
+	cursorForce: f32,
+	cursorZForce: f32,
+	cursorRadSq: f32
 }), "SimParams");
-var fieldLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var fieldLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	pos: {
-		storage: d.arrayOf(d.vec4f, MAX_PARTICLES),
+		storage: arrayOf(vec4f, MAX_PARTICLES),
 		access: "mutable"
 	},
 	vel: {
-		storage: d.arrayOf(d.vec4f, MAX_PARTICLES),
+		storage: arrayOf(vec4f, MAX_PARTICLES),
 		access: "mutable"
 	},
 	col: {
-		storage: d.arrayOf(d.vec4f, MAX_PARTICLES),
+		storage: arrayOf(vec4f, MAX_PARTICLES),
 		access: "mutable"
 	},
 	accumR: {
-		storage: d.arrayOf(d.atomic(d.u32), OUT_CELLS),
+		storage: arrayOf(atomic(u32), OUT_CELLS),
 		access: "mutable"
 	},
 	accumG: {
-		storage: d.arrayOf(d.atomic(d.u32), OUT_CELLS),
+		storage: arrayOf(atomic(u32), OUT_CELLS),
 		access: "mutable"
 	},
 	accumB: {
-		storage: d.arrayOf(d.atomic(d.u32), OUT_CELLS),
+		storage: arrayOf(atomic(u32), OUT_CELLS),
 		access: "mutable"
 	},
 	accumW: {
-		storage: d.arrayOf(d.atomic(d.u32), OUT_CELLS),
+		storage: arrayOf(atomic(u32), OUT_CELLS),
 		access: "mutable"
 	},
 	params: { uniform: SimParams },
-	src: { texture: d.texture2d(d.f32) },
-	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	src: { texture: texture2d(f32) },
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "fieldLayout");
-var channelLuminance = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+var channelLuminance = src_default.fn([vec3f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
 	"use gpu";
-	return std.dot(rgb, d.vec3f(.299, .587, .114));
+	return dot(rgb, vec3f(.299, .587, .114));
 }), {
 	v: 1,
 	name: void 0,
@@ -115,13 +119,13 @@ var channelLuminance = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) =>
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-var channelLuminanceInv = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+var channelLuminanceInv = src_default.fn([vec3f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
 	"use gpu";
-	return __tsover_sub(1, std.dot(rgb, d.vec3f(.299, .587, .114)));
+	return __tsover_sub(1, dot(rgb, vec3f(.299, .587, .114)));
 }), {
 	v: 1,
 	name: void 0,
@@ -162,11 +166,11 @@ var channelLuminanceInv = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($)
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-var channelRed = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+var channelRed = src_default.fn([vec3f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
 	"use gpu";
 	return rgb.x;
 }), {
@@ -189,7 +193,7 @@ var channelRed = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globa
 	},
 	externals: () => ({})
 }) && $.f)({}));
-var channelGreen = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+var channelGreen = src_default.fn([vec3f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
 	"use gpu";
 	return rgb.y;
 }), {
@@ -212,7 +216,7 @@ var channelGreen = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (glo
 	},
 	externals: () => ({})
 }) && $.f)({}));
-var channelBlue = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+var channelBlue = src_default.fn([vec3f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
 	"use gpu";
 	return rgb.z;
 }), {
@@ -235,10 +239,10 @@ var channelBlue = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (glob
 	},
 	externals: () => ({})
 }) && $.f)({}));
-var channelSaturation = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
+var channelSaturation = src_default.fn([vec3f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rgb, _a) => {
 	"use gpu";
-	const mx = std.max(std.max(rgb.x, rgb.y), rgb.z);
-	const mn = std.min(std.min(rgb.x, rgb.y), rgb.z);
+	const mx = max(max(rgb.x, rgb.y), rgb.z);
+	const mn = min(min(rgb.x, rgb.y), rgb.z);
 	return __tsover_sub(mx, mn);
 }), {
 	v: 1,
@@ -327,9 +331,9 @@ var channelSaturation = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) =>
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-var channelAlpha = tgpu.fn([d.vec3f, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((_rgb, a) => {
+var channelAlpha = src_default.fn([vec3f, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((_rgb, a) => {
 	"use gpu";
 	return a;
 }), {
@@ -366,13 +370,13 @@ var DEPTH_SOURCE_MODES = {
 	saturation: 5,
 	alpha: 6
 };
-const particleFieldClearKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+const particleFieldClearKernel = 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(fieldLayout.$.params.outW)), x);
-	std.atomicStore(fieldLayout.$.accumR[idx], d.u32(0));
-	std.atomicStore(fieldLayout.$.accumG[idx], d.u32(0));
-	std.atomicStore(fieldLayout.$.accumB[idx], d.u32(0));
-	std.atomicStore(fieldLayout.$.accumW[idx], d.u32(0));
+	const idx = __tsover_add(__tsover_mul(y, u32(fieldLayout.$.params.outW)), x);
+	atomicStore(fieldLayout.$.accumR[idx], u32(0));
+	atomicStore(fieldLayout.$.accumG[idx], u32(0));
+	atomicStore(fieldLayout.$.accumB[idx], u32(0));
+	atomicStore(fieldLayout.$.accumW[idx], u32(0));
 }), {
 	v: 1,
 	name: void 0,
@@ -544,71 +548,71 @@ const particleFieldClearKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) =>
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		fieldLayout,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("particleFieldClear");
 function makeParticleFieldSimKernel(channelMode) {
 	const channelFn = channelFns[channelMode] ?? channelLuminance;
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
 		"use gpu";
 		const P = fieldLayout.$.params;
-		const i = __tsover_add(__tsover_mul(gy, d.u32(P.gridW)), gx);
-		const homeU = __tsover_div(__tsover_add(d.f32(gx), .5), P.gridW);
-		const homeV = __tsover_div(__tsover_add(d.f32(gy), .5), P.gridH);
-		const dims = std.textureDimensions(fieldLayout.$.src);
-		const sw = d.f32(dims.x);
-		const sh = d.f32(dims.y);
+		const i = __tsover_add(__tsover_mul(gy, u32(P.gridW)), gx);
+		const homeU = __tsover_div(__tsover_add(f32(gx), .5), P.gridW);
+		const homeV = __tsover_div(__tsover_add(f32(gy), .5), P.gridH);
+		const dims = textureDimensions(fieldLayout.$.src);
+		const sw = f32(dims.x);
+		const sh = f32(dims.y);
 		const cu = __tsover_sub(__tsover_mul(homeU, sw), .5);
 		const cv = __tsover_sub(__tsover_mul(homeV, sh), .5);
-		const cx0 = std.floor(cu);
-		const cy0 = std.floor(cv);
+		const cx0 = floor(cu);
+		const cy0 = floor(cv);
 		const fx = __tsover_sub(cu, cx0);
 		const fy = __tsover_sub(cv, cy0);
-		const ix0 = d.u32(std.clamp(cx0, d.f32(0), __tsover_sub(sw, 1)));
-		const ix1 = d.u32(std.clamp(__tsover_add(cx0, 1), d.f32(0), __tsover_sub(sw, 1)));
-		const iy0 = d.u32(std.clamp(cy0, d.f32(0), __tsover_sub(sh, 1)));
-		const iy1 = d.u32(std.clamp(__tsover_add(cy0, 1), d.f32(0), __tsover_sub(sh, 1)));
-		const c00 = std.textureLoad(fieldLayout.$.src, d.vec2u(ix0, iy0), 0);
-		const c10 = std.textureLoad(fieldLayout.$.src, d.vec2u(ix1, iy0), 0);
-		const c01 = std.textureLoad(fieldLayout.$.src, d.vec2u(ix0, iy1), 0);
-		const c11 = std.textureLoad(fieldLayout.$.src, d.vec2u(ix1, iy1), 0);
-		const prem = std.mix(std.mix(c00, c10, fx), std.mix(c01, c11, fx), fy);
+		const ix0 = u32(clamp(cx0, f32(0), __tsover_sub(sw, 1)));
+		const ix1 = u32(clamp(__tsover_add(cx0, 1), f32(0), __tsover_sub(sw, 1)));
+		const iy0 = u32(clamp(cy0, f32(0), __tsover_sub(sh, 1)));
+		const iy1 = u32(clamp(__tsover_add(cy0, 1), f32(0), __tsover_sub(sh, 1)));
+		const c00 = textureLoad(fieldLayout.$.src, vec2u(ix0, iy0), 0);
+		const c10 = textureLoad(fieldLayout.$.src, vec2u(ix1, iy0), 0);
+		const c01 = textureLoad(fieldLayout.$.src, vec2u(ix0, iy1), 0);
+		const c11 = textureLoad(fieldLayout.$.src, vec2u(ix1, iy1), 0);
+		const prem = mix(mix(c00, c10, fx), mix(c01, c11, fx), fy);
 		const a = prem.w;
-		const rgb = prem.xyz.div(std.max(a, d.f32(1e-4)));
-		fieldLayout.$.col[i] = d.vec4f(rgb.x, rgb.y, rgb.z, a);
+		const rgb = prem.xyz.div(max(a, f32(1e-4)));
+		fieldLayout.$.col[i] = vec4f(rgb.x, rgb.y, rgb.z, a);
 		const ch = channelFn(rgb, a);
 		const targetZ = __tsover_mul(__tsover_sub(ch, .5), P.depth);
 		const p4 = fieldLayout.$.pos[i];
 		const v4 = fieldLayout.$.vel[i];
 		const dt = P.dt;
 		const firstFrame = P.snap > .5;
-		const homeW = d.vec2f(__tsover_mul(__tsover_sub(homeU, .5), P.aspect), __tsover_sub(homeV, .5));
-		const off = d.vec2f(p4.x, p4.y);
-		const pw = d.vec3f(__tsover_add(homeW.x, off.x), __tsover_add(homeW.y, off.y), p4.z);
+		const homeW = vec2f(__tsover_mul(__tsover_sub(homeU, .5), P.aspect), __tsover_sub(homeV, .5));
+		const off = vec2f(p4.x, p4.y);
+		const pw = vec3f(__tsover_add(homeW.x, off.x), __tsover_add(homeW.y, off.y), p4.z);
 		const rxv = __tsover_add(__tsover_add(__tsover_mul(P.rowX.x, pw.x), __tsover_mul(P.rowX.y, pw.y)), __tsover_mul(P.rowX.z, pw.z));
 		const ryv = __tsover_add(__tsover_add(__tsover_mul(P.rowY.x, pw.x), __tsover_mul(P.rowY.y, pw.y)), __tsover_mul(P.rowY.z, pw.z));
 		const rzv = __tsover_add(__tsover_add(__tsover_mul(P.rowZ.x, pw.x), __tsover_mul(P.rowZ.y, pw.y)), __tsover_mul(P.rowZ.z, pw.z));
-		const persp = __tsover_div(P.zoom, std.clamp(__tsover_sub(1, __tsover_mul(rzv, PERSP_K)), .35, 2.6));
+		const persp = __tsover_div(P.zoom, clamp(__tsover_sub(1, __tsover_mul(rzv, PERSP_K)), .35, 2.6));
 		const su = __tsover_add(__tsover_add(.5, __tsover_div(__tsover_mul(rxv, persp), P.aspect)), P.transX);
 		const sv = __tsover_add(__tsover_add(.5, __tsover_mul(ryv, persp)), P.transY);
-		const deltaS = d.vec2f(__tsover_mul(__tsover_sub(su, P.pointerX), P.aspect), __tsover_sub(sv, P.pointerY));
+		const deltaS = vec2f(__tsover_mul(__tsover_sub(su, P.pointerX), P.aspect), __tsover_sub(sv, P.pointerY));
 		const mxy = cursorMagnet(deltaS, P.cursorRadSq, P.cursorForce);
 		const mz = __tsover_mul(cursorFalloff(deltaS, P.cursorRadSq), P.cursorZForce);
-		const cf = d.vec3f(__tsover_add(__tsover_add(__tsover_mul(P.rowX.x, mxy.x), __tsover_mul(P.rowY.x, mxy.y)), __tsover_mul(P.rowZ.x, mz)), __tsover_add(__tsover_add(__tsover_mul(P.rowX.y, mxy.x), __tsover_mul(P.rowY.y, mxy.y)), __tsover_mul(P.rowZ.y, mz)), __tsover_add(__tsover_add(__tsover_mul(P.rowX.z, mxy.x), __tsover_mul(P.rowY.z, mxy.y)), __tsover_mul(P.rowZ.z, mz)));
-		const F = d.vec3f(__tsover_mul(off.x, -STIFF), __tsover_mul(off.y, -STIFF), __tsover_mul(__tsover_sub(targetZ, p4.z), STIFF)).add(cf);
-		let v3 = d.vec3f(v4.x, v4.y, v4.z).add(F.mul(dt)).mul(P.dragMul);
-		const spd = std.length(v3);
-		v3 = v3.mul(__tsover_div(std.min(spd, d.f32(MAX_SPEED)), std.max(spd, 1e-5)));
-		let offN = off.add(d.vec2f(v3.x, v3.y).mul(dt));
+		const cf = vec3f(__tsover_add(__tsover_add(__tsover_mul(P.rowX.x, mxy.x), __tsover_mul(P.rowY.x, mxy.y)), __tsover_mul(P.rowZ.x, mz)), __tsover_add(__tsover_add(__tsover_mul(P.rowX.y, mxy.x), __tsover_mul(P.rowY.y, mxy.y)), __tsover_mul(P.rowZ.y, mz)), __tsover_add(__tsover_add(__tsover_mul(P.rowX.z, mxy.x), __tsover_mul(P.rowY.z, mxy.y)), __tsover_mul(P.rowZ.z, mz)));
+		const F = vec3f(__tsover_mul(off.x, -STIFF), __tsover_mul(off.y, -STIFF), __tsover_mul(__tsover_sub(targetZ, p4.z), STIFF)).add(cf);
+		let v3 = vec3f(v4.x, v4.y, v4.z).add(F.mul(dt)).mul(P.dragMul);
+		const spd = length(v3);
+		v3 = v3.mul(__tsover_div(min(spd, f32(MAX_SPEED)), max(spd, 1e-5)));
+		let offN = off.add(vec2f(v3.x, v3.y).mul(dt));
 		let curZ = __tsover_add(p4.z, __tsover_mul(v3.z, dt));
-		offN = std.select(offN, d.vec2f(0, 0), firstFrame);
-		curZ = std.select(curZ, targetZ, firstFrame);
-		v3 = std.select(v3, d.vec3f(0, 0, 0), firstFrame);
-		const seed = hash12(d.vec2f(__tsover_add(d.f32(gx), .5), __tsover_add(d.f32(gy), .5)));
-		fieldLayout.$.pos[i] = d.vec4f(offN.x, offN.y, curZ, seed);
-		fieldLayout.$.vel[i] = d.vec4f(v3.x, v3.y, v3.z, 0);
+		offN = select(offN, vec2f(0, 0), firstFrame);
+		curZ = select(curZ, targetZ, firstFrame);
+		v3 = select(v3, vec3f(0, 0, 0), firstFrame);
+		const seed = hash12(vec2f(__tsover_add(f32(gx), .5), __tsover_add(f32(gy), .5)));
+		fieldLayout.$.pos[i] = vec4f(offN.x, offN.y, curZ, seed);
+		fieldLayout.$.vel[i] = vec4f(v3.x, v3.y, v3.z, 0);
 	}), {
 		v: 1,
 		name: void 0,
@@ -2477,8 +2481,8 @@ function makeParticleFieldSimKernel(channelMode) {
 		},
 		externals: () => ({
 			fieldLayout,
-			d,
-			std,
+			d: data_exports,
+			std: std_exports,
 			channelFn,
 			PERSP_K,
 			agents: agents_exports,
@@ -2494,55 +2498,55 @@ function makeParticleFieldSplatKernel(shape) {
 	const weightFn = makeAgentWeightFn(name);
 	const SOFT = s.soft;
 	const EXTQ = s.ext * s.ext + .75;
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
 		"use gpu";
 		const P = fieldLayout.$.params;
-		const i = __tsover_add(__tsover_mul(gy, d.u32(P.gridW)), gx);
+		const i = __tsover_add(__tsover_mul(gy, u32(P.gridW)), gx);
 		const p4 = fieldLayout.$.pos[i];
 		const col = fieldLayout.$.col[i];
 		const childA = col.w;
-		const homeU = __tsover_div(__tsover_add(d.f32(gx), .5), P.gridW);
-		const homeV = __tsover_div(__tsover_add(d.f32(gy), .5), P.gridH);
+		const homeU = __tsover_div(__tsover_add(f32(gx), .5), P.gridW);
+		const homeV = __tsover_div(__tsover_add(f32(gy), .5), P.gridH);
 		const ph = __tsover_mul(p4.w, TAU);
 		const wob = P.wobbleAmp;
-		const wx = __tsover_mul(__tsover_mul(std.sin(__tsover_add(__tsover_mul(P.time, WOBBLE_FREQ), ph)), wob), .012);
-		const wy = __tsover_mul(__tsover_mul(std.cos(__tsover_add(__tsover_mul(__tsover_mul(P.time, WOBBLE_FREQ), 1.13), __tsover_mul(ph, 1.7))), wob), .012);
-		const wz = __tsover_mul(__tsover_mul(std.sin(__tsover_add(__tsover_mul(__tsover_mul(P.time, WOBBLE_FREQ), .87), __tsover_mul(ph, 2.3))), wob), .06);
-		const pw = d.vec3f(__tsover_add(__tsover_add(__tsover_mul(__tsover_sub(homeU, .5), P.aspect), p4.x), wx), __tsover_add(__tsover_add(__tsover_sub(homeV, .5), p4.y), wy), __tsover_add(p4.z, wz));
+		const wx = __tsover_mul(__tsover_mul(sin(__tsover_add(__tsover_mul(P.time, WOBBLE_FREQ), ph)), wob), .012);
+		const wy = __tsover_mul(__tsover_mul(cos(__tsover_add(__tsover_mul(__tsover_mul(P.time, WOBBLE_FREQ), 1.13), __tsover_mul(ph, 1.7))), wob), .012);
+		const wz = __tsover_mul(__tsover_mul(sin(__tsover_add(__tsover_mul(__tsover_mul(P.time, WOBBLE_FREQ), .87), __tsover_mul(ph, 2.3))), wob), .06);
+		const pw = vec3f(__tsover_add(__tsover_add(__tsover_mul(__tsover_sub(homeU, .5), P.aspect), p4.x), wx), __tsover_add(__tsover_add(__tsover_sub(homeV, .5), p4.y), wy), __tsover_add(p4.z, wz));
 		const rx = __tsover_add(__tsover_add(__tsover_mul(P.rowX.x, pw.x), __tsover_mul(P.rowX.y, pw.y)), __tsover_mul(P.rowX.z, pw.z));
 		const ry = __tsover_add(__tsover_add(__tsover_mul(P.rowY.x, pw.x), __tsover_mul(P.rowY.y, pw.y)), __tsover_mul(P.rowY.z, pw.z));
 		const rz = __tsover_add(__tsover_add(__tsover_mul(P.rowZ.x, pw.x), __tsover_mul(P.rowZ.y, pw.y)), __tsover_mul(P.rowZ.z, pw.z));
-		const persp0 = __tsover_div(1, std.clamp(__tsover_sub(1, __tsover_mul(rz, PERSP_K)), .35, 2.6));
+		const persp0 = __tsover_div(1, clamp(__tsover_sub(1, __tsover_mul(rz, PERSP_K)), .35, 2.6));
 		const persp = __tsover_mul(persp0, P.zoom);
 		const su = __tsover_add(__tsover_add(.5, __tsover_div(__tsover_mul(rx, persp), P.aspect)), P.transX);
 		const sv = __tsover_add(__tsover_add(.5, __tsover_mul(ry, persp)), P.transY);
 		const tx = __tsover_mul(su, P.outW);
 		const ty = __tsover_mul(sv, P.outH);
-		const dotR = std.clamp(__tsover_mul(__tsover_mul(__tsover_mul(P.particleSize, P.spacing), .5), persp), .5, d.f32(SPLAT_R));
-		const dr = std.max(P.depth, .001);
-		const near = std.smoothstep(__tsover_mul(dr, -1), dr, rz);
-		const shade = std.mix(d.f32(1), __tsover_add(.35, __tsover_mul(.65, near)), P.depthShading);
+		const dotR = clamp(__tsover_mul(__tsover_mul(__tsover_mul(P.particleSize, P.spacing), .5), persp), .5, f32(SPLAT_R));
+		const dr = max(P.depth, .001);
+		const near = smoothstep(__tsover_mul(dr, -1), dr, rz);
+		const shade = mix(f32(1), __tsover_add(.35, __tsover_mul(.65, near)), P.depthShading);
 		const depthWeight = __tsover_mul(__tsover_mul(persp0, persp0), shade);
-		const owI = d.i32(P.outW);
-		const ohI = d.i32(P.outH);
-		const owU = d.u32(P.outW);
-		const cxi = d.i32(std.floor(tx));
-		const cyi = d.i32(std.floor(ty));
+		const owI = i32(P.outW);
+		const ohI = i32(P.outH);
+		const owU = u32(P.outW);
+		const cxi = i32(floor(tx));
+		const cyi = i32(floor(ty));
 		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 < owI && py >= 0 && py < ohI) {
-				const ddx = __tsover_sub(__tsover_add(d.f32(px), .5), tx);
-				const ddy = __tsover_sub(__tsover_add(d.f32(py), .5), ty);
-				if (__tsover_div(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)), std.max(__tsover_mul(dotR, dotR), .01)) < d.f32(EXTQ)) {
-					const w = weightFn(ddx, ddy, dotR, .75, d.f32(SOFT));
+				const ddx = __tsover_sub(__tsover_add(f32(px), .5), tx);
+				const ddy = __tsover_sub(__tsover_add(f32(py), .5), ty);
+				if (__tsover_div(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)), max(__tsover_mul(dotR, dotR), .01)) < f32(EXTQ)) {
+					const w = weightFn(ddx, ddy, dotR, .75, f32(SOFT));
 					const wc = __tsover_mul(__tsover_mul(w, childA), depthWeight);
 					if (wc > 0) {
-						const idx = __tsover_add(__tsover_mul(d.u32(py), owU), d.u32(px));
-						std.atomicAdd(fieldLayout.$.accumR[idx], d.u32(__tsover_mul(__tsover_mul(col.x, wc), FP)));
-						std.atomicAdd(fieldLayout.$.accumG[idx], d.u32(__tsover_mul(__tsover_mul(col.y, wc), FP)));
-						std.atomicAdd(fieldLayout.$.accumB[idx], d.u32(__tsover_mul(__tsover_mul(col.z, wc), FP)));
-						std.atomicAdd(fieldLayout.$.accumW[idx], d.u32(__tsover_mul(wc, FP)));
+						const idx = __tsover_add(__tsover_mul(u32(py), owU), u32(px));
+						atomicAdd(fieldLayout.$.accumR[idx], u32(__tsover_mul(__tsover_mul(col.x, wc), FP)));
+						atomicAdd(fieldLayout.$.accumG[idx], u32(__tsover_mul(__tsover_mul(col.y, wc), FP)));
+						atomicAdd(fieldLayout.$.accumB[idx], u32(__tsover_mul(__tsover_mul(col.z, wc), FP)));
+						atomicAdd(fieldLayout.$.accumW[idx], u32(__tsover_mul(wc, FP)));
 					}
 				}
 			}
@@ -3965,9 +3969,9 @@ function makeParticleFieldSplatKernel(shape) {
 		},
 		externals: () => ({
 			fieldLayout,
-			d,
+			d: data_exports,
 			TAU,
-			std,
+			std: std_exports,
 			WOBBLE_FREQ,
 			PERSP_K,
 			SPLAT_R,
@@ -3980,20 +3984,20 @@ function makeParticleFieldSplatKernel(shape) {
 	}) && $.f)({})).$name("particleFieldSplat");
 }
 const particleFieldSplatKernel = makeParticleFieldSplatKernel("dot");
-const particleFieldResolveKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+const particleFieldResolveKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
 	"use gpu";
 	const P = fieldLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(y, d.u32(P.outW)), x);
-	const wRaw = d.f32(std.atomicLoad(fieldLayout.$.accumW[idx]));
-	const rRaw = d.f32(std.atomicLoad(fieldLayout.$.accumR[idx]));
-	const gRaw = d.f32(std.atomicLoad(fieldLayout.$.accumG[idx]));
-	const bRaw = d.f32(std.atomicLoad(fieldLayout.$.accumB[idx]));
-	const denom = std.max(wRaw, d.f32(1));
+	const idx = __tsover_add(__tsover_mul(y, u32(P.outW)), x);
+	const wRaw = f32(atomicLoad(fieldLayout.$.accumW[idx]));
+	const rRaw = f32(atomicLoad(fieldLayout.$.accumR[idx]));
+	const gRaw = f32(atomicLoad(fieldLayout.$.accumG[idx]));
+	const bRaw = f32(atomicLoad(fieldLayout.$.accumB[idx]));
+	const denom = max(wRaw, f32(1));
 	const r = __tsover_div(rRaw, denom);
 	const g = __tsover_div(gRaw, denom);
 	const b = __tsover_div(bRaw, denom);
-	const alpha = __tsover_sub(1, std.exp(__tsover_mul(__tsover_mul(wRaw, __tsover_div(1, FP)), -ALPHA_K)));
-	std.textureStore(fieldLayout.$.outTex, d.vec2u(x, y), d.vec4f(r, g, b, alpha));
+	const alpha = __tsover_sub(1, exp(__tsover_mul(__tsover_mul(wRaw, __tsover_div(1, FP)), -ALPHA_K)));
+	textureStore(fieldLayout.$.outTex, vec2u(x, y), vec4f(r, g, b, alpha));
 }), {
 	v: 1,
 	name: void 0,
@@ -4319,8 +4323,8 @@ const particleFieldResolveKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($)
 	},
 	externals: () => ({
 		fieldLayout,
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		FP,
 		ALPHA_K
 	})
@@ -4576,13 +4580,13 @@ const componentDefinition = {
 		let OUT_H = OUT_MAX;
 		if (aspect0 >= 1) OUT_H = Math.max(Math.round(OUT_MAX / aspect0), 1);
 		else OUT_W = Math.max(Math.round(OUT_MAX * aspect0), 1);
-		const posBuf = createStateBuffer(root, d.vec4f, MAX_PARTICLES);
-		const velBuf = createStateBuffer(root, d.vec4f, MAX_PARTICLES);
-		const colBuf = createStateBuffer(root, d.vec4f, MAX_PARTICLES);
-		const accumR = createStateBuffer(root, d.atomic(d.u32), OUT_CELLS);
-		const accumG = createStateBuffer(root, d.atomic(d.u32), OUT_CELLS);
-		const accumB = createStateBuffer(root, d.atomic(d.u32), OUT_CELLS);
-		const accumW = createStateBuffer(root, d.atomic(d.u32), OUT_CELLS);
+		const posBuf = createStateBuffer(root, vec4f, MAX_PARTICLES);
+		const velBuf = createStateBuffer(root, vec4f, MAX_PARTICLES);
+		const colBuf = createStateBuffer(root, vec4f, MAX_PARTICLES);
+		const accumR = createStateBuffer(root, atomic(u32), OUT_CELLS);
+		const accumG = createStateBuffer(root, atomic(u32), OUT_CELLS);
+		const accumB = createStateBuffer(root, atomic(u32), OUT_CELLS);
+		const accumW = createStateBuffer(root, atomic(u32), OUT_CELLS);
 		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [OUT_W, OUT_H],
 			format: STATE_FORMAT
@@ -4739,9 +4743,9 @@ const componentDefinition = {
 				const m10 = sz * cy, m11 = sz * sy * sx + cz * cx, m12 = sz * sy * cx - cz * sx;
 				const m20 = -sy, m21 = cy * sx, m22 = cy * cx;
 				paramsU.write({
-					rowX: d.vec4f(m00, -m01, m02, 0),
-					rowY: d.vec4f(-m10, m11, -m12, 0),
-					rowZ: d.vec4f(m20, -m21, m22, 0),
+					rowX: vec4f(m00, -m01, m02, 0),
+					rowY: vec4f(-m10, m11, -m12, 0),
+					rowZ: vec4f(m20, -m21, m22, 0),
 					dt,
 					time: localTime,
 					snap: frameIdx === 0 ? 1 : 0,