shaders 3.0.447 → 3.0.449

package/dist/core/{SmokeFill-CAayneM2.js → SmokeFill-CaDMgNW-.js}

@@ -1,7 +1,9 @@
-import { Bt as ZERO, F as sdf_exports, Ht as call, J as std, Jt as vec4, Tn as d, X as createGuardedCompute, Z as createStateBuffer, ln as colorMixing_exports, n as tgpu, y as sdf3d_exports } from "./coords-BkIjixe_.js";
-import { n as glass_exports } from "./glass-sOqjtPJD.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, Ct as floor, Dt as min, Et as max, F as colorMixing_exports, Gt as textureStorage2d, It as sin, Ot as mix, Rt as sqrt, Tt as length, Ut as arrayOf, Vt as data_exports, Wt as texture2d, Xt as struct, _t as clamp, an as f32, at as textureStore, d as ZERO, et as src_default, in as vec4f, it as textureLoad, mt as abs, nt as std_exports, on as i32, p as call, pt as select, sn as u32, tn as vec2u, vt as cos, xt as exp, y as vec4 } from "./edges-BXNBKxSN.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 { n as glass_exports } from "./glass-IfoQ8Prf.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV } = glass_exports;
 var { createSvgSdfSampler, createSdfDataTexture, SVG_SDF_SIZE, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS, buildAnalyticSdfFn } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS } = sdf3d_exports;
@@ -16,120 +18,120 @@ var PRESSURE_DISSIPATION = .8;
 var VELOCITY_DISSIPATION = .2;
 var STATE_FORMAT = "rgba16float";
 var cm = colorMixing_exports;
-var FillParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	dt: d.f32,
-	emitX: d.f32,
-	emitY: d.f32,
-	emitVelX: d.f32,
-	emitVelY: d.f32,
-	perpDirX: d.f32,
-	perpDirY: d.f32,
-	spreadFactor: d.f32,
-	emitRad: d.f32,
-	emitIntensity: d.f32,
-	densDissip: d.f32,
-	curlStrength: d.f32,
-	gravity: d.f32,
-	colorDecay: d.f32,
-	centerX: d.f32,
-	centerY: d.f32,
-	scale: d.f32,
-	rotation: d.f32,
-	aspect: d.f32,
-	cursorX: d.f32,
-	cursorY: d.f32,
-	cursorVelX: d.f32,
-	cursorVelY: d.f32,
-	mouseActive: 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,
-	vfOriginX: d.f32,
-	vfOriginY: d.f32,
-	vfSpanX: d.f32,
-	vfSpanY: d.f32,
-	vfActiveRes: d.f32
+var FillParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	dt: f32,
+	emitX: f32,
+	emitY: f32,
+	emitVelX: f32,
+	emitVelY: f32,
+	perpDirX: f32,
+	perpDirY: f32,
+	spreadFactor: f32,
+	emitRad: f32,
+	emitIntensity: f32,
+	densDissip: f32,
+	curlStrength: f32,
+	gravity: f32,
+	colorDecay: f32,
+	centerX: f32,
+	centerY: f32,
+	scale: f32,
+	rotation: f32,
+	aspect: f32,
+	cursorX: f32,
+	cursorY: f32,
+	cursorVelX: f32,
+	cursorVelY: f32,
+	mouseActive: f32,
+	mouseRadSq: f32,
+	saRadius: f32,
+	saSides: f32,
+	saRounding: f32,
+	saInnerRatio: f32,
+	saRotation: f32,
+	saHeight: f32,
+	saOffset: f32,
+	saAperture: f32,
+	vfOriginX: f32,
+	vfOriginY: f32,
+	vfSpanX: f32,
+	vfSpanY: f32,
+	vfActiveRes: f32
 }), "FillParams");
-var fluidLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var fluidLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	velA: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "mutable"
 	},
 	velB: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "mutable"
 	},
 	densA: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "mutable"
 	},
 	densB: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "mutable"
 	},
 	pressure: {
-		storage: d.arrayOf(d.f32, COUNT),
+		storage: arrayOf(f32, COUNT),
 		access: "mutable"
 	},
 	divergence: {
-		storage: d.arrayOf(d.f32, COUNT),
+		storage: arrayOf(f32, COUNT),
 		access: "mutable"
 	},
 	maskBuf: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "readonly"
 	},
 	params: { uniform: FillParams }
 }), "fluidLayout");
-var maskLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var maskLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	maskBuf: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "mutable"
 	},
 	params: { uniform: FillParams }
 }), "maskLayout");
-var maskSvgLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var maskSvgLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	maskBuf: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "mutable"
 	},
 	params: { uniform: FillParams },
-	sdfSource: { texture: d.texture2d(d.f32) }
+	sdfSource: { texture: texture2d(f32) }
 }), "maskSvgLayout");
