shaders 3.0.447 → 3.0.449

package/dist/core/{Particles-BFsKUAPx.js → Particles-D8rP46SB.js}

@@ -1,6 +1,10 @@
-import { Bt as ZERO, F as sdf_exports, J as std, Tn as d, X as createGuardedCompute, Z as createStateBuffer, gn as mixColorsVariants, hn as mixColorsLinear, i as agents_exports, l as pointShapeOptions, lt as hash33, n as tgpu, o as cursorMagnet, ot as hash11, pt as noise_exports, r as AGENT_SHAPES, s as makeAgentWeightFn, u as resolveAgentShape, y as sdf3d_exports } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { $t as vec2f, At as pow, Ct as floor, Dt as min, Et as max, Gt as textureStorage2d, H as mixColorsLinear, Ht as atomic, Lt as smoothstep, Ot as mix, Rt as sqrt, Tt as length, U as mixColorsVariants, Ut as arrayOf, Vt as data_exports, Wt as texture2d, Xt as struct, _t as clamp, an as f32, at as textureStore, d as ZERO, dt as atomicStore, et as src_default, in as vec4f, it as textureLoad, kt as normalize, lt as atomicAdd, mt as abs, nn as vec3f, nt as std_exports, on as i32, sn as u32, tn as vec2u, ut as atomicLoad, xt as exp, yt as cross } from "./edges-BXNBKxSN.js";
+import { l as hash33, o as hash11, p as noise_exports } from "./noise-wTSHXgFz.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { h as sdf_exports } from "./sdf-R0EN3EvS.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-CtKwBX8c.js";
+import { a as makeAgentWeightFn, c as resolveAgentShape, i as cursorMagnet, n as agents_exports, s as pointShapeOptions, t as AGENT_SHAPES } from "./agents-Bv3--qPL.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var { buildAnalyticSdfFn, createSdfDataTexture, SVG_SDF_SIZE } = sdf_exports;
 var { createAnalytic3dSdfSetup, createSvg3dSdfSetup, rotateVec3, rotateVecCpu, is3dShapeType, isSvg3dShapeType, isMobileGpuViewport, resolveShapeSubProp, SHAPE3D_DEFAULTS, SVG3D_DEFAULTS, VOLUMETRIC_FIELD_FORMAT } = sdf3d_exports;
 var DEG_TO_RAD = .017453292519943295;
@@ -26,84 +30,84 @@ var SPLAT_R = 6;
 var SPLAT_WIN = 13;
 var MAX_SPEED = 3;
 var STATE_FORMAT = "rgba16float";
-var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	colA: d.vec4f,
-	colB: d.vec4f,
-	dt: d.f32,
-	time: d.f32,
-	spread: d.f32,
-	agitation: d.f32,
-	dragMul: d.f32,
-	gravX: d.f32,
-	gravY: d.f32,
-	halfDepth: d.f32,
-	mouseX: d.f32,
-	mouseY: d.f32,
-	mouseForce: d.f32,
-	mouseRadSq: d.f32,
-	saRadius: d.f32,
-	saSides: d.f32,
-	saRounding: d.f32,
-	saInnerRatio: d.f32,
-	saRotation: d.f32,
-	saHeight: d.f32,
-	saOffset: d.f32,
-	saAperture: d.f32,
-	centerX: d.f32,
-	centerYv: d.f32,
-	scale: d.f32,
-	rotC: d.f32,
-	rotS: d.f32,
-	aspect: d.f32,
-	size: d.f32,
-	exposure: d.f32,
-	softness: d.f32,
-	speedColorK: d.f32,
-	omegaX: d.f32,
-	omegaY: d.f32,
-	omegaZ: d.f32,
-	entrain: d.f32,
-	gridOffX: d.f32,
-	gridOffY: d.f32,
-	gridOffZ: d.f32
+var SimParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	colA: vec4f,
+	colB: vec4f,
+	dt: f32,
+	time: f32,
+	spread: f32,
+	agitation: f32,
+	dragMul: f32,
+	gravX: f32,
+	gravY: f32,
+	halfDepth: f32,
+	mouseX: f32,
+	mouseY: f32,
+	mouseForce: f32,
+	mouseRadSq: f32,
+	saRadius: f32,
+	saSides: f32,
+	saRounding: f32,
+	saInnerRatio: f32,
+	saRotation: f32,
+	saHeight: f32,
+	saOffset: f32,
+	saAperture: f32,
+	centerX: f32,
+	centerYv: f32,
+	scale: f32,
+	rotC: f32,
+	rotS: f32,
+	aspect: f32,
+	size: f32,
+	exposure: f32,
+	softness: f32,
+	speedColorK: f32,
+	omegaX: f32,
+	omegaY: f32,
+	omegaZ: f32,
+	entrain: f32,
+	gridOffX: f32,
+	gridOffY: f32,
+	gridOffZ: f32
 }), "SimParams");
