shaders 3.0.448 → 3.0.450

package/dist/core/{Particles-BFsKUAPx.js → Particles-BDEX4Fw2.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 { At as mix, Bt as sqrt, Ct as exp, Dt as length, Gt as arrayOf, H as mixColorsLinear, Kt as texture2d, Mt as pow, Ot as max, Qt as struct, Tt as floor, U as mixColorsVariants, Ut as data_exports, Wt as atomic, cn as i32, d as ZERO, dt as atomicLoad, et as src_default, ft as atomicStore, ht as abs, in as vec3f, it as textureLoad, jt as normalize, kt as min, ln as u32, nt as std_exports, on as vec4f, ot as textureStore, qt as textureStorage2d, rn as vec2u, sn as f32, tn as vec2f, ut as atomicAdd, vt as ceil, xt as cross, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { l as hash33, o as hash11, p as noise_exports } from "./noise-Cq0KUOSC.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BoeIXi0l.js";
+import { h as sdf_exports } from "./sdf-o99ONcMJ.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-Dg4GQ5vW.js";
+import { a as makeAgentTexelWeightFn, c as pointShapeOptions, i as cursorMagnet, l as resolveAgentShape, n as agents_exports, t as AGENT_SHAPES } from "./agents-c-JjGH1b.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;
@@ -18,92 +22,95 @@ function parseShapeConfig(raw) {
 	return {};
 }
 var MAX_PARTICLES = 16e3;
+var COUNT_CAP = isMobileGpuViewport() ? 6e3 : MAX_PARTICLES;
 var DGRID = 32;
 var DCELLS = DGRID * DGRID * DGRID;
 var DOMAIN = 1;
 var OUT_RES = isMobileGpuViewport() ? 768 : 1024;
-var SPLAT_R = 6;
-var SPLAT_WIN = 13;
+var SIZE_SCALE = OUT_RES / 1024;
+var EXTQ = 2.6;
+var EXT = Math.sqrt(EXTQ);
+var MAX_SPLAT_SIZE = 6;
 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 +290,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 +877,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 +975,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 +1285,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 +1338,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,166 +2009,212 @@ 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) => {
+var glowProfile = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((q, _ddx, _ddy, _size, _soft) => {
 	"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));
+	return exp(__tsover_mul(q, -2.5));
 }), {
 	v: 1,
 	name: void 0,
 	ast: {
-		"params": [{
-			"type": "i",
-			"name": "x"
-		}, {
-			"type": "i",
-			"name": "y"
-		}],
-		"body": [0, [
+		"params": [
+			{
+				"type": "i",
+				"name": "q"
+			},
+			{
+				"type": "i",
+				"name": "_ddx"
+			},
+			{
+				"type": "i",
+				"name": "_ddy"
+			},
+			{
+				"type": "i",
+				"name": "_size"
+			},
+			{
+				"type": "i",
+				"name": "_soft"
+			}
+		],
+		"body": [0, [[10, [
+			6,
 			[
-				13,
-				"idx",
+				7,
+				"std",
+				"exp"
+			],
+			[[
+				1,
+				"q",
+				"*",
 				[
-					1,
-					[
-						1,
-						"y",
-						"*",
-						[
-							6,
-							[
-								7,
-								"d",
-								"u32"
-							],
-							["OUT_RES"]
-						]
-					],
-					"+",
-					"x"
+					4,
+					"-",
+					[5, "2.5"]
 				]
+			]]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({})).$name("particlesGlowProfile");
+function makeParticleProfileFn(name) {
+	if (AGENT_SHAPES[name].soft === 1) return glowProfile;
+	const weightFn = makeAgentTexelWeightFn(name);
+	return src_default.fn([
+		f32,
+		f32,
+		f32,
+		f32,
+		f32
+	], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((q, ddx, ddy, size, soft) => {
+		"use gpu";
+		return mix(weightFn(q, ddx, ddy, size, .9), exp(__tsover_mul(q, -2.5)), soft);
+	}), {
+		v: 1,
+		name: void 0,
+		ast: {
+			"params": [
+				{
+					"type": "i",
+					"name": "q"
+				},
+				{
+					"type": "i",
+					"name": "ddx"
+				},
+				{
+					"type": "i",
+					"name": "ddy"
+				},
+				{
+					"type": "i",
+					"name": "size"
+				},
+				{
+					"type": "i",
+					"name": "soft"
+				}
 			],
-			[
-				6,
+			"body": [0, [
 				[
-					7,
-					"std",
-					"atomicStore"
-				],
-				[[
-					8,
+					13,
+					"wHard",
 					[
-						7,
+						6,
+						"weightFn",
 						[
-							7,
-							"simLayout",
-							"$"
-						],
-						"accumE"
-					],
-					"idx"
-				], [
-					6,
-					[
-						7,
-						"d",
-						"u32"
-					],
-					[[5, "0"]]
-				]]
-			],
-			[
-				6,
-				[
-					7,
-					"std",
-					"atomicStore"
+							"q",
+							"ddx",
+							"ddy",
+							"size",
+							[5, "0.9"]
+						]
+					]
 				],
-				[[
-					8,
+				[
+					13,
+					"wSoft",
 					[
-						7,
+						6,
 						[
 							7,
-							"simLayout",
-							"$"
+							"std",
+							"exp"
 						],
-						"accumS"
-					],
-					"idx"
-				], [
+						[[
+							1,
+							"q",
+							"*",
+							[
+								4,
+								"-",
+								[5, "2.5"]
+							]
+						]]
+					]
+				],
+				[10, [
 					6,
 					[
 						7,
-						"d",
-						"u32"
+						"std",
+						"mix"
 					],
-					[[5, "0"]]
+					[
+						"wHard",
+						"wSoft",
+						"soft"
+					]
 				]]
-			]
-		]],
-		"externalNames": [
-			"d",
-			"OUT_RES",
-			"std",
-			"simLayout"
-		]
-	},
-	externals: () => ({
-		d,
-		OUT_RES,
-		std,
-		simLayout
-	})
-}) && $.f)({})).$name("particlesClearAccum");
+			]],
+			"externalNames": ["weightFn", "std"]
+		},
+		externals: () => ({
+			weightFn,
+			std: std_exports
+		})
+	}) && $.f)({})).$name("particlesProfile");
+}
 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) => {
+	const profileFn = makeParticleProfileFn(resolveAgentShape(shape, "dot"));
+	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(MAX_SPLAT_SIZE));
 		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));