-var maskVfLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var maskVfLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	maskBuf: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "mutable"
 	},
 	params: { uniform: FillParams },
 	fieldTex: {
-		texture: d.texture2d(d.f32),
+		texture: texture2d(f32),
 		sampleType: "unfilterable-float"
 	}
 }), "maskVfLayout");
-var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	densA: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "readonly"
 	},
-	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "outputLayout");
-var nidx = tgpu.fn([
-	d.i32,
-	d.i32,
-	d.i32,
-	d.i32
-], d.u32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ii, ji, di, dj) => {
+var nidx = src_default.fn([
+	i32,
+	i32,
+	i32,
+	i32
+], u32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ii, ji, di, dj) => {
 	"use gpu";
-	const row = std.clamp(__tsover_add(ii, di), 0, __tsover_sub(N, 1));
-	const col = std.clamp(__tsover_add(ji, dj), 0, __tsover_sub(N, 1));
-	return d.u32(__tsover_add(__tsover_mul(row, N), col));
+	const row = clamp(__tsover_add(ii, di), 0, __tsover_sub(N, 1));
+	const col = clamp(__tsover_add(ji, dj), 0, __tsover_sub(N, 1));
+	return u32(__tsover_add(__tsover_mul(row, N), col));
 }), {
 	v: 1,
 	name: void 0,
@@ -234,28 +236,28 @@ var nidx = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		N,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
 function makeMaskKernel(shapeType) {
 	const sdfFn = buildAnalyticSdfFn(shapeType);
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 		"use gpu";
 		const p = maskLayout.$.params;
-		const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-		const u = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(N));
-		const v = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(N));
+		const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+		const u = __tsover_div(__tsover_add(f32(cx), .5), f32(N));
+		const v = __tsover_div(__tsover_add(f32(cy), .5), f32(N));
 		const dxAc = __tsover_mul(__tsover_sub(u, p.centerX), p.aspect);
 		const dy = __tsover_sub(v, p.centerY);
-		const cosR = std.cos(p.rotation);
-		const sinR = std.sin(p.rotation);
+		const cosR = cos(p.rotation);
+		const sinR = sin(p.rotation);
 		const rdx = __tsover_add(__tsover_mul(dxAc, cosR), __tsover_mul(dy, sinR));
 		const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dxAc, sinR));
-		const res = sdfFn(d.vec2f(__tsover_add(__tsover_div(rdx, p.scale), .5), __tsover_add(__tsover_div(rdy, p.scale), .5)), p.saRadius, p.saSides, p.saRounding, p.saInnerRatio, p.saRotation, p.saHeight, p.saOffset, p.saAperture);
-		const inside = std.select(d.f32(0), d.f32(1), res.x < 0);
-		maskLayout.$.maskBuf[idx] = d.vec4f(inside, res.x, 0, 0);
+		const res = sdfFn(vec2f(__tsover_add(__tsover_div(rdx, p.scale), .5), __tsover_add(__tsover_div(rdy, p.scale), .5)), p.saRadius, p.saSides, p.saRounding, p.saInnerRatio, p.saRotation, p.saHeight, p.saOffset, p.saAperture);
+		const inside = select(f32(0), f32(1), res.x < 0);
+		maskLayout.$.maskBuf[idx] = vec4f(inside, res.x, 0, 0);
 	}), {
 		v: 1,
 		name: void 0,
@@ -657,32 +659,32 @@ function makeMaskKernel(shapeType) {
 		},
 		externals: () => ({
 			maskLayout,
-			d,
+			d: data_exports,
 			N,
-			std,
+			std: std_exports,
 			sdfFn
 		})
 	}) && $.f)({})).$name("smokeFillMask");
 }
-const svgMaskKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const svgMaskKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const p = maskSvgLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const u = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(N));
-	const v = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(N));
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const u = __tsover_div(__tsover_add(f32(cx), .5), f32(N));
+	const v = __tsover_div(__tsover_add(f32(cy), .5), f32(N));
 	const dxAc = __tsover_mul(__tsover_sub(u, p.centerX), p.aspect);
 	const dy = __tsover_sub(v, p.centerY);
-	const cosR = std.cos(p.rotation);
-	const sinR = std.sin(p.rotation);
+	const cosR = cos(p.rotation);
+	const sinR = sin(p.rotation);
 	const rdx = __tsover_add(__tsover_mul(dxAc, cosR), __tsover_mul(dy, sinR));
 	const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dxAc, sinR));
-	const sdfUV = d.vec2f(__tsover_add(__tsover_div(rdx, p.scale), .5), __tsover_add(__tsover_div(rdy, p.scale), .5));
+	const sdfUV = vec2f(__tsover_add(__tsover_div(rdx, p.scale), .5), __tsover_add(__tsover_div(rdy, p.scale), .5));
 	const sizeM1 = __tsover_sub(SVG_SDF_SIZE, 1);
