shaders 3.0.447 → 3.0.449

package/dist/core/{InkFlow-DJaJqula.js → InkFlow-BH86usRX.js}

@@ -1,5 +1,6 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, X as createGuardedCompute, Z as createStateBuffer, _n as mixPreconvertedLinear, n as tgpu, un as convertP3ToMixSpaceCPU, vn as mixPreconvertedVariants } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { Ct as floor, Et as max, G as mixPreconvertedLinear, Gt as textureStorage2d, K as mixPreconvertedVariants, L as convertP3ToMixSpaceCPU, Ot as mix, Rt as sqrt, Ut as arrayOf, Vt as data_exports, Xt as struct, _ as floatE, _t as clamp, an as f32, at as textureStore, d as ZERO, et as src_default, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, on as i32, p as call, pt as select, sn as u32, tn as vec2u, xt as exp, y as vec4 } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var N = 256;
 var COUNT = N * N;
 var JACOBI_ITERS = 10;
@@ -12,82 +13,82 @@ var CYCLE_TIME_RATE = .06;
 var VEL_FADE_MAX = 4;
 var VEL_FADE_MIN = .05;
 var GAIN = 1.35;
-var FlowParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	dt: d.f32,
-	curlStrength: d.f32,
-	velFade: d.f32,
-	dyeFade: d.f32
+var FlowParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	dt: f32,
+	curlStrength: f32,
+	velFade: f32,
+	dyeFade: f32
 }), "FlowParams");
-var SplatParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	posX: d.f32,
-	posY: d.f32,
-	velX: d.f32,
-	velY: d.f32,
-	colR: d.f32,
-	colG: d.f32,
-	colB: d.f32,
-	col2R: d.f32,
-	col2G: d.f32,
-	col2B: d.f32,
-	mixT: d.f32,
-	radius: d.f32,
-	strength: d.f32
+var SplatParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	posX: f32,
+	posY: f32,
+	velX: f32,
+	velY: f32,
+	colR: f32,
+	colG: f32,
+	colB: f32,
+	col2R: f32,
+	col2G: f32,
+	col2B: f32,
+	mixT: f32,
+	radius: f32,
+	strength: f32
 }), "SplatParams");
-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"
 	},
 	dyeA: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "mutable"
 	},
 	dyeB: {
-		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"
 	},
 	params: { uniform: FlowParams }
 }), "fluidLayout");
-var splatLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var splatLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	velA: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "mutable"
 	},
 	dyeA: {
-		storage: d.arrayOf(d.vec4f, COUNT),
+		storage: arrayOf(vec4f, COUNT),
 		access: "mutable"
 	},
 	sparams: { uniform: SplatParams }
 }), "splatLayout");
-var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	dyeA: {
-		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,
@@ -192,30 +193,30 @@ var nidx = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		N,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
 var makeSplatKernel = (colorSpaceMode) => {
 	const mixFn = mixPreconvertedVariants[colorSpaceMode] ?? mixPreconvertedLinear;
-	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 = splatLayout.$.sparams;
-		const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
-		const cellX = __tsover_add(d.f32(cx), .5);
-		const cellY = __tsover_add(d.f32(cy), .5);
+		const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+		const cellX = __tsover_add(f32(cx), .5);
+		const cellY = __tsover_add(f32(cy), .5);
 		const dx = __tsover_sub(cellX, p.posX);
 		const dy = __tsover_sub(cellY, p.posY);
 		const distSq = __tsover_add(__tsover_mul(dx, dx), __tsover_mul(dy, dy));
-		const radSq = std.max(__tsover_mul(p.radius, p.radius), d.f32(1));
-		const inf = std.exp(__tsover_mul(__tsover_div(distSq, radSq), -1));
-		const w = std.clamp(__tsover_mul(inf, p.strength), d.f32(0), d.f32(1));
-		const brush = mixFn(d.vec3f(p.colR, p.colG, p.colB), d.vec3f(p.col2R, p.col2G, p.col2B), 1, 1, p.mixT);
+		const radSq = max(__tsover_mul(p.radius, p.radius), f32(1));
+		const inf = exp(__tsover_mul(__tsover_div(distSq, radSq), -1));
+		const w = clamp(__tsover_mul(inf, p.strength), f32(0), f32(1));
+		const brush = mixFn(vec3f(p.colR, p.colG, p.colB), vec3f(p.col2R, p.col2G, p.col2B), 1, 1, p.mixT);
 		const cell = splatLayout.$.dyeA[idx];
-		splatLayout.$.dyeA[idx] = d.vec4f(std.mix(cell.x, brush.x, w), std.mix(cell.y, brush.y, w), std.mix(cell.z, brush.z, w), 0);
+		splatLayout.$.dyeA[idx] = vec4f(mix(cell.x, brush.x, w), mix(cell.y, brush.y, w), mix(cell.z, brush.z, w), 0);
 		const vel = splatLayout.$.velA[idx];
-		splatLayout.$.velA[idx] = d.vec4f(__tsover_add(vel.x, __tsover_mul(p.velX, inf)), __tsover_add(vel.y, __tsover_mul(p.velY, inf)), vel.z, 0);
+		splatLayout.$.velA[idx] = vec4f(__tsover_add(vel.x, __tsover_mul(p.velX, inf)), __tsover_add(vel.y, __tsover_mul(p.velY, inf)), vel.z, 0);
 	}), {
 		v: 1,
 		name: void 0,
@@ -725,9 +726,9 @@ var makeSplatKernel = (colorSpaceMode) => {
 		},
 		externals: () => ({
 			splatLayout,
-			d,
+			d: data_exports,
 			N,
-			std,
+			std: std_exports,
 			mixFn
 		})
 	}) && $.f)({})).$name(`inkFlowSplat${colorSpaceMode}`);