-var simLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var simLayout = /* @__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"
 	},
 	dens: {
-		storage: d.arrayOf(d.atomic(d.u32), DCELLS),
+		storage: arrayOf(atomic(u32), DCELLS),
 		access: "mutable"
 	},
 	accumE: {
-		storage: d.arrayOf(d.atomic(d.u32), OUT_RES * OUT_RES),
+		storage: arrayOf(atomic(u32), OUT_RES * OUT_RES),
 		access: "mutable"
 	},
 	accumS: {
-		storage: d.arrayOf(d.atomic(d.u32), OUT_RES * OUT_RES),
+		storage: arrayOf(atomic(u32), OUT_RES * OUT_RES),
 		access: "mutable"
 	},
 	params: { uniform: SimParams },
-	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "simLayout");
-var svgSdfLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({ sdfSource: { texture: d.texture2d(d.f32) } }), "svgSdfLayout");
-var densAt = tgpu.fn([
-	d.i32,
-	d.i32,
-	d.i32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy, cz) => {
+var svgSdfLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({ sdfSource: { texture: texture2d(f32) } }), "svgSdfLayout");
+var densAt = src_default.fn([
+	i32,
+	i32,
+	i32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy, cz) => {
 	"use gpu";
-	const g = d.i32(DGRID);
-	const x = std.clamp(cx, 0, __tsover_sub(g, 1));
-	const y = std.clamp(cy, 0, __tsover_sub(g, 1));
-	const z = std.clamp(cz, 0, __tsover_sub(g, 1));
-	const idx = d.u32(__tsover_add(__tsover_mul(__tsover_add(__tsover_mul(z, g), y), g), x));
-	return __tsover_mul(d.f32(std.atomicLoad(simLayout.$.dens[idx])), __tsover_div(1, 64));
+	const g = i32(DGRID);
+	const x = clamp(cx, 0, __tsover_sub(g, 1));
+	const y = clamp(cy, 0, __tsover_sub(g, 1));
+	const z = clamp(cz, 0, __tsover_sub(g, 1));
+	const idx = u32(__tsover_add(__tsover_mul(__tsover_add(__tsover_mul(z, g), y), g), x));
+	return __tsover_mul(f32(atomicLoad(simLayout.$.dens[idx])), __tsover_div(1, 64));
 }), {
 	v: 1,
 	name: void 0,
@@ -283,25 +287,25 @@ var densAt = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DGRID,
-		std,
+		std: std_exports,
 		simLayout
 	})
 }) && $.f)({}));
-var densTrilinear = tgpu.fn([d.vec3f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos) => {
+var densTrilinear = src_default.fn([vec3f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((pos) => {
 	"use gpu";
 	const prm = simLayout.$.params;
-	const g = d.f32(DGRID);
-	const c = d.vec3f(__tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.x, prm.gridOffX), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5), __tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.y, prm.gridOffY), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5), __tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.z, prm.gridOffZ), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5));
-	const base = std.clamp(std.floor(c), d.vec3f(0, 0, 0), d.vec3f(__tsover_sub(g, 2), __tsover_sub(g, 2), __tsover_sub(g, 2)));
-	const f = std.clamp(c.sub(base), d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
-	const bi = d.i32(base.x);
-	const bj = d.i32(base.y);
-	const bk = d.i32(base.z);
-	let acc = d.f32(0);
+	const g = f32(DGRID);
+	const c = vec3f(__tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.x, prm.gridOffX), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5), __tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.y, prm.gridOffY), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5), __tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.z, prm.gridOffZ), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5));
+	const base = clamp(floor(c), vec3f(0, 0, 0), vec3f(__tsover_sub(g, 2), __tsover_sub(g, 2), __tsover_sub(g, 2)));
+	const f = clamp(c.sub(base), vec3f(0, 0, 0), vec3f(1, 1, 1));
+	const bi = i32(base.x);
+	const bj = i32(base.y);
+	const bk = i32(base.z);
+	let acc = f32(0);
 	for (let dz = 0; dz < 2; dz++) for (let dy = 0; dy < 2; dy++) for (let dx = 0; dx < 2; dx++) {
-		const w = __tsover_mul(__tsover_mul(std.mix(__tsover_sub(1, f.x), f.x, d.f32(dx)), std.mix(__tsover_sub(1, f.y), f.y, d.f32(dy))), std.mix(__tsover_sub(1, f.z), f.z, d.f32(dz)));
+		const w = __tsover_mul(__tsover_mul(mix(__tsover_sub(1, f.x), f.x, f32(dx)), mix(__tsover_sub(1, f.y), f.y, f32(dy))), mix(__tsover_sub(1, f.z), f.z, f32(dz)));
 		acc = __tsover_add(acc, __tsover_mul(densAt(__tsover_add(bi, dx), __tsover_add(bj, dy), __tsover_add(bk, dz)), w));
 	}
 	return acc;
@@ -870,18 +874,18 @@ var densTrilinear = tgpu.fn([d.vec3f], d.f32)(/* @__PURE__ */ (($) => (globalThi
 	},
 	externals: () => ({
 		simLayout,
-		d,
+		d: data_exports,
 		DGRID,
 		DOMAIN,
-		std,
+		std: std_exports,
 		densAt
 	})
 }) && $.f)({}));