-	const tx = std.clamp(d.i32(__tsover_mul(sdfUV.x, SVG_SDF_SIZE)), 0, sizeM1);
-	const ty = std.clamp(d.i32(__tsover_mul(sdfUV.y, SVG_SDF_SIZE)), 0, sizeM1);
-	const dist = std.textureLoad(maskSvgLayout.$.sdfSource, d.vec2u(d.u32(tx), d.u32(ty)), 0).x;
-	const inside = std.select(d.f32(0), d.f32(1), dist < 0);
-	maskSvgLayout.$.maskBuf[idx] = d.vec4f(inside, dist, 0, 0);
+	const tx = clamp(i32(__tsover_mul(sdfUV.x, SVG_SDF_SIZE)), 0, sizeM1);
+	const ty = clamp(i32(__tsover_mul(sdfUV.y, SVG_SDF_SIZE)), 0, sizeM1);
+	const dist = textureLoad(maskSvgLayout.$.sdfSource, vec2u(u32(tx), u32(ty)), 0).x;
+	const inside = select(f32(0), f32(1), dist < 0);
+	maskSvgLayout.$.maskBuf[idx] = vec4f(inside, dist, 0, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -1156,34 +1158,34 @@ const svgMaskKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThi
 	},
 	externals: () => ({
 		maskSvgLayout,
-		d,
+		d: data_exports,
 		N,
-		std,
+		std: std_exports,
 		SVG_SDF_SIZE
 	})
 }) && $.f)({})).$name("smokeFillSvgMask");
-const vfMaskKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const vfMaskKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const p = maskVfLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const u = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(N));
-	const v = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(N));
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const u = __tsover_div(__tsover_add(f32(cx), .5), f32(N));
+	const v = __tsover_div(__tsover_add(f32(cy), .5), f32(N));
 	const dxAc = __tsover_mul(__tsover_sub(u, p.centerX), p.aspect);
 	const dy = __tsover_sub(v, p.centerY);
-	const cosR = std.cos(p.rotation);
-	const sinR = std.sin(p.rotation);
+	const cosR = cos(p.rotation);
+	const sinR = sin(p.rotation);
 	const rdx = __tsover_add(__tsover_mul(dxAc, cosR), __tsover_mul(dy, sinR));
 	const rdy = __tsover_sub(__tsover_mul(dy, cosR), __tsover_mul(dxAc, sinR));
-	const sdfUV = d.vec2f(__tsover_add(__tsover_div(rdx, p.scale), .5), __tsover_add(__tsover_div(rdy, p.scale), .5));
-	const uxc = std.clamp(sdfUV.x, p.vfOriginX, __tsover_add(p.vfOriginX, p.vfSpanX));
-	const uyc = std.clamp(sdfUV.y, p.vfOriginY, __tsover_add(p.vfOriginY, p.vfSpanY));
-	const outsideDist = std.length(d.vec2f(__tsover_sub(sdfUV.x, uxc), __tsover_sub(sdfUV.y, uyc)));
+	const sdfUV = vec2f(__tsover_add(__tsover_div(rdx, p.scale), .5), __tsover_add(__tsover_div(rdy, p.scale), .5));
+	const uxc = clamp(sdfUV.x, p.vfOriginX, __tsover_add(p.vfOriginX, p.vfSpanX));
+	const uyc = clamp(sdfUV.y, p.vfOriginY, __tsover_add(p.vfOriginY, p.vfSpanY));
+	const outsideDist = length(vec2f(__tsover_sub(sdfUV.x, uxc), __tsover_sub(sdfUV.y, uyc)));
 	const maxT = __tsover_sub(p.vfActiveRes, 1);
-	const tx = std.clamp(__tsover_sub(__tsover_mul(__tsover_div(__tsover_sub(uxc, p.vfOriginX), p.vfSpanX), p.vfActiveRes), .5), d.f32(0), maxT);
-	const ty = std.clamp(__tsover_sub(__tsover_mul(__tsover_div(__tsover_sub(uyc, p.vfOriginY), p.vfSpanY), p.vfActiveRes), .5), d.f32(0), maxT);
-	const dist = __tsover_add(std.textureLoad(maskVfLayout.$.fieldTex, d.vec2u(d.u32(tx), d.u32(ty)), 0).x, outsideDist);
-	const inside = std.select(d.f32(0), d.f32(1), dist < 0);
-	maskVfLayout.$.maskBuf[idx] = d.vec4f(inside, dist, 0, 0);
+	const tx = clamp(__tsover_sub(__tsover_mul(__tsover_div(__tsover_sub(uxc, p.vfOriginX), p.vfSpanX), p.vfActiveRes), .5), f32(0), maxT);
+	const ty = clamp(__tsover_sub(__tsover_mul(__tsover_div(__tsover_sub(uyc, p.vfOriginY), p.vfSpanY), p.vfActiveRes), .5), f32(0), maxT);
+	const dist = __tsover_add(textureLoad(maskVfLayout.$.fieldTex, vec2u(u32(tx), u32(ty)), 0).x, outsideDist);
+	const inside = select(f32(0), f32(1), dist < 0);
+	maskVfLayout.$.maskBuf[idx] = vec4f(inside, dist, 0, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -1826,41 +1828,41 @@ const vfMaskKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis
 	},
 	externals: () => ({
 		maskVfLayout,
-		d,
+		d: data_exports,
 		N,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("smokeFillVfMask");
-const splatKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const splatKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const p = fluidLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
 	const mask = fluidLayout.$.maskBuf[idx].x;
-	const cellX = __tsover_add(d.f32(cx), .5);
-	const cellY = __tsover_add(d.f32(cy), .5);
+	const cellX = __tsover_add(f32(cx), .5);
+	const cellY = __tsover_add(f32(cy), .5);
 	const dx = __tsover_sub(cellX, p.emitX);
 	const dy = __tsover_sub(cellY, p.emitY);
 	const distSq = __tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy));
-	const radSq = std.max(__tsover_mul(p.emitRad, p.emitRad), d.f32(1));
-	const influence = __tsover_mul(std.exp(__tsover_mul(__tsover_div(distSq, radSq), -1)), mask);
+	const radSq = max(__tsover_mul(p.emitRad, p.emitRad), f32(1));
+	const influence = __tsover_mul(exp(__tsover_mul(__tsover_div(distSq, radSq), -1)), mask);
 	const cell = fluidLayout.$.densA[idx];
 	const oldDens = cell.x;
 	const addDens = __tsover_mul(__tsover_mul(__tsover_mul(p.emitIntensity, influence), p.dt), 8);
-	const newDens = std.min(__tsover_add(oldDens, addDens), 1);
-	const rejuvenate = __tsover_div(addDens, std.max(newDens, d.f32(.001)));
-	fluidLayout.$.densA[idx] = d.vec4f(newDens, __tsover_mul(cell.y, __tsover_sub(1, std.min(rejuvenate, 1))), 0, 0);
+	const newDens = min(__tsover_add(oldDens, addDens), 1);
+	const rejuvenate = __tsover_div(addDens, max(newDens, f32(.001)));
+	fluidLayout.$.densA[idx] = vec4f(newDens, __tsover_mul(cell.y, __tsover_sub(1, min(rejuvenate, 1))), 0, 0);
 	const vel = fluidLayout.$.velA[idx];
-	const perpOff = __tsover_div(__tsover_add(__tsover_mul(dx, p.perpDirX), __tsover_mul(dy, p.perpDirY)), std.max(p.emitRad, d.f32(1)));
-	const vmSq = std.max(__tsover_add(__tsover_mul(p.emitVelX, p.emitVelX), __tsover_mul(p.emitVelY, p.emitVelY)), d.f32(1));
-	const tvx = __tsover_add(p.emitVelX, __tsover_mul(__tsover_mul(__tsover_mul(p.perpDirX, perpOff), p.spreadFactor), std.sqrt(vmSq)));
-	const tvy = __tsover_add(p.emitVelY, __tsover_mul(__tsover_mul(__tsover_mul(p.perpDirY, perpOff), p.spreadFactor), std.sqrt(vmSq)));
-	const br = std.min(__tsover_mul(__tsover_mul(influence, p.dt), 3), 1);
+	const perpOff = __tsover_div(__tsover_add(__tsover_mul(dx, p.perpDirX), __tsover_mul(dy, p.perpDirY)), max(p.emitRad, f32(1)));
+	const vmSq = max(__tsover_add(__tsover_mul(p.emitVelX, p.emitVelX), __tsover_mul(p.emitVelY, p.emitVelY)), f32(1));
+	const tvx = __tsover_add(p.emitVelX, __tsover_mul(__tsover_mul(__tsover_mul(p.perpDirX, perpOff), p.spreadFactor), sqrt(vmSq)));
+	const tvy = __tsover_add(p.emitVelY, __tsover_mul(__tsover_mul(__tsover_mul(p.perpDirY, perpOff), p.spreadFactor), sqrt(vmSq)));
+	const br = min(__tsover_mul(__tsover_mul(influence, p.dt), 3), 1);
 	const gravForce = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(p.gravity, oldDens), p.dt), __tsover_mul(N, .08)), mask);
 	const cursorDX = __tsover_sub(cellX, p.cursorX);
 	const cursorDY = __tsover_sub(cellY, p.cursorY);
 	const cursorDistSq = __tsover_add(__tsover_mul(cursorDX, cursorDX), __tsover_mul(cursorDY, cursorDY));