@@ -741,18 +742,18 @@ var splatKernelVariants = {
 	5: makeSplatKernel(5)
 };
 const splatKernel = splatKernelVariants[2];
-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,
@@ -1032,30 +1033,30 @@ const curlKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis._
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx
 	})
 }) && $.f)({})).$name("inkFlowCurl");
-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 fx = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_div(gy, gl), cc), p.curlStrength), p.dt);
 	const fy = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_div(gx, gl), -1), cc), p.curlStrength), p.dt);
 	const vel = fluidLayout.$.velA[idx];
-	fluidLayout.$.velA[idx] = d.vec4f(__tsover_add(vel.x, fx), __tsover_add(vel.y, fy), vel.z, 0);
+	fluidLayout.$.velA[idx] = vec4f(__tsover_add(vel.x, fx), __tsover_add(vel.y, fy), vel.z, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -1541,28 +1542,28 @@ const vorticityKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalT
 	},
 	externals: () => ({
 		fluidLayout,
-		d,
+		d: data_exports,
 		N,
-		std,
+		std: std_exports,
 		nidx
 	})
 }) && $.f)({})).$name("inkFlowVorticity");
-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 selfVel = fluidLayout.$.velA[idx];
 	const normalL = fluidLayout.$.velA[nidx(ii, ji, 0, -1)].x;
 	const normalR = fluidLayout.$.velA[nidx(ii, ji, 0, 1)].x;
 	const normalU = fluidLayout.$.velA[nidx(ii, ji, -1, 0)].y;
 	const normalD = fluidLayout.$.velA[nidx(ii, ji, 1, 0)].y;
-	const L = std.select(normalL, __tsover_mul(selfVel.x, -1), jf < .5);
-	const R = std.select(normalR, __tsover_mul(selfVel.x, -1), jf > d.f32(__tsover_sub(N, 1.5)));
-	const T = std.select(normalU, __tsover_mul(selfVel.y, -1), iF < .5);
-	const B = std.select(normalD, __tsover_mul(selfVel.y, -1), iF > d.f32(__tsover_sub(N, 1.5)));
+	const L = select(normalL, __tsover_mul(selfVel.x, -1), jf < .5);
+	const R = select(normalR, __tsover_mul(selfVel.x, -1), jf > f32(__tsover_sub(N, 1.5)));
+	const T = select(normalU, __tsover_mul(selfVel.y, -1), iF < .5);
+	const B = select(normalD, __tsover_mul(selfVel.y, -1), iF > f32(__tsover_sub(N, 1.5)));
 	const div = __tsover_mul(__tsover_add(__tsover_sub(R, L), __tsover_sub(B, T)), .5);
 	fluidLayout.$.pressure[idx] = __tsover_mul(fluidLayout.$.pressure[idx], PRESSURE_DISSIPATION);
 	fluidLayout.$.divergence[idx] = div;
@@ -2053,19 +2054,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("inkFlowDivergence");
-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)];
@@ -2314,23 +2315,23 @@ const jacobiKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx
 	})
 }) && $.f)({})).$name("inkFlowJacobi");
-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,
@@ -2603,31 +2604,31 @@ const gradSubtractKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (glob
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout,
 		nidx
 	})
 }) && $.f)({})).$name("inkFlowGradSubtract");