-var extrudeSdf = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((d2, wz) => {
+var extrudeSdf = src_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((d2, wz) => {
 	"use gpu";
-	const ox = std.max(d2, 0);
-	const oz = std.max(wz, 0);
-	return __tsover_add(std.min(std.max(d2, wz), 0), std.sqrt(__tsover_add(__tsover_mul(ox, ox), __tsover_mul(oz, oz))));
+	const ox = max(d2, 0);
+	const oz = max(wz, 0);
+	return __tsover_add(min(max(d2, wz), 0), sqrt(__tsover_add(__tsover_mul(ox, ox), __tsover_mul(oz, oz))));
 }), {
 	v: 1,
 	name: void 0,
@@ -968,17 +972,16 @@ var extrudeSdf = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalT
 		]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const particleInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+const particleInitKernel = src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 	"use gpu";
-	const fi = d.f32(i);
-	const h3 = hash33(d.vec3f(__tsover_add(__tsover_mul(fi, 1.6180339), .71), __tsover_add(__tsover_mul(fi, 2.7182818), 4.17), __tsover_add(__tsover_mul(fi, 3.1415926), 9.03)));
-	const dir = std.normalize(h3.sub(d.vec3f(.5, .5, .5)).add(d.vec3f(1e-4, 2e-4, 3e-4)));
-	const rad = __tsover_mul(std.pow(hash11(__tsover_add(__tsover_mul(fi, 2.2360679), 1.7)), d.f32(.3333)), .55);
+	const fi = f32(i);
+	const dir = normalize(hash33(vec3f(__tsover_add(__tsover_mul(fi, 1.6180339), .71), __tsover_add(__tsover_mul(fi, 2.7182818), 4.17), __tsover_add(__tsover_mul(fi, 3.1415926), 9.03))).sub(vec3f(.5, .5, .5)).add(vec3f(1e-4, 2e-4, 3e-4)));
+	const rad = __tsover_mul(pow(hash11(__tsover_add(__tsover_mul(fi, 2.2360679), 1.7)), f32(.3333)), .55);
 	const seed = hash11(__tsover_add(__tsover_mul(fi, 1.7320508), .37));
-	simLayout.$.pos[i] = d.vec4f(__tsover_mul(dir.x, rad), __tsover_mul(dir.y, rad), __tsover_mul(__tsover_mul(dir.z, rad), .8), seed);
-	simLayout.$.vel[i] = d.vec4f(0, 0, 0, 0);
+	simLayout.$.pos[i] = vec4f(__tsover_mul(dir.x, rad), __tsover_mul(dir.y, rad), __tsover_mul(__tsover_mul(dir.z, rad), .8), seed);
+	simLayout.$.vel[i] = vec4f(0, 0, 0, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -1279,15 +1282,15 @@ const particleInitKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		noise: noise_exports,
-		std,
+		std: std_exports,
 		simLayout
 	})
 }) && $.f)({})).$name("particlesInit");
-const particleClearDensityKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+const particleClearDensityKernel = src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 	"use gpu";
-	std.atomicStore(simLayout.$.dens[i], d.u32(0));
+	atomicStore(simLayout.$.dens[i], u32(0));
 }), {
 	v: 1,
 	name: void 0,
@@ -1332,30 +1335,30 @@ const particleClearDensityKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (glo
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		simLayout,
-		d
+		d: data_exports
 	})
 }) && $.f)({})).$name("particlesClearDensity");
-const particleDensityKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
+const particleDensityKernel = src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((i) => {
 	"use gpu";
 	const prm = simLayout.$.params;
 	const pos = simLayout.$.pos[i];
-	const g = d.f32(DGRID);
-	const c = d.vec3f(__tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.x, prm.gridOffX), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5), __tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.y, prm.gridOffY), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5), __tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.z, prm.gridOffZ), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5));
-	const base = std.clamp(std.floor(c), d.vec3f(0, 0, 0), d.vec3f(__tsover_sub(g, 2), __tsover_sub(g, 2), __tsover_sub(g, 2)));
-	const f = std.clamp(c.sub(base), d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
-	const bi = d.i32(base.x);
-	const bj = d.i32(base.y);
-	const bk = d.i32(base.z);
-	const gi = d.i32(DGRID);
+	const g = f32(DGRID);
+	const c = vec3f(__tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.x, prm.gridOffX), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5), __tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.y, prm.gridOffY), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5), __tsover_sub(__tsover_mul(__tsover_div(__tsover_add(__tsover_add(pos.z, prm.gridOffZ), DOMAIN), __tsover_mul(2, DOMAIN)), g), .5));
+	const base = clamp(floor(c), vec3f(0, 0, 0), vec3f(__tsover_sub(g, 2), __tsover_sub(g, 2), __tsover_sub(g, 2)));
+	const f = clamp(c.sub(base), vec3f(0, 0, 0), vec3f(1, 1, 1));
+	const bi = i32(base.x);
+	const bj = i32(base.y);
+	const bk = i32(base.z);
+	const gi = i32(DGRID);
 	for (let dz = 0; dz < 2; dz++) for (let dy = 0; dy < 2; dy++) for (let dx = 0; dx < 2; dx++) {
-		const wx = std.mix(__tsover_sub(1, f.x), f.x, d.f32(dx));
-		const wy = std.mix(__tsover_sub(1, f.y), f.y, d.f32(dy));
-		const wz = std.mix(__tsover_sub(1, f.z), f.z, d.f32(dz));
+		const wx = mix(__tsover_sub(1, f.x), f.x, f32(dx));
+		const wy = mix(__tsover_sub(1, f.y), f.y, f32(dy));
+		const wz = mix(__tsover_sub(1, f.z), f.z, f32(dz));
 		const w = __tsover_mul(__tsover_mul(wx, wy), wz);
-		const idx = d.u32(__tsover_add(__tsover_mul(__tsover_add(__tsover_mul(__tsover_add(bk, dz), gi), __tsover_add(bj, dy)), gi), __tsover_add(bi, dx)));
-		std.atomicAdd(simLayout.$.dens[idx], d.u32(__tsover_add(__tsover_mul(w, 64), .5)));
+		const idx = u32(__tsover_add(__tsover_mul(__tsover_add(__tsover_mul(__tsover_add(bk, dz), gi), __tsover_add(bj, dy)), gi), __tsover_add(bi, dx)));
+		atomicAdd(simLayout.$.dens[idx], u32(__tsover_add(__tsover_mul(w, 64), .5)));
 	}
 }), {
 	v: 1,
@@ -2003,17 +2006,17 @@ const particleDensityKernel = tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalTh
 	},
 	externals: () => ({
 		simLayout,
-		d,
+		d: data_exports,
 		DGRID,
 		DOMAIN,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("particlesDensity");
-const particleClearAccumKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
+const particleClearAccumKernel = 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(OUT_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(OUT_RES)), x);
+	atomicStore(simLayout.$.accumE[idx], u32(0));
+	atomicStore(simLayout.$.accumS[idx], u32(0));
 }), {
 	v: 1,
 	name: void 0,
@@ -2116,9 +2119,9 @@ const particleClearAccumKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) =>
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		OUT_RES,
-		std,
+		std: std_exports,
 		simLayout
 	})
 }) && $.f)({})).$name("particlesClearAccum");
@@ -2126,43 +2129,41 @@ function makeParticleSplatKernel(shape) {
 	const name = resolveAgentShape(shape, "dot");
 	const weightFn = makeAgentWeightFn(name);
 	const FORCE_SOFT = AGENT_SHAPES[name].soft;
-	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 pos = simLayout.$.pos[i];
 		const vel = simLayout.$.vel[i];
-		const persp = __tsover_div(1, std.clamp(__tsover_sub(1, __tsover_mul(pos.z, .35)), .45, 2));
+		const persp = __tsover_div(1, clamp(__tsover_sub(1, __tsover_mul(pos.z, .35)), .45, 2));
 		const xs = __tsover_mul(pos.x, persp);
 		const ys = __tsover_mul(__tsover_mul(pos.y, persp), -1);
 		const rx = __tsover_sub(__tsover_mul(xs, prm.rotC), __tsover_mul(ys, prm.rotS));
 		const ry = __tsover_add(__tsover_mul(ys, prm.rotC), __tsover_mul(xs, prm.rotS));
 		const u = __tsover_add(prm.centerX, __tsover_div(__tsover_mul(rx, prm.scale), prm.aspect));
 		const v = __tsover_add(prm.centerYv, __tsover_mul(ry, prm.scale));
-		const outF = d.f32(OUT_RES);
+		const outF = f32(OUT_RES);
 		const tx = __tsover_mul(u, outF);
 		const ty = __tsover_mul(v, outF);
-		const size = std.clamp(__tsover_mul(__tsover_mul(__tsover_mul(prm.size, __tsover_add(.65, __tsover_mul(.7, pos.w))), persp), prm.scale), .6, d.f32(SPLAT_R));
+		const size = clamp(__tsover_mul(__tsover_mul(__tsover_mul(prm.size, __tsover_add(.65, __tsover_mul(.7, pos.w))), persp), prm.scale), .6, f32(SPLAT_R));
 		const bright = __tsover_mul(__tsover_mul(__tsover_add(.7, __tsover_mul(.6, pos.w)), persp), persp);
-		const speedNorm = std.clamp(__tsover_mul(vel.w, prm.speedColorK), 0, 1);
-		const softV = std.max(prm.softness, d.f32(FORCE_SOFT));
-		const cxi = d.i32(std.floor(tx));
-		const cyi = d.i32(std.floor(ty));
+		const speedNorm = clamp(__tsover_mul(vel.w, prm.speedColorK), 0, 1);
+		const softV = max(prm.softness, f32(FORCE_SOFT));
+		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 < OUT_RES && py >= 0 && py < OUT_RES) {
-				const ddx = __tsover_sub(__tsover_add(d.f32(px), .5), tx);
-				const ddy = __tsover_sub(__tsover_add(d.f32(py), .5), ty);
-				const q = __tsover_div(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)), std.max(__tsover_mul(size, size), .01));
+				const ddx = __tsover_sub(__tsover_add(f32(px), .5), tx);
+				const ddy = __tsover_sub(__tsover_add(f32(py), .5), ty);
+				const q = __tsover_div(__tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)), max(__tsover_mul(size, size), .01));
 				if (q < 2.6) {
-					const wHard = weightFn(ddx, ddy, size, .9, d.f32(0));
-					const wSoft = std.exp(__tsover_mul(q, -2.5));
-					const w = std.mix(wHard, wSoft, softV);
-					const e = d.u32(__tsover_mul(__tsover_mul(w, bright), 256));
-					if (e > d.u32(0)) {
-						const idx = d.u32(__tsover_add(__tsover_mul(py, OUT_RES), px));
-						std.atomicAdd(simLayout.$.accumE[idx], e);
-						std.atomicAdd(simLayout.$.accumS[idx], d.u32(__tsover_mul(__tsover_mul(__tsover_mul(w, bright), speedNorm), 256)));
+					const w = mix(weightFn(ddx, ddy, size, .9, f32(0)), exp(__tsover_mul(q, -2.5)), softV);
+					const e = u32(__tsover_mul(__tsover_mul(w, bright), 256));
+					if (e > u32(0)) {
+						const idx = u32(__tsover_add(__tsover_mul(py, OUT_RES), px));
+						atomicAdd(simLayout.$.accumE[idx], e);
+						atomicAdd(simLayout.$.accumS[idx], u32(__tsover_mul(__tsover_mul(__tsover_mul(w, bright), speedNorm), 256)));
 					}
 				}
 			}
@@ -3040,8 +3041,8 @@ function makeParticleSplatKernel(shape) {
 		},
 		externals: () => ({
 			simLayout,
-			std,
-			d,
+			std: std_exports,
+			d: data_exports,
 			OUT_RES,
 			SPLAT_R,
 			FORCE_SOFT,
@@ -3053,17 +3054,17 @@ function makeParticleSplatKernel(shape) {
 const particleSplatKernel = makeParticleSplatKernel("dot");
 function makeParticleResolveKernel(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(OUT_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(OUT_RES)), x);
+		const eRaw = f32(atomicLoad(simLayout.$.accumE[idx]));
+		const sRaw = f32(atomicLoad(simLayout.$.accumS[idx]));
 		const energy = __tsover_mul(__tsover_mul(eRaw, __tsover_div(1, 256)), prm.exposure);
-		const speedAvg = __tsover_div(sRaw, std.max(eRaw, 1));
-		const col = mixFn(prm.colA, prm.colB, std.clamp(speedAvg, 0, 1));
-		const alpha = __tsover_sub(1, std.exp(__tsover_mul(energy, -1.6)));
-		std.textureStore(simLayout.$.outTex, d.vec2u(x, y), d.vec4f(col.x, col.y, col.z, __tsover_mul(alpha, col.w)));
+		const speedAvg = __tsover_div(sRaw, max(eRaw, 1));
+		const col = mixFn(prm.colA, prm.colB, clamp(speedAvg, 0, 1));
+		const alpha = __tsover_sub(1, exp(__tsover_mul(energy, -1.6)));
+		textureStore(simLayout.$.outTex, vec2u(x, y), vec4f(col.x, col.y, col.z, __tsover_mul(alpha, col.w)));
 	}), {
 		v: 1,
 		name: void 0,
@@ -3354,58 +3355,55 @@ function makeParticleResolveKernel(colorSpaceMode) {
 		},
 		externals: () => ({
 			simLayout,
-			d,
+			d: data_exports,
 			OUT_RES,
-			std,
+			std: std_exports,
 			mixFn
 		})
 	}) && $.f)({})).$name("particlesResolve");
 }
 function makeParticleUpdateKernel(evalSdf) {
-	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 p4 = simLayout.$.pos[i];
 		const v4 = simLayout.$.vel[i];
-		let pos = d.vec3f(p4.x, p4.y, p4.z);
+		let pos = vec3f(p4.x, p4.y, p4.z);
 		const dt = prm.dt;
 		const sd = evalSdf(pos);
-		const e = d.f32(.02);
-		const gx = __tsover_sub(evalSdf(d.vec3f(__tsover_add(pos.x, e), pos.y, pos.z)), evalSdf(d.vec3f(__tsover_sub(pos.x, e), pos.y, pos.z)));
-		const gy = __tsover_sub(evalSdf(d.vec3f(pos.x, __tsover_add(pos.y, e), pos.z)), evalSdf(d.vec3f(pos.x, __tsover_sub(pos.y, e), pos.z)));
-		const gz = __tsover_sub(evalSdf(d.vec3f(pos.x, pos.y, __tsover_add(pos.z, e))), evalSdf(d.vec3f(pos.x, pos.y, __tsover_sub(pos.z, e))));
-		const gv = d.vec3f(gx, gy, gz);
-		const gn = gv.div(std.max(std.length(gv), 1e-4));
-		const he = d.f32(__tsover_div(DOMAIN, DGRID));
+		const e = f32(.02);
+		const gv = vec3f(__tsover_sub(evalSdf(vec3f(__tsover_add(pos.x, e), pos.y, pos.z)), evalSdf(vec3f(__tsover_sub(pos.x, e), pos.y, pos.z))), __tsover_sub(evalSdf(vec3f(pos.x, __tsover_add(pos.y, e), pos.z)), evalSdf(vec3f(pos.x, __tsover_sub(pos.y, e), pos.z))), __tsover_sub(evalSdf(vec3f(pos.x, pos.y, __tsover_add(pos.z, e))), evalSdf(vec3f(pos.x, pos.y, __tsover_sub(pos.z, e)))));
+		const gn = gv.div(max(length(gv), 1e-4));
+		const he = f32(__tsover_div(DOMAIN, DGRID));
 		const c0 = densTrilinear(pos);
-		const dgx = __tsover_sub(densTrilinear(d.vec3f(__tsover_add(pos.x, he), pos.y, pos.z)), densTrilinear(d.vec3f(__tsover_sub(pos.x, he), pos.y, pos.z)));
-		const dgy = __tsover_sub(densTrilinear(d.vec3f(pos.x, __tsover_add(pos.y, he), pos.z)), densTrilinear(d.vec3f(pos.x, __tsover_sub(pos.y, he), pos.z)));
-		const dgz = __tsover_sub(densTrilinear(d.vec3f(pos.x, pos.y, __tsover_add(pos.z, he))), densTrilinear(d.vec3f(pos.x, pos.y, __tsover_sub(pos.z, he))));
-		const pressNorm = __tsover_div(__tsover_mul(prm.spread, 4.4), std.max(__tsover_add(__tsover_mul(c0, 2), 6), 6));
-		let F = d.vec3f(__tsover_mul(__tsover_mul(dgx, -1), pressNorm), __tsover_mul(__tsover_mul(dgy, -1), pressNorm), __tsover_mul(__tsover_mul(dgz, -1), pressNorm));
-		const out = std.max(sd, 0);
-		const wall = __tsover_add(__tsover_mul(std.smoothstep(-.1, .01, sd), 1.1), __tsover_mul(out, 22));
+		const dgx = __tsover_sub(densTrilinear(vec3f(__tsover_add(pos.x, he), pos.y, pos.z)), densTrilinear(vec3f(__tsover_sub(pos.x, he), pos.y, pos.z)));
+		const dgy = __tsover_sub(densTrilinear(vec3f(pos.x, __tsover_add(pos.y, he), pos.z)), densTrilinear(vec3f(pos.x, __tsover_sub(pos.y, he), pos.z)));
+		const dgz = __tsover_sub(densTrilinear(vec3f(pos.x, pos.y, __tsover_add(pos.z, he))), densTrilinear(vec3f(pos.x, pos.y, __tsover_sub(pos.z, he))));
+		const pressNorm = __tsover_div(__tsover_mul(prm.spread, 4.4), max(__tsover_add(__tsover_mul(c0, 2), 6), 6));
+		let F = vec3f(__tsover_mul(__tsover_mul(dgx, -1), pressNorm), __tsover_mul(__tsover_mul(dgy, -1), pressNorm), __tsover_mul(__tsover_mul(dgz, -1), pressNorm));
+		const out = max(sd, 0);
+		const wall = __tsover_add(__tsover_mul(smoothstep(-.1, .01, sd), 1.1), __tsover_mul(out, 22));
 		F = F.sub(gn.mul(wall));
-		const rl = std.length(pos);
-		const recall = __tsover_mul(std.smoothstep(__tsover_mul(DOMAIN, .85), __tsover_mul(DOMAIN, 1.1), rl), 9);
-		F = F.sub(pos.mul(__tsover_div(recall, std.max(rl, 1e-4))));
-		const homing = __tsover_mul(std.smoothstep(.12, .45, sd), 5);
-		F = F.sub(pos.mul(__tsover_div(homing, std.max(rl, 1e-4))));
-		const vPrev = d.vec3f(v4.x, v4.y, v4.z);
-		const featureVel = std.cross(d.vec3f(prm.omegaX, prm.omegaY, prm.omegaZ), pos);
-		const insideM = __tsover_sub(1, std.smoothstep(-.05, .05, sd));
+		const rl = length(pos);
+		const recall = __tsover_mul(smoothstep(__tsover_mul(DOMAIN, .85), __tsover_mul(DOMAIN, 1.1), rl), 9);
+		F = F.sub(pos.mul(__tsover_div(recall, max(rl, 1e-4))));
+		const homing = __tsover_mul(smoothstep(.12, .45, sd), 5);
+		F = F.sub(pos.mul(__tsover_div(homing, max(rl, 1e-4))));
+		const vPrev = vec3f(v4.x, v4.y, v4.z);
+		const featureVel = cross(vec3f(prm.omegaX, prm.omegaY, prm.omegaZ), pos);
+		const insideM = __tsover_sub(1, smoothstep(-.05, .05, sd));
 		F = F.add(featureVel.sub(vPrev).mul(__tsover_mul(prm.entrain, insideM)));
-		const mxy = cursorMagnet(d.vec2f(__tsover_sub(pos.x, prm.mouseX), __tsover_sub(pos.y, prm.mouseY)), prm.mouseRadSq, prm.mouseForce);
-		F = F.add(d.vec3f(mxy.x, mxy.y, 0));
-		F = F.add(d.vec3f(prm.gravX, prm.gravY, 0));
-		const rnd = hash33(pos.mul(193).add(d.vec3f(__tsover_mul(prm.time, 31.7), __tsover_mul(prm.time, 27.3), __tsover_mul(p4.w, 997)))).sub(d.vec3f(.5, .5, .5));
+		const mxy = cursorMagnet(vec2f(__tsover_sub(pos.x, prm.mouseX), __tsover_sub(pos.y, prm.mouseY)), prm.mouseRadSq, prm.mouseForce);
+		F = F.add(vec3f(mxy.x, mxy.y, 0));
+		F = F.add(vec3f(prm.gravX, prm.gravY, 0));
+		const rnd = hash33(pos.mul(193).add(vec3f(__tsover_mul(prm.time, 31.7), __tsover_mul(prm.time, 27.3), __tsover_mul(p4.w, 997)))).sub(vec3f(.5, .5, .5));
 		F = F.add(rnd.mul(__tsover_mul(prm.agitation, 5)));
 		let v3 = vPrev.add(F.mul(dt)).mul(prm.dragMul);
-		const spd = std.length(v3);
-		v3 = v3.mul(__tsover_div(std.min(spd, d.f32(MAX_SPEED)), std.max(spd, 1e-5)));
-		pos = std.clamp(pos.add(v3.mul(dt)), d.vec3f(-1.9, -1.9, -1.9), d.vec3f(1.9, 1.9, 1.9));
-		simLayout.$.pos[i] = d.vec4f(pos.x, pos.y, pos.z, p4.w);
-		simLayout.$.vel[i] = d.vec4f(v3.x, v3.y, v3.z, std.length(v3));
+		const spd = length(v3);
+		v3 = v3.mul(__tsover_div(min(spd, f32(MAX_SPEED)), max(spd, 1e-5)));
+		pos = clamp(pos.add(v3.mul(dt)), vec3f(-1.9, -1.9, -1.9), vec3f(1.9, 1.9, 1.9));
+		simLayout.$.pos[i] = vec4f(pos.x, pos.y, pos.z, p4.w);
+		simLayout.$.vel[i] = vec4f(v3.x, v3.y, v3.z, length(v3));
 	}), {
 		v: 1,
 		name: void 0,
@@ -5005,9 +5003,9 @@ function makeParticleUpdateKernel(evalSdf) {
 		},
 		externals: () => ({
 			simLayout,
-			d,
+			d: data_exports,
 			evalSdf,
-			std,
+			std: std_exports,
 			DOMAIN,
 			DGRID,
 			densTrilinear,
@@ -5274,11 +5272,11 @@ const componentDefinition = {
 		if (!root) return null;
 		const shapeSdfUrl = getCpuValue("shapeSdfUrl") || "";
 		const shapeType = resolveShapeType(getCpuValue("shapeType") || "", getCpuValue("shape"));
-		const posBuf = createStateBuffer(root, d.vec4f, MAX_PARTICLES);
-		const velBuf = createStateBuffer(root, d.vec4f, MAX_PARTICLES);
-		const densBuf = createStateBuffer(root, d.atomic(d.u32), DCELLS);
-		const accumE = createStateBuffer(root, d.atomic(d.u32), OUT_RES * OUT_RES);
-		const accumS = createStateBuffer(root, d.atomic(d.u32), OUT_RES * OUT_RES);
+		const posBuf = createStateBuffer(root, vec4f, MAX_PARTICLES);
+		const velBuf = createStateBuffer(root, vec4f, MAX_PARTICLES);
+		const densBuf = createStateBuffer(root, atomic(u32), DCELLS);
+		const accumE = createStateBuffer(root, atomic(u32), OUT_RES * OUT_RES);
+		const accumS = createStateBuffer(root, atomic(u32), OUT_RES * OUT_RES);
 		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [OUT_RES, OUT_RES],
 			format: STATE_FORMAT
@@ -5312,12 +5310,12 @@ const componentDefinition = {
 			});
 			const baked = setup3d.sdfFn;
 			const layoutSvg = setup3d.layout;
-			evalSdf = tgpu.fn([d.vec3f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p3) => {
+			evalSdf = src_default.fn([vec3f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p3) => {
 				"use gpu";
 				const ps = rotateVec3(p3, layoutSvg.$.params.rot);
-				const exX = std.max(__tsover_sub(std.abs(ps.x), .5), 0);
-				const exY = std.max(__tsover_sub(std.abs(ps.y), .5), 0);
-				return __tsover_add(baked(ps), std.sqrt(__tsover_add(__tsover_mul(exX, exX), __tsover_mul(exY, exY))));
+				const exX = max(__tsover_sub(abs(ps.x), .5), 0);
+				const exY = max(__tsover_sub(abs(ps.y), .5), 0);
+				return __tsover_add(baked(ps), sqrt(__tsover_add(__tsover_mul(exX, exX), __tsover_mul(exY, exY))));
 			}), {
 				v: 1,
 				name: void 0,
@@ -5452,23 +5450,23 @@ const componentDefinition = {
 				externals: () => ({
 					rotateVec3,
 					layoutSvg,
-					std,
+					std: std_exports,
 					baked
 				})
 			}) && $.f)({}));
 		} else if (shapeSdfUrl) {
 			const sdfTex = createSdfDataTexture(params, shapeSdfUrl);
 			extraBg = root.createBindGroup(svgSdfLayout, { sdfSource: sdfTex.texture.texture });
-			evalSdf = tgpu.fn([d.vec3f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p3) => {
+			evalSdf = src_default.fn([vec3f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p3) => {
 				"use gpu";
 				const prm = simLayout.$.params;
 				const sizeM1 = __tsover_sub(SVG_SDF_SIZE, 1);
-				const tx = std.clamp(d.i32(__tsover_mul(__tsover_add(p3.x, .5), SVG_SDF_SIZE)), 0, sizeM1);
-				const ty = std.clamp(d.i32(__tsover_mul(__tsover_sub(.5, p3.y), SVG_SDF_SIZE)), 0, sizeM1);
-				const d2 = std.textureLoad(svgSdfLayout.$.sdfSource, d.vec2u(d.u32(tx), d.u32(ty)), 0).x;
-				const exX = std.max(__tsover_sub(std.abs(p3.x), .5), 0);
-				const exY = std.max(__tsover_sub(std.abs(p3.y), .5), 0);
-				return extrudeSdf(__tsover_add(d2, std.sqrt(__tsover_add(__tsover_mul(exX, exX), __tsover_mul(exY, exY)))), __tsover_sub(std.abs(p3.z), prm.halfDepth));
+				const tx = clamp(i32(__tsover_mul(__tsover_add(p3.x, .5), SVG_SDF_SIZE)), 0, sizeM1);
+				const ty = clamp(i32(__tsover_mul(__tsover_sub(.5, p3.y), SVG_SDF_SIZE)), 0, sizeM1);
+				const d2 = textureLoad(svgSdfLayout.$.sdfSource, vec2u(u32(tx), u32(ty)), 0).x;
+				const exX = max(__tsover_sub(abs(p3.x), .5), 0);
+				const exY = max(__tsover_sub(abs(p3.y), .5), 0);
+				return extrudeSdf(__tsover_add(d2, sqrt(__tsover_add(__tsover_mul(exX, exX), __tsover_mul(exY, exY)))), __tsover_sub(abs(p3.z), prm.halfDepth));
 			}), {
 				v: 1,
 				name: void 0,
@@ -5764,8 +5762,8 @@ const componentDefinition = {
 				externals: () => ({
 					simLayout,
 					SVG_SDF_SIZE,
-					std,
-					d,
+					std: std_exports,
+					d: data_exports,
 					svgSdfLayout,
 					extrudeSdf
 				})
@@ -5783,7 +5781,7 @@ const componentDefinition = {
 			});
 			const baked = setup3d.sdfFn;
 			const layout3d = setup3d.layout;
-			evalSdf = tgpu.fn([d.vec3f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p3) => {
+			evalSdf = src_default.fn([vec3f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p3) => {
 				"use gpu";
 				return baked(rotateVec3(p3, layout3d.$.params.rot));
 			}), {
@@ -5829,11 +5827,11 @@ const componentDefinition = {
 			}) && $.f)({}));
 		} else {
 			const sdf2d = buildAnalyticSdfFn(shapeType);
-			evalSdf = tgpu.fn([d.vec3f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p3) => {
+			evalSdf = src_default.fn([vec3f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p3) => {
 				"use gpu";
 				const prm = simLayout.$.params;
-				const d2 = sdf2d(d.vec2f(__tsover_add(p3.x, .5), __tsover_sub(.5, p3.y)), prm.saRadius, prm.saSides, prm.saRounding, prm.saInnerRatio, prm.saRotation, prm.saHeight, prm.saOffset, prm.saAperture).x;
-				return extrudeSdf(d2, __tsover_sub(std.abs(p3.z), prm.halfDepth));
+				const d2 = sdf2d(vec2f(__tsover_add(p3.x, .5), __tsover_sub(.5, p3.y)), prm.saRadius, prm.saSides, prm.saRounding, prm.saInnerRatio, prm.saRotation, prm.saHeight, prm.saOffset, prm.saAperture).x;
+				return extrudeSdf(d2, __tsover_sub(abs(p3.z), prm.halfDepth));
 			}), {
 				v: 1,
 				name: void 0,
@@ -5979,10 +5977,10 @@ const componentDefinition = {
 				},
 				externals: () => ({
 					simLayout,
-					d,
+					d: data_exports,
 					sdf2d,
 					extrudeSdf,
-					std
+					std: std_exports
 				})
 			}) && $.f)({}));
 		}
@@ -6183,8 +6181,8 @@ const componentDefinition = {
 				const colA = getCpuValue("colorA");
 				const colB = getCpuValue("colorB");
 				paramsU.write({
-					colA: d.vec4f(colA?.x ?? 1, colA?.y ?? 1, colA?.z ?? 1, colA?.w ?? 1),
-					colB: d.vec4f(colB?.x ?? 1, colB?.y ?? 1, colB?.z ?? 1, colB?.w ?? 1),
+					colA: vec4f(colA?.x ?? 1, colA?.y ?? 1, colA?.z ?? 1, colA?.w ?? 1),
+					colB: vec4f(colB?.x ?? 1, colB?.y ?? 1, colB?.z ?? 1, colB?.w ?? 1),
 					dt,
 					time,
 					spread: g("spread", 1),