-	const cursorInf = __tsover_mul(__tsover_mul(std.exp(__tsover_mul(__tsover_div(cursorDistSq, std.max(p.mouseRadSq, d.f32(1))), -1)), p.mouseActive), mask);
-	fluidLayout.$.velA[idx] = d.vec4f(__tsover_add(std.mix(vel.x, tvx, br), __tsover_mul(p.cursorVelX, cursorInf)), __tsover_add(__tsover_add(std.mix(vel.y, tvy, br), gravForce), __tsover_mul(p.cursorVelY, cursorInf)), vel.z, 0);
+	const cursorInf = __tsover_mul(__tsover_mul(exp(__tsover_mul(__tsover_div(cursorDistSq, max(p.mouseRadSq, f32(1))), -1)), p.mouseActive), mask);
+	fluidLayout.$.velA[idx] = vec4f(__tsover_add(mix(vel.x, tvx, br), __tsover_mul(p.cursorVelX, cursorInf)), __tsover_add(__tsover_add(mix(vel.y, tvy, br), gravForce), __tsover_mul(p.cursorVelY, cursorInf)), vel.z, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -2727,23 +2729,23 @@ const splatKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.
 	},
 	externals: () => ({
 		fluidLayout,
-		d,
+		d: data_exports,
 		N,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("smokeFillSplat");
-const curlKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const curlKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
 	const vL = fluidLayout.$.velA[nidx(ii, ji, 0, -1)];
 	const vR = fluidLayout.$.velA[nidx(ii, ji, 0, 1)];
 	const vU = fluidLayout.$.velA[nidx(ii, ji, -1, 0)];
 	const vD = fluidLayout.$.velA[nidx(ii, ji, 1, 0)];
 	const curl = __tsover_mul(__tsover_sub(__tsover_sub(vR.y, vL.y), __tsover_sub(vD.x, vU.x)), .5);
 	const vel = fluidLayout.$.velA[idx];
-	fluidLayout.$.velA[idx] = d.vec4f(vel.x, vel.y, curl, 0);
+	fluidLayout.$.velA[idx] = vec4f(vel.x, vel.y, curl, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -3023,28 +3025,28 @@ const curlKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis._
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx
 	})
 }) && $.f)({})).$name("smokeFillCurl");
-const vorticityKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const vorticityKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const p = fluidLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
-	const cL = std.abs(fluidLayout.$.velA[nidx(ii, ji, 0, -1)].z);
-	const cR = std.abs(fluidLayout.$.velA[nidx(ii, ji, 0, 1)].z);
-	const cU = std.abs(fluidLayout.$.velA[nidx(ii, ji, -1, 0)].z);
-	const cD = std.abs(fluidLayout.$.velA[nidx(ii, ji, 1, 0)].z);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
+	const cL = abs(fluidLayout.$.velA[nidx(ii, ji, 0, -1)].z);
+	const cR = abs(fluidLayout.$.velA[nidx(ii, ji, 0, 1)].z);
+	const cU = abs(fluidLayout.$.velA[nidx(ii, ji, -1, 0)].z);
+	const cD = abs(fluidLayout.$.velA[nidx(ii, ji, 1, 0)].z);
 	const cc = fluidLayout.$.velA[idx].z;
 	const gx = __tsover_mul(__tsover_sub(cR, cL), .5);
 	const gy = __tsover_mul(__tsover_sub(cD, cU), .5);
-	const gl = std.max(std.sqrt(__tsover_add(__tsover_mul(gx, gx), __tsover_mul(gy, gy))), d.f32(1e-5));
+	const gl = max(sqrt(__tsover_add(__tsover_mul(gx, gx), __tsover_mul(gy, gy))), f32(1e-5));
 	const vel = fluidLayout.$.velA[idx];
-	fluidLayout.$.velA[idx] = d.vec4f(__tsover_add(vel.x, __tsover_mul(__tsover_mul(__tsover_mul(__tsover_div(gy, gl), cc), p.curlStrength), p.dt)), __tsover_add(vel.y, __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_div(gx, gl), -1), cc), p.curlStrength), p.dt)), vel.z, 0);
+	fluidLayout.$.velA[idx] = vec4f(__tsover_add(vel.x, __tsover_mul(__tsover_mul(__tsover_mul(__tsover_div(gy, gl), cc), p.curlStrength), p.dt)), __tsover_add(vel.y, __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_div(gx, gl), -1), cc), p.curlStrength), p.dt)), vel.z, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -3520,29 +3522,29 @@ const vorticityKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalT
 	},
 	externals: () => ({
 		fluidLayout,
-		d,
+		d: data_exports,
 		N,
-		std,
+		std: std_exports,
 		nidx
 	})
 }) && $.f)({})).$name("smokeFillVorticity");
-const divergenceKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const divergenceKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
-	const jf = d.f32(cx);
-	const iF = d.f32(cy);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
+	const jf = f32(cx);
+	const iF = f32(cy);
 	const selfMask = fluidLayout.$.maskBuf[idx].x;
 	const selfVel = fluidLayout.$.velA[idx];
 	const isWallL = jf < .5 || fluidLayout.$.maskBuf[nidx(ii, ji, 0, -1)].x < .5;
-	const isWallR = jf > d.f32(__tsover_sub(N, 1.5)) || fluidLayout.$.maskBuf[nidx(ii, ji, 0, 1)].x < .5;
+	const isWallR = jf > f32(__tsover_sub(N, 1.5)) || fluidLayout.$.maskBuf[nidx(ii, ji, 0, 1)].x < .5;
 	const isWallT = iF < .5 || fluidLayout.$.maskBuf[nidx(ii, ji, -1, 0)].x < .5;
-	const isWallB = iF > d.f32(__tsover_sub(N, 1.5)) || fluidLayout.$.maskBuf[nidx(ii, ji, 1, 0)].x < .5;
-	const L = std.select(fluidLayout.$.velA[nidx(ii, ji, 0, -1)].x, __tsover_mul(selfVel.x, -1), isWallL);
-	const R = std.select(fluidLayout.$.velA[nidx(ii, ji, 0, 1)].x, __tsover_mul(selfVel.x, -1), isWallR);
-	const T = std.select(fluidLayout.$.velA[nidx(ii, ji, -1, 0)].y, __tsover_mul(selfVel.y, -1), isWallT);
-	const B = std.select(fluidLayout.$.velA[nidx(ii, ji, 1, 0)].y, __tsover_mul(selfVel.y, -1), isWallB);
+	const isWallB = iF > f32(__tsover_sub(N, 1.5)) || fluidLayout.$.maskBuf[nidx(ii, ji, 1, 0)].x < .5;
+	const L = select(fluidLayout.$.velA[nidx(ii, ji, 0, -1)].x, __tsover_mul(selfVel.x, -1), isWallL);
+	const R = select(fluidLayout.$.velA[nidx(ii, ji, 0, 1)].x, __tsover_mul(selfVel.x, -1), isWallR);
+	const T = select(fluidLayout.$.velA[nidx(ii, ji, -1, 0)].y, __tsover_mul(selfVel.y, -1), isWallT);
+	const B = select(fluidLayout.$.velA[nidx(ii, ji, 1, 0)].y, __tsover_mul(selfVel.y, -1), isWallB);
 	const div = __tsover_mul(__tsover_mul(__tsover_add(__tsover_sub(R, L), __tsover_sub(B, T)), .5), selfMask);
 	fluidLayout.$.pressure[idx] = __tsover_mul(__tsover_mul(fluidLayout.$.pressure[idx], PRESSURE_DISSIPATION), selfMask);
 	fluidLayout.$.divergence[idx] = div;
@@ -4212,19 +4214,19 @@ const divergenceKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (global
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx,
-		std,
+		std: std_exports,
 		PRESSURE_DISSIPATION
 	})
 }) && $.f)({})).$name("smokeFillDivergence");
-const jacobiKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const jacobiKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
 	const pL = fluidLayout.$.pressure[nidx(ii, ji, 0, -1)];
 	const pR = fluidLayout.$.pressure[nidx(ii, ji, 0, 1)];
 	const pU = fluidLayout.$.pressure[nidx(ii, ji, -1, 0)];
@@ -4473,23 +4475,23 @@ const jacobiKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx
 	})
 }) && $.f)({})).$name("smokeFillJacobi");
-const gradSubtractKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const gradSubtractKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
 	const pL = fluidLayout.$.pressure[nidx(ii, ji, 0, -1)];
 	const pR = fluidLayout.$.pressure[nidx(ii, ji, 0, 1)];
 	const pU = fluidLayout.$.pressure[nidx(ii, ji, -1, 0)];
 	const pD = fluidLayout.$.pressure[nidx(ii, ji, 1, 0)];
 	const vel = fluidLayout.$.velA[idx];
-	fluidLayout.$.velA[idx] = d.vec4f(__tsover_sub(vel.x, __tsover_mul(__tsover_sub(pR, pL), .5)), __tsover_sub(vel.y, __tsover_mul(__tsover_sub(pD, pU), .5)), vel.z, 0);
+	fluidLayout.$.velA[idx] = vec4f(__tsover_sub(vel.x, __tsover_mul(__tsover_sub(pR, pL), .5)), __tsover_sub(vel.y, __tsover_mul(__tsover_sub(pD, pU), .5)), vel.z, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -4762,32 +4764,32 @@ const gradSubtractKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (glob
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx
 	})
 }) && $.f)({})).$name("smokeFillGradSubtract");
-const advectVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const advectVelKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const p = fluidLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
 	const vel = fluidLayout.$.velA[idx];