-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(p.velFade, p.dt));
-	fluidLayout.$.velB[idx] = d.vec4f(__tsover_div(std.mix(std.mix(v00.x, v10.x, sx), std.mix(v01.x, v11.x, sx), sy), decay), __tsover_div(std.mix(std.mix(v00.y, v10.y, sx), std.mix(v01.y, v11.y, sx), sy), decay), 0, 0);
+	fluidLayout.$.velB[idx] = vec4f(__tsover_div(mix(mix(v00.x, v10.x, sx), mix(v01.x, v11.x, sx), sy), decay), __tsover_div(mix(mix(v00.y, v10.y, sx), mix(v01.y, v11.y, sx), sy), decay), 0, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -3265,16 +3266,16 @@ const advectVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalT
 	},
 	externals: () => ({
 		fluidLayout,
-		d,
+		d: data_exports,
 		N,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("inkFlowAdvectVel");
-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,
@@ -3374,33 +3375,33 @@ const copyVelKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThi
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout
 	})
 }) && $.f)({})).$name("inkFlowCopyVel");
-const advectDyeKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const advectDyeKernel = 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 c00 = fluidLayout.$.dyeA[d.u32(__tsover_add(__tsover_mul(iy0, N), ix0))];
-	const c10 = fluidLayout.$.dyeA[d.u32(__tsover_add(__tsover_add(__tsover_mul(iy0, N), ix0), 1))];
-	const c01 = fluidLayout.$.dyeA[d.u32(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0))];
-	const c11 = fluidLayout.$.dyeA[d.u32(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0), 1))];
-	const r = std.mix(std.mix(c00.x, c10.x, sx), std.mix(c01.x, c11.x, sx), sy);
-	const g = std.mix(std.mix(c00.y, c10.y, sx), std.mix(c01.y, c11.y, sx), sy);
-	const b = std.mix(std.mix(c00.z, c10.z, sx), std.mix(c01.z, c11.z, sx), sy);
+	const ix0 = i32(x0);
+	const iy0 = i32(y0);
+	const c00 = fluidLayout.$.dyeA[u32(__tsover_add(__tsover_mul(iy0, N), ix0))];
+	const c10 = fluidLayout.$.dyeA[u32(__tsover_add(__tsover_add(__tsover_mul(iy0, N), ix0), 1))];
+	const c01 = fluidLayout.$.dyeA[u32(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0))];
+	const c11 = fluidLayout.$.dyeA[u32(__tsover_add(__tsover_add(__tsover_mul(__tsover_add(iy0, 1), N), ix0), 1))];
+	const r = mix(mix(c00.x, c10.x, sx), mix(c01.x, c11.x, sx), sy);
+	const g = mix(mix(c00.y, c10.y, sx), mix(c01.y, c11.y, sx), sy);
+	const b = mix(mix(c00.z, c10.z, sx), mix(c01.z, c11.z, sx), sy);
 	const decay = __tsover_add(1, __tsover_mul(p.dyeFade, p.dt));
-	fluidLayout.$.dyeB[idx] = d.vec4f(std.max(__tsover_div(r, decay), d.f32(0)), std.max(__tsover_div(g, decay), d.f32(0)), std.max(__tsover_div(b, decay), d.f32(0)), 0);
+	fluidLayout.$.dyeB[idx] = vec4f(max(__tsover_div(r, decay), f32(0)), max(__tsover_div(g, decay), f32(0)), max(__tsover_div(b, decay), f32(0)), 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -4158,16 +4159,16 @@ const advectDyeKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalT
 	},
 	externals: () => ({
 		fluidLayout,
-		d,
+		d: data_exports,
 		N,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("inkFlowAdvectDye");
-const copyDyeKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const copyDyeKernel = 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 c = fluidLayout.$.dyeB[idx];
-	fluidLayout.$.dyeA[idx] = d.vec4f(c.x, c.y, c.z, 0);
+	fluidLayout.$.dyeA[idx] = vec4f(c.x, c.y, c.z, 0);
 }), {
 	v: 1,
 	name: void 0,
@@ -4271,16 +4272,16 @@ const copyDyeKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThi
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		fluidLayout
 	})
 }) && $.f)({})).$name("inkFlowCopyDye");