-		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));
-				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 speedNorm = clamp(__tsover_mul(vel.w, prm.speedColorK), 0, 1);
+		const doSpeed = __tsover_mul(__tsover_mul(bright, speedNorm), 256) >= 1;
+		const cxi = i32(floor(tx));
+		const cyi = i32(floor(ty));
+		const rad = i32(ceil(__tsover_mul(size, f32(EXT))));
+		const radF = f32(rad);
+		if (tx > __tsover_mul(radF, -1) && tx < __tsover_add(outF, radF) && ty > __tsover_mul(radF, -1) && ty < __tsover_add(outF, radF)) {
+			const x0 = max(__tsover_sub(cxi, rad), 0);
+			const x1 = min(__tsover_add(cxi, rad), i32(__tsover_sub(OUT_RES, 1)));
+			const y0 = max(__tsover_sub(cyi, rad), 0);
+			const y1 = min(__tsover_add(cyi, rad), i32(__tsover_sub(OUT_RES, 1)));
+			const sizeSq = max(__tsover_mul(size, size), .01);
+			for (let py = y0; py <= y1; py++) {
+				const ddy = __tsover_sub(__tsover_add(f32(py), .5), ty);
+				const ddySq = __tsover_mul(ddy, ddy);
+				for (let px = x0; px <= x1; px++) {
+					const ddx = __tsover_sub(__tsover_add(f32(px), .5), tx);
+					const q = __tsover_div(__tsover_add(__tsover_mul(ddx, ddx), ddySq), sizeSq);
+					if (q < EXTQ) {
+						const w = profileFn(q, ddx, ddy, size, prm.softness);
+						const e = u32(__tsover_mul(__tsover_mul(w, bright), 256));
+						if (e > u32(0)) {
+							const idx = u32(__tsover_add(__tsover_mul(py, i32(OUT_RES)), px));
+							atomicAdd(simLayout.$.accumE[idx], e);
+							if (doSpeed) atomicAdd(simLayout.$.accumS[idx], u32(__tsover_mul(__tsover_mul(__tsover_mul(w, bright), speedNorm), 256)));
+						}
 					}
 				}
 			}
@@ -2497,7 +2549,7 @@ function makeParticleSplatKernel(shape) {
 									"d",
 									"f32"
 								],
-								["SPLAT_R"]
+								["MAX_SPLAT_SIZE"]
 							]
 						]
 					]
@@ -2563,32 +2615,48 @@ function makeParticleSplatKernel(shape) {
 				],
 				[
 					13,
-					"softV",
+					"doSpeed",
+					[
+						1,
+						[
+							1,
+							[
+								1,
+								"bright",
+								"*",
+								"speedNorm"
+							],
+							"*",
+							[5, "256"]
+						],
+						">=",
+						[5, "1"]
+					]
+				],
+				[
+					13,
+					"cxi",
 					[
 						6,
 						[
 							7,
-							"std",
-							"max"
+							"d",
+							"i32"
 						],
 						[[
-							7,
-							"prm",
-							"softness"
-						], [
 							6,
 							[
 								7,
-								"d",
-								"f32"
+								"std",
+								"floor"
 							],
-							["FORCE_SOFT"]
+							["tx"]
 						]]
 					]
 				],
 				[
 					13,
-					"cxi",
+					"cyi",
 					[
 						6,
 						[
@@ -2603,13 +2671,13 @@ function makeParticleSplatKernel(shape) {
 								"std",
 								"floor"
 							],
-							["tx"]
+							["ty"]
 						]]
 					]
 				],
 				[
 					13,
-					"cyi",
+					"rad",
 					[
 						6,
 						[
@@ -2622,302 +2690,371 @@ function makeParticleSplatKernel(shape) {
 							[
 								7,
 								"std",
-								"floor"
+								"ceil"
 							],
-							["ty"]
+							[[
+								1,
+								"size",
+								"*",
+								[
+									6,
+									[
+										7,
+										"d",
+										"f32"
+									],
+									["EXT"]
+								]
+							]]
 						]]
 					]
 				],
 				[
-					14,
-					[
-						12,
-						"ky",
-						[5, "0"]
-					],
+					13,
+					"radF",
 					[
-						1,
-						"ky",
-						"<",
-						"SPLAT_WIN"
-					],
+						6,
+						[
+							7,
+							"d",
+							"f32"
+						],
+						["rad"]
+					]
+				],
+				[
+					13,
+					"onTarget",
 					[
-						102,
-						"++",
-						"ky"
-					],
-					[0, [[
-						14,
+						3,
 						[
-							12,
-							"kx",
-							[5, "0"]
+							3,
+							[
+								3,
+								[
+									1,
+									"tx",
+									">",
+									[
+										1,
+										"radF",
+										"*",
+										[
+											4,
+											"-",
+											[5, "1"]
+										]
+									]
+								],
+								"&&",
+								[
+									1,
+									"tx",
+									"<",
+									[
+										1,
+										"outF",
+										"+",
+										"radF"
+									]
+								]
+							],
+							"&&",
+							[
+								1,
+								"ty",
+								">",
+								[
+									1,
+									"radF",
+									"*",
+									[
+										4,
+										"-",
+										[5, "1"]
+									]
+								]
+							]
 						],
+						"&&",
 						[
 							1,
-							"kx",
+							"ty",
 							"<",
-							"SPLAT_WIN"
-						],
+							[
+								1,
+								"outF",
+								"+",
+								"radF"
+							]
+						]
+					]
+				],
+				[
+					11,
+					"onTarget",
+					[0, [
 						[
-							102,
-							"++",
-							"kx"
+							13,
+							"x0",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								[[
+									1,
+									"cxi",
+									"-",
+									"rad"
+								], [5, "0"]]
+							]
 						],
-						[0, [
+						[
+							13,
+							"x1",
 							[
-								13,
-								"px",
+								6,
 								[
+									7,
+									"std",
+									"min"
+								],
+								[[
 									1,
+									"cxi",
+									"+",
+									"rad"
+								], [
+									6,
 									[
-										1,
-										"cxi",
-										"+",
-										"kx"
+										7,
+										"d",
+										"i32"
 									],
+									[[
+										1,
+										"OUT_RES",
+										"-",
+										[5, "1"]
+									]]
+								]]
+							]
+						],
+						[
+							13,
+							"y0",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								[[
+									1,
+									"cyi",
 									"-",
-									"SPLAT_R"
-								]
-							],
+									"rad"
+								], [5, "0"]]
+							]
+						],
+						[
+							13,
+							"y1",
 							[
-								13,
-								"py",
+								6,
 								[
+									7,
+									"std",
+									"min"
+								],
+								[[
 									1,
+									"cyi",
+									"+",
+									"rad"
+								], [
+									6,
 									[
-										1,
-										"cyi",
-										"+",
-										"ky"
+										7,
+										"d",
+										"i32"
 									],
-									"-",
-									"SPLAT_R"
-								]
+									[[
+										1,
+										"OUT_RES",
+										"-",
+										[5, "1"]
+									]]
+								]]
+							]
+						],
+						[
+							13,
+							"sizeSq",
+							[
+								6,
+								[
+									7,
+									"std",
+									"max"
+								],
+								[[
+									1,
+									"size",
+									"*",
+									"size"
+								], [5, "0.01"]]
+							]
+						],
+						[
+							14,
+							[
+								12,
+								"py",
+								"y0"
+							],
+							[
+								1,
+								"py",
+								"<=",
+								"y1"
 							],
 							[
-								11,
+								102,
+								"++",
+								"py"
+							],
+							[0, [
 								[
-									3,
+									13,
+									"ddy",
 									[
-										3,
+										1,
 										[
-											3,
+											1,
 											[
-												1,
-												"px",
-												">=",
-												[5, "0"]
+												6,
+												[
+													7,
+													"d",
+													"f32"
+												],
+												["py"]
 											],
-											"&&",
-											[
-												1,
-												"px",
-												"<",
-												"OUT_RES"
-											]
+											"+",
+											[5, "0.5"]
 										],
-										"&&",
-										[
-											1,
-											"py",
-											">=",
-											[5, "0"]
-										]
-									],
-									"&&",
+										"-",
+										"ty"
+									]
+								],
+								[
+									13,
+									"ddySq",
 									[
 										1,
-										"py",
-										"<",
-										"OUT_RES"
+										"ddy",
+										"*",
+										"ddy"
 									]
 								],
-								[0, [
+								[
+									14,
 									[
-										13,
-										"ddx",
-										[
-											1,
-											[
-												1,
-												[
-													6,
-													[
-														7,
-														"d",
-														"f32"
-													],
-													["px"]
-												],
-												"+",
-												[5, "0.5"]
-											],
-											"-",
-											"tx"
-										]
+										12,
+										"px",
+										"x0"
 									],
 									[
-										13,
-										"ddy",
+										1,
+										"px",
+										"<=",
+										"x1"
+									],
+									[
+										102,
+										"++",
+										"px"
+									],
+									[0, [
 										[
-											1,
+											13,
+											"ddx",
 											[
 												1,
 												[
-													6,
+													1,
 													[
-														7,
-														"d",
-														"f32"
+														6,
+														[
+															7,
+															"d",
+															"f32"
+														],
+														["px"]
 													],
-													["py"]
+													"+",
+													[5, "0.5"]
 												],
-												"+",
-												[5, "0.5"]
-											],
-											"-",
-											"ty"
-										]
-									],
-									[
-										13,
-										"q",
+												"-",
+												"tx"
+											]
+										],
 										[
-											1,
+											13,
+											"q",
 											[
 												1,
 												[
 													1,
-													"ddx",
-													"*",
-													"ddx"
-												],
-												"+",
-												[
-													1,
-													"ddy",
-													"*",
-													"ddy"
-												]
-											],
-											"/",
-											[
-												6,
-												[
-													7,
-													"std",
-													"max"
+													[
+														1,
+														"ddx",
+														"*",
+														"ddx"
+													],
+													"+",
+													"ddySq"
 												],
-												[[
-													1,
-													"size",
-													"*",
-													"size"
-												], [5, "0.01"]]
+												"/",
+												"sizeSq"
 											]
-										]
-									],
-									[
-										11,
-										[
-											1,
-											"q",
-											"<",
-											[5, "2.6"]
 										],
-										[0, [
+										[
+											11,
 											[
-												13,
-												"wHard",
+												1,
+												"q",
+												"<",
+												"EXTQ"
+											],
+											[0, [
 												[
-													6,
-													"weightFn",
+													13,
+													"w",
 													[
-														"ddx",
-														"ddy",
-														"size",
-														[5, "0.9"],
+														6,
+														"profileFn",
 														[
-															6,
+															"q",
+															"ddx",
+															"ddy",
+															"size",
 															[
 																7,
-																"d",
-																"f32"
-															],
-															[[5, "0"]]
-														]
-													]
-												]
-											],
-											[
-												13,
-												"wSoft",
-												[
-													6,
-													[
-														7,
-														"std",
-														"exp"
-													],
-													[[
-														1,
-														"q",
-														"*",
-														[
-															4,
-															"-",
-															[5, "2.5"]
+																"prm",
+																"softness"
+															]
 														]
-													]]
-												]
-											],
-											[
-												13,
-												"w",
-												[
-													6,
-													[
-														7,
-														"std",
-														"mix"
-													],
-													[
-														"wHard",
-														"wSoft",
-														"softV"
 													]
-												]
-											],
-											[
-												13,
-												"e",
-												[
-													6,
-													[
-														7,
-														"d",
-														"u32"
-													],
-													[[
-														1,
-														[
-															1,
-															"w",
-															"*",
-															"bright"
-														],
-														"*",
-														[5, "256"]
-													]]
-												]
-											],
-											[
-												11,
+												],
 												[
-													1,
+													13,
 													"e",
-													">",
 													[
 														6,
 														[
@@ -2925,13 +3062,25 @@ function makeParticleSplatKernel(shape) {
 															"d",
 															"u32"
 														],
-														[[5, "0"]]
+														[[
+															1,
+															[
+																1,
+																"w",
+																"*",
+																"bright"
+															],
+															"*",
+															[5, "256"]
+														]]
 													]
 												],
-												[0, [
+												[
+													11,
 													[
-														13,
-														"idx",
+														1,
+														"e",
+														">",
 														[
 															6,
 															[
@@ -2939,92 +3088,119 @@ function makeParticleSplatKernel(shape) {
 																"d",
 																"u32"
 															],
-															[[
-																1,
-																[
-																	1,
-																	"py",
-																	"*",
-																	"OUT_RES"
-																],
-																"+",
-																"px"
-															]]
+															[[5, "0"]]
 														]
 													],
-													[
-														6,
+													[0, [
 														[
-															7,
-															"std",
-															"atomicAdd"
-														],
-														[[
-															8,
+															13,
+															"idx",
 															[
-																7,
+																6,
 																[
 																	7,
-																	"simLayout",
-																	"$"
+																	"d",
+																	"u32"
 																],
-																"accumE"
-															],
-															"idx"
-														], "e"]
-													],
-													[
-														6,
-														[
-															7,
-															"std",
-															"atomicAdd"
+																[[
+																	1,
+																	[
+																		1,
+																		"py",
+																		"*",
+																		[
+																			6,
+																			[
+																				7,
+																				"d",
+																				"i32"
+																			],
+																			["OUT_RES"]
+																		]
+																	],
+																	"+",
+																	"px"
+																]]
+															]
 														],
-														[[
-															8,
+														[
+															6,
 															[
 																7,
+																"std",
+																"atomicAdd"
+															],
+															[[
+																8,
 																[
 																	7,
-																	"simLayout",
-																	"$"
+																	[
+																		7,
+																		"simLayout",
+																		"$"
+																	],
+																	"accumE"
 																],
-																"accumS"
-															],
-															"idx"
-														], [
-															6,
+																"idx"
+															], "e"]
+														],
+														[
+															11,
+															"doSpeed",
 															[
-																7,
-																"d",
-																"u32"
-															],
-															[[
-																1,
+																6,
 																[
-																	1,
+																	7,
+																	"std",
+																	"atomicAdd"
+																],
+																[[
+																	8,
+																	[
+																		7,
+																		[
+																			7,
+																			"simLayout",
+																			"$"
+																		],
+																		"accumS"
+																	],
+																	"idx"
+																], [
+																	6,
 																	[
+																		7,
+																		"d",
+																		"u32"
+																	],
+																	[[
 																		1,
-																		"w",
+																		[
+																			1,
+																			[
+																				1,
+																				"w",
+																				"*",
+																				"bright"
+																			],
+																			"*",
+																			"speedNorm"
+																		],
 																		"*",
-																		"bright"
-																	],
-																	"*",
-																	"speedNorm"
-																],
-																"*",
-																[5, "256"]
-															]]
-														]]
-													]
-												]]
-											]
-										]]
-									]
-								]]
-							]
-						]]
-					]]]
+																		[5, "256"]
+																	]]
+																]]
+															]
+														]
+													]]
+												]
+											]]
+										]
+									]]
+								]
+							]]
+						]
+					]]
 				]
 			]],
 			"externalNames": [
@@ -3032,38 +3208,40 @@ function makeParticleSplatKernel(shape) {
 				"std",
 				"d",
 				"OUT_RES",
-				"SPLAT_R",
-				"FORCE_SOFT",
-				"SPLAT_WIN",
-				"weightFn"
+				"MAX_SPLAT_SIZE",
+				"EXT",
+				"EXTQ",
+				"profileFn"
 			]
 		},
 		externals: () => ({
 			simLayout,
-			std,
-			d,
+			std: std_exports,
+			d: data_exports,
 			OUT_RES,
-			SPLAT_R,
-			FORCE_SOFT,
-			SPLAT_WIN,
-			weightFn
+			MAX_SPLAT_SIZE,
+			EXT,
+			EXTQ,
+			profileFn
 		})
 	}) && $.f)({})).$name("particlesSplat");
 }
 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]));
+		atomicStore(simLayout.$.accumE[idx], u32(0));
+		atomicStore(simLayout.$.accumS[idx], u32(0));
 		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,
@@ -3178,6 +3356,64 @@ function makeParticleResolveKernel(colorSpaceMode) {
 						]]
 					]
 				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"atomicStore"
+					],
+					[[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"accumE"
+						],
+						"idx"
+					], [
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[5, "0"]]
+					]]
+				],
+				[
+					6,
+					[
+						7,
+						"std",
+						"atomicStore"
+					],
+					[[
+						8,
+						[
+							7,
+							[
+								7,
+								"simLayout",
+								"$"
+							],
+							"accumS"
+						],
+						"idx"
+					], [
+						6,
+						[
+							7,
+							"d",
+							"u32"
+						],
+						[[5, "0"]]
+					]]
+				],
 				[
 					13,
 					"energy",
@@ -3354,58 +3590,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 +5238,9 @@ function makeParticleUpdateKernel(evalSdf) {
 		},
 		externals: () => ({
 			simLayout,
-			d,
+			d: data_exports,
 			evalSdf,
-			std,
+			std: std_exports,
 			DOMAIN,
 			DGRID,
 			densTrilinear,
@@ -5274,11 +5507,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 +5545,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 +5685,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 +5997,8 @@ const componentDefinition = {
 				externals: () => ({
 					simLayout,
 					SVG_SDF_SIZE,
-					std,
-					d,
+					std: std_exports,
+					d: data_exports,
 					svgSdfLayout,
 					extrudeSdf
 				})
@@ -5783,7 +6016,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 +6062,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 +6212,10 @@ const componentDefinition = {
 				},
 				externals: () => ({
 					simLayout,
-					d,
+					d: data_exports,
 					sdf2d,
 					extrudeSdf,
-					std
+					std: std_exports
 				})
 			}) && $.f)({}));
 		}
@@ -6036,29 +6269,6 @@ const componentDefinition = {
 		}) && $.f)({}), { size: [DCELLS] }).with(simBg);
 		const density = mk1(particleDensityKernel);
 		const update = mk1(updateKernel);
-		const clearAccum = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
-			"use gpu";
-			particleClearAccumKernel(x, y);
-		}), {
-			v: 1,
-			name: void 0,
-			ast: {
-				"params": [{
-					"type": "i",
-					"name": "x"
-				}, {
-					"type": "i",
-					"name": "y"
-				}],
-				"body": [0, [[
-					6,
-					"particleClearAccumKernel",
-					["x", "y"]
-				]]],
-				"externalNames": ["particleClearAccumKernel"]
-			},
-			externals: () => ({ particleClearAccumKernel })
-		}) && $.f)({}), { size: [OUT_RES, OUT_RES] }).with(simBg);
 		const splat = mk1(splatKernel);
 		const resolve = createGuardedCompute(root, /* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x, y) => {
 			"use gpu";
@@ -6183,8 +6393,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),
@@ -6211,7 +6421,7 @@ const componentDefinition = {
 					rotC,
 					rotS,
 					aspect,
-					size: g("size", 2.2),
+					size: g("size", 2.2) * SIZE_SCALE,
 					exposure: g("exposure", 1),
 					softness: Math.min(Math.max(g("softness", .5), 0), 1),
 					speedColorK: 2 / MAX_SPEED,
@@ -6228,13 +6438,13 @@ const componentDefinition = {
 					deltaTime: dt,
 					pointer: fp.pointer
 				});
-				const count = Math.min(Math.max(Math.round(g("count", 4e3)), 16), MAX_PARTICLES);
+				const count = Math.min(Math.max(Math.round(g("count", 4e3)), 16), COUNT_CAP);
 				const nodes = [];
 				if (!initialized) {
 					initialized = true;
 					nodes.push(() => init.dispatchThreads(MAX_PARTICLES));
 				}
-				nodes.push(clearDensity, () => density.dispatchThreads(count), () => update.dispatchThreads(count), clearAccum, () => splat.dispatchThreads(count), resolve);
+				nodes.push(clearDensity, () => density.dispatchThreads(count), () => update.dispatchThreads(count), () => splat.dispatchThreads(count), resolve);
 				return nodes;
 			}
 		};
@@ -6246,4 +6456,4 @@ const componentDefinition = {
 	}
 };
 var Particles_default = componentDefinition;
-export { makeParticleUpdateKernel as a, particleDensityKernel as c, makeParticleSplatKernel as i, particleInitKernel as l, componentDefinition as n, particleClearAccumKernel as o, makeParticleResolveKernel as r, particleClearDensityKernel as s, Particles_default as t, particleSplatKernel as u };
+export { makeParticleUpdateKernel as a, particleInitKernel as c, makeParticleSplatKernel as i, particleSplatKernel as l, componentDefinition as n, particleClearDensityKernel as o, makeParticleResolveKernel as r, particleDensityKernel as s, Particles_default as t };