-	const srcX = std.clamp(__tsover_sub(d.f32(cx), __tsover_mul(vel.x, p.dt)), 0, d.f32(__tsover_sub(N, 1)));
-	const srcY = std.clamp(__tsover_sub(d.f32(cy), __tsover_mul(vel.y, p.dt)), 0, d.f32(__tsover_sub(N, 1)));
-	const x0 = std.clamp(std.floor(srcX), 0, d.f32(__tsover_sub(N, 2)));
-	const y0 = std.clamp(std.floor(srcY), 0, d.f32(__tsover_sub(N, 2)));
+	const srcX = clamp(__tsover_sub(f32(cx), __tsover_mul(vel.x, p.dt)), 0, f32(__tsover_sub(N, 1)));
+	const srcY = clamp(__tsover_sub(f32(cy), __tsover_mul(vel.y, p.dt)), 0, f32(__tsover_sub(N, 1)));
+	const x0 = clamp(floor(srcX), 0, f32(__tsover_sub(N, 2)));
+	const y0 = clamp(floor(srcY), 0, f32(__tsover_sub(N, 2)));
 	const sx = __tsover_sub(srcX, x0);
 	const sy = __tsover_sub(srcY, y0);
-	const ix0 = d.i32(x0);
-	const iy0 = d.i32(y0);
-	const v00 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_mul(iy0, N), ix0))];
-	const v10 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_add(__tsover_mul(iy0, N), ix0), 1))];
-	const v01 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0))];
-	const v11 = fluidLayout.$.velA[d.u32(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0), 1))];
+	const ix0 = i32(x0);
+	const iy0 = i32(y0);
+	const v00 = fluidLayout.$.velA[u32(__tsover_add(__tsover_mul(iy0, N), ix0))];
+	const v10 = fluidLayout.$.velA[u32(__tsover_add(__tsover_add(__tsover_mul(iy0, N), ix0), 1))];
+	const v01 = fluidLayout.$.velA[u32(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0))];
+	const v11 = fluidLayout.$.velA[u32(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0), 1))];
 	const decay = __tsover_add(1, __tsover_mul(VELOCITY_DISSIPATION, p.dt));
 	const mask = fluidLayout.$.maskBuf[idx].x;
-	fluidLayout.$.velB[idx] = d.vec4f(__tsover_mul(__tsover_div(std.mix(std.mix(v00.x, v10.x, sx), std.mix(v01.x, v11.x, sx), sy), decay), mask), __tsover_mul(__tsover_div(std.mix(std.mix(v00.y, v10.y, sx), std.mix(v01.y, v11.y, sx), sy), decay), mask), 0, 0);
+	fluidLayout.$.velB[idx] = vec4f(__tsover_mul(__tsover_div(mix(mix(v00.x, v10.x, sx), mix(v01.x, v11.x, sx), sy), decay), mask), __tsover_mul(__tsover_div(mix(mix(v00.y, v10.y, sx), mix(v01.y, v11.y, sx), sy), decay), mask), 0, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -5453,17 +5455,17 @@ const advectVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalT
 	},
 	externals: () => ({
 		fluidLayout,
-		d,
+		d: data_exports,
 		N,
-		std,
+		std: std_exports,
 		VELOCITY_DISSIPATION
 	})
 }) && $.f)({})).$name("smokeFillAdvectVel");
-const copyVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const copyVelKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
 	const v = fluidLayout.$.velB[idx];
-	fluidLayout.$.velA[idx] = d.vec4f(v.x, v.y, 0, 0);
+	fluidLayout.$.velA[idx] = vec4f(v.x, v.y, 0, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -5563,33 +5565,33 @@ const copyVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThi
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout
 	})
 }) && $.f)({})).$name("smokeFillCopyVel");
-const advectDensKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const advectDensKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const p = fluidLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
 	const vel = fluidLayout.$.velA[idx];
-	const srcX = std.clamp(__tsover_sub(d.f32(cx), __tsover_mul(vel.x, p.dt)), 0, d.f32(__tsover_sub(N, 1)));
-	const srcY = std.clamp(__tsover_sub(d.f32(cy), __tsover_mul(vel.y, p.dt)), 0, d.f32(__tsover_sub(N, 1)));
-	const x0 = std.clamp(std.floor(srcX), 0, d.f32(__tsover_sub(N, 2)));
-	const y0 = std.clamp(std.floor(srcY), 0, d.f32(__tsover_sub(N, 2)));
+	const srcX = clamp(__tsover_sub(f32(cx), __tsover_mul(vel.x, p.dt)), 0, f32(__tsover_sub(N, 1)));
+	const srcY = clamp(__tsover_sub(f32(cy), __tsover_mul(vel.y, p.dt)), 0, f32(__tsover_sub(N, 1)));
+	const x0 = clamp(floor(srcX), 0, f32(__tsover_sub(N, 2)));
+	const y0 = clamp(floor(srcY), 0, f32(__tsover_sub(N, 2)));
 	const sx = __tsover_sub(srcX, x0);
 	const sy = __tsover_sub(srcY, y0);
-	const ix0 = d.i32(x0);
-	const iy0 = d.i32(y0);
-	const d00 = fluidLayout.$.densA[d.u32(__tsover_add(__tsover_mul(iy0, N), ix0))];
-	const d10 = fluidLayout.$.densA[d.u32(__tsover_add(__tsover_add(__tsover_mul(iy0, N), ix0), 1))];
-	const d01 = fluidLayout.$.densA[d.u32(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0))];
-	const d11 = fluidLayout.$.densA[d.u32(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0), 1))];
-	const dens = std.mix(std.mix(d00.x, d10.x, sx), std.mix(d01.x, d11.x, sx), sy);
-	const age = std.mix(std.mix(d00.y, d10.y, sx), std.mix(d01.y, d11.y, sx), sy);
+	const ix0 = i32(x0);
+	const iy0 = i32(y0);
+	const d00 = fluidLayout.$.densA[u32(__tsover_add(__tsover_mul(iy0, N), ix0))];
+	const d10 = fluidLayout.$.densA[u32(__tsover_add(__tsover_add(__tsover_mul(iy0, N), ix0), 1))];
+	const d01 = fluidLayout.$.densA[u32(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0))];
+	const d11 = fluidLayout.$.densA[u32(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0), 1))];
+	const dens = mix(mix(d00.x, d10.x, sx), mix(d01.x, d11.x, sx), sy);
+	const age = mix(mix(d00.y, d10.y, sx), mix(d01.y, d11.y, sx), sy);
 	const decay = __tsover_add(1, __tsover_mul(p.densDissip, p.dt));
 	const mask = fluidLayout.$.maskBuf[idx].x;
-	fluidLayout.$.densB[idx] = d.vec4f(__tsover_mul(std.max(__tsover_div(dens, decay), d.f32(0)), mask), std.min(__tsover_add(age, __tsover_mul(__tsover_mul(p.dt, .4), p.colorDecay)), 1), 0, 0);
+	fluidLayout.$.densB[idx] = vec4f(__tsover_mul(max(__tsover_div(dens, decay), f32(0)), mask), min(__tsover_add(age, __tsover_mul(__tsover_mul(p.dt, .4), p.colorDecay)), 1), 0, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -6305,16 +6307,16 @@ const advectDensKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (global
 	},
 	externals: () => ({
 		fluidLayout,
-		d,
+		d: data_exports,
 		N,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("smokeFillAdvectDens");
-const copyDensKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const copyDensKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
 	const dd = fluidLayout.$.densB[idx];
-	fluidLayout.$.densA[idx] = d.vec4f(dd.x, dd.y, 0, 0);
+	fluidLayout.$.densA[idx] = vec4f(dd.x, dd.y, 0, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -6414,16 +6416,16 @@ const copyDensKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalTh
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout
 	})
 }) && $.f)({})).$name("smokeFillCopyDens");
-const outputKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const outputKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
 	const dd = outputLayout.$.densA[idx];
-	std.textureStore(outputLayout.$.outTex, d.vec2u(cx, cy), d.vec4f(dd.x, dd.y, 0, 0));
+	textureStore(outputLayout.$.outTex, vec2u(cx, cy), vec4f(dd.x, dd.y, 0, 0));
 }), {
 	v: 1,
 	name: void 0,
@@ -6535,15 +6537,15 @@ const outputKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		outputLayout,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("smokeFillOutput");
-const smokeFillShapeMask = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist) => {
+const smokeFillShapeMask = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dist) => {
 	"use gpu";
-	return std.clamp(__tsover_mul(__tsover_mul(dist, -1), __tsover_mul(N, 4)), 0, 1);
+	return clamp(__tsover_mul(__tsover_mul(dist, -1), __tsover_mul(N, 4)), 0, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -6587,7 +6589,7 @@ const smokeFillShapeMask = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (glob
 		"externalNames": ["std", "N"]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		N
 	})
 }) && $.f)({}));
@@ -6855,13 +6857,13 @@ const componentDefinition = {
 		const shapeSdfUrl = getCpuValue("shapeSdfUrl") || "";
 		const shapeType = resolveShapeType(getCpuValue("shapeType") || "", getCpuValue("shape"));
 		const vf = createVolumetricFieldComputeNode(params, () => getCpuValue("shape"), "none");
-		const velA = createStateBuffer(root, d.vec4f, COUNT);
-		const velB = createStateBuffer(root, d.vec4f, COUNT);
-		const densA = createStateBuffer(root, d.vec4f, COUNT);
-		const densB = createStateBuffer(root, d.vec4f, COUNT);
-		const pressure = createStateBuffer(root, d.f32, COUNT);
-		const divergence = createStateBuffer(root, d.f32, COUNT);
-		const maskBuf = createStateBuffer(root, d.vec4f, COUNT);
+		const velA = createStateBuffer(root, vec4f, COUNT);
+		const velB = createStateBuffer(root, vec4f, COUNT);
+		const densA = createStateBuffer(root, vec4f, COUNT);
+		const densB = createStateBuffer(root, vec4f, COUNT);
+		const pressure = createStateBuffer(root, f32, COUNT);
+		const divergence = createStateBuffer(root, f32, COUNT);
+		const maskBuf = createStateBuffer(root, vec4f, COUNT);
 		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [N, N],
 			format: STATE_FORMAT