-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 c = outputLayout.$.dyeA[idx];
-	std.textureStore(outputLayout.$.outTex, d.vec2u(cx, cy), d.vec4f(c.x, c.y, c.z, 1));
+	textureStore(outputLayout.$.outTex, vec2u(cx, cy), vec4f(c.x, c.y, c.z, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -4396,17 +4397,16 @@ const outputKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		outputLayout,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("inkFlowOutput");
-const inkFlowComposite = tgpu.fn([d.vec3f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dye, gain) => {
+const inkFlowComposite = src_default.fn([vec3f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((dye, gain) => {
 	"use gpu";
-	const lum = std.max(dye.x, std.max(dye.y, dye.z));
-	const coverage = std.clamp(__tsover_mul(lum, gain), d.f32(0), d.f32(1));
-	return d.vec4f(dye, coverage);
+	const lum = max(dye.x, max(dye.y, dye.z));
+	return vec4f(dye, clamp(__tsover_mul(lum, gain), f32(0), f32(1)));
 }), {
 	v: 1,
 	name: void 0,
@@ -4503,8 +4503,8 @@ const inkFlowComposite = tgpu.fn([d.vec3f, d.f32], d.vec4f)(/* @__PURE__ */ (($)
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({})).$name("inkFlowComposite");
 function srgbToLinear(c) {
@@ -4716,12 +4716,12 @@ const componentDefinition = {
 		const { gpu, getCpuValue, propValues, registerComputeTexture, onCleanup } = params;
 		const root = gpu?.root;
 		if (!root) return null;
-		const velA = createStateBuffer(root, d.vec4f, COUNT);
-		const velB = createStateBuffer(root, d.vec4f, COUNT);
-		const dyeA = createStateBuffer(root, d.vec4f, COUNT);
-		const dyeB = createStateBuffer(root, d.vec4f, COUNT);
-		const pressure = createStateBuffer(root, d.f32, COUNT);
-		const divergence = createStateBuffer(root, d.f32, COUNT);
+		const velA = createStateBuffer(root, vec4f, COUNT);
+		const velB = createStateBuffer(root, vec4f, COUNT);
+		const dyeA = createStateBuffer(root, vec4f, COUNT);
+		const dyeB = createStateBuffer(root, vec4f, COUNT);
+		const pressure = createStateBuffer(root, f32, COUNT);
+		const divergence = createStateBuffer(root, f32, COUNT);
 		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [N, N],
 			format: STATE_FORMAT

package/dist/core/{Invert-DDmITZjt.js → Invert-BIjy9ddK.js}

@@ -1,7 +1,7 @@
-import { Bt as ZERO, Ht as call, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-const invertColor = tgpu.fn([d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
+import { Vt as data_exports, d as ZERO, et as src_default, in as vec4f, p as call } from "./edges-BXNBKxSN.js";
+const invertColor = src_default.fn([vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color) => {
 	"use gpu";
-	return d.vec4f(__tsover_sub(1, color.x), __tsover_sub(1, color.y), __tsover_sub(1, color.z), color.w);
+	return vec4f(__tsover_sub(1, color.x), __tsover_sub(1, color.y), __tsover_sub(1, color.z), color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -57,7 +57,7 @@ const invertColor = tgpu.fn([d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalT
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
 const componentDefinition = {
 	name: "Invert",

package/dist/core/{IrisWipe-BFs5DDSa.js → IrisWipe-lpU7lucQ.js}

@@ -1,28 +1,25 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { c as transformPosition, i as transformBoolean } from "./transformations-t0d2-uSX.js";
-const irisWipeMask = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, center, progress, feather, invert) => {
+import { $t as vec2f, Et as max, Lt as smoothstep, Tt as length, Vt as data_exports, an as f32, d as ZERO, et as src_default, in as vec4f, nt as std_exports, p as call, pt as select } from "./edges-BXNBKxSN.js";
+import { c as transformPosition, i as transformBoolean } from "./transformations-CsPUHppB.js";
+const irisWipeMask = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, aspect, center, progress, feather, invert) => {
 	"use gpu";
 	const cx = __tsover_mul(center.x, aspect);
 	const cy = __tsover_sub(1, center.y);
-	const rel = d.vec2f(__tsover_sub(__tsover_mul(uv.x, aspect), cx), __tsover_sub(uv.y, cy));
-	const dist = std.length(rel);
-	const dx = std.max(cx, __tsover_sub(aspect, cx));
-	const dy = std.max(cy, __tsover_sub(1, cy));
-	const maxDist = std.length(d.vec2f(dx, dy));
-	let coord = __tsover_div(dist, std.max(maxDist, 1e-4));
-	coord = std.select(coord, __tsover_sub(1, coord), invert > 0);
-	const f = std.max(feather, 1e-4);
+	const dist = length(vec2f(__tsover_sub(__tsover_mul(uv.x, aspect), cx), __tsover_sub(uv.y, cy)));
+	const maxDist = length(vec2f(max(cx, __tsover_sub(aspect, cx)), max(cy, __tsover_sub(1, cy))));
+	let coord = __tsover_div(dist, max(maxDist, 1e-4));
+	coord = select(coord, __tsover_sub(1, coord), invert > 0);
+	const f = max(feather, 1e-4);
 	const front = __tsover_sub(__tsover_mul(progress, __tsover_add(1, __tsover_mul(2, f))), f);
-	const reveal = std.smoothstep(__tsover_sub(front, f), __tsover_add(front, f), coord);
-	return d.vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
+	const reveal = smoothstep(__tsover_sub(front, f), __tsover_add(front, f), coord);
+	return vec4f(color.x, color.y, color.z, __tsover_mul(color.w, reveal));
 }), {
 	v: 1,
 	name: void 0,
@@ -342,8 +339,8 @@ const irisWipeMask = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {