shaders 3.0.448 → 3.0.449

package/dist/core/{ReactionDiffusion-DdXavIVw.js → ReactionDiffusion-DknxOF-o.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, ln as colorMixing_exports, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, i as transformBoolean, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, At as pow, Ct as floor, Dt as min, Et as max, F as colorMixing_exports, Gt as textureStorage2d, It as sin, Lt as smoothstep, Ot as mix, Ut as arrayOf, Vt as data_exports, Wt as texture2d, Xt as struct, _ as floatE, _t as clamp, an as f32, at as textureStore, bt as dot, d as ZERO, et as src_default, in as vec4f, it as textureLoad, kt as normalize, nn as vec3f, nt as std_exports, on as i32, p as call, pt as select, rt as textureDimensions, 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 { a as transformColor, i as transformBoolean, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var cm = colorMixing_exports;
 var N = 512;
 var COUNT = N * N;
@@ -67,68 +68,68 @@ var CHILD_FEED_MIN = .008;
 var CHILD_FEED_MAX = .11;
 var CHILD_KILL_MIN = .03;
 var CHILD_KILL_MAX = .075;
-var RDParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	feed: d.f32,
-	kill: d.f32,
-	dv: d.f32,
-	brushRadSq: d.f32,
-	brushStrength: d.f32,
-	cursorX: d.f32,
-	cursorY: d.f32,
-	cursorActive: d.f32,
-	childInfluence: d.f32,
-	childContrast: d.f32,
-	childThreshold: d.f32,
-	childInvert: d.f32,
-	childMapX: d.f32,
-	childMapY: d.f32,
-	_pad0: d.f32,
-	_pad1: d.f32
+var RDParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	feed: f32,
+	kill: f32,
+	dv: f32,
+	brushRadSq: f32,
+	brushStrength: f32,
+	cursorX: f32,
+	cursorY: f32,
+	cursorActive: f32,
+	childInfluence: f32,
+	childContrast: f32,
+	childThreshold: f32,
+	childInvert: f32,
+	childMapX: f32,
+	childMapY: f32,
+	_pad0: f32,
+	_pad1: f32
 }), "RDParams");
-var reactionLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var reactionLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	readBuf: {
-		storage: d.arrayOf(d.vec2f, COUNT),
+		storage: arrayOf(vec2f, COUNT),
 		access: "readonly"
 	},
 	writeBuf: {
-		storage: d.arrayOf(d.vec2f, COUNT),
+		storage: arrayOf(vec2f, COUNT),
 		access: "mutable"
 	},
 	params: { uniform: RDParams }
 }), "reactionLayout");
-var seedLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({ stateBuf: {
-	storage: d.arrayOf(d.vec2f, COUNT),
+var seedLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({ stateBuf: {
+	storage: arrayOf(vec2f, COUNT),
 	access: "mutable"
 } }), "seedLayout");
-var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	srcBuf: {
-		storage: d.arrayOf(d.vec2f, COUNT),
+		storage: arrayOf(vec2f, COUNT),
 		access: "readonly"
 	},
-	outTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	outTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "outputLayout");
-var reactionChildLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var reactionChildLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	readBuf: {
-		storage: d.arrayOf(d.vec2f, COUNT),
+		storage: arrayOf(vec2f, COUNT),
 		access: "readonly"
 	},
 	writeBuf: {
-		storage: d.arrayOf(d.vec2f, COUNT),
+		storage: arrayOf(vec2f, COUNT),
 		access: "mutable"
 	},
 	params: { uniform: RDParams },
-	childTex: { texture: d.texture2d(d.f32) }
+	childTex: { texture: texture2d(f32) }
 }), "reactionChildLayout");
-var nbrState = tgpu.fn([
-	d.i32,
-	d.i32,
-	d.i32,
-	d.i32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ii, ji, di, dj) => {
+var nbrState = src_default.fn([
+	i32,
+	i32,
+	i32,
+	i32
+], vec2f)(/* @__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 reactionLayout.$.readBuf[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 reactionLayout.$.readBuf[u32(__tsover_add(__tsover_mul(row, N), col))];
 }), {
 	v: 1,
 	name: void 0,
@@ -246,19 +247,19 @@ var nbrState = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		N,
 		reactionLayout,
-		d
+		d: data_exports
 	})
 }) && $.f)({})).$name("reactionDiffusionNbr");
-const reactionKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const reactionKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const p = reactionLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
 	const self = reactionLayout.$.readBuf[idx];
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
 	const L = nbrState(ii, ji, 0, -1);
 	const R = nbrState(ii, ji, 0, 1);
 	const T = nbrState(ii, ji, -1, 0);
@@ -275,17 +276,17 @@ const reactionKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalTh
 	let newU = __tsover_add(U, __tsover_add(__tsover_sub(lapU, uvv), __tsover_mul(p.feed, __tsover_sub(1, U))));
 	let newV = __tsover_add(V, __tsover_sub(__tsover_add(__tsover_mul(p.dv, lapV), uvv), __tsover_mul(__tsover_add(p.feed, p.kill), V)));
 	if (p.cursorActive > 0) {
-		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 dxp = __tsover_sub(cellX, p.cursorX);
 		const dyp = __tsover_sub(cellY, p.cursorY);
 		const distSq = __tsover_add(__tsover_mul(dxp, dxp), __tsover_mul(dyp, dyp));
-		const inf = __tsover_mul(std.exp(__tsover_mul(__tsover_div(distSq, std.max(p.brushRadSq, d.f32(1))), -1)), p.cursorActive);
-		newV = std.min(__tsover_add(newV, __tsover_mul(inf, p.brushStrength)), d.f32(1));
+		const inf = __tsover_mul(exp(__tsover_mul(__tsover_div(distSq, max(p.brushRadSq, f32(1))), -1)), p.cursorActive);
+		newV = min(__tsover_add(newV, __tsover_mul(inf, p.brushStrength)), f32(1));
 	}
-	newU = std.clamp(newU, 0, 1);
-	newV = std.clamp(newV, 0, 1);
-	reactionLayout.$.writeBuf[idx] = d.vec2f(newU, newV);
+	newU = clamp(newU, 0, 1);
+	newV = clamp(newV, 0, 1);
+	reactionLayout.$.writeBuf[idx] = vec2f(newU, newV);
 }), {
 	v: 1,
 	name: void 0,
@@ -1073,22 +1074,22 @@ const reactionKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalTh
 	},
 	externals: () => ({
 		reactionLayout,
-		d,
+		d: data_exports,
 		N,
 		nbrState,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("reactionDiffusionReact");
-var nbrStateChild = tgpu.fn([
-	d.i32,
-	d.i32,
-	d.i32,
-	d.i32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ii, ji, di, dj) => {
+var nbrStateChild = src_default.fn([
+	i32,
+	i32,
+	i32,
+	i32
+], vec2f)(/* @__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 reactionChildLayout.$.readBuf[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 reactionChildLayout.$.readBuf[u32(__tsover_add(__tsover_mul(row, N), col))];
 }), {
 	v: 1,
 	name: void 0,
@@ -1206,32 +1207,31 @@ var nbrStateChild = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		N,
 		reactionChildLayout,
-		d
+		d: data_exports
 	})
 }) && $.f)({})).$name("reactionDiffusionNbrChild");
-const rdChildDrive = tgpu.fn([d.u32, d.u32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const rdChildDrive = src_default.fn([u32, u32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const p = reactionChildLayout.$.params;
-	const dims = std.textureDimensions(reactionChildLayout.$.childTex);
-	const fw = d.f32(dims.x);
-	const fh = d.f32(dims.y);
-	const fx = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(N));
-	const fy = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(N));
-	const cu = std.clamp(__tsover_add(__tsover_mul(__tsover_sub(fx, .5), p.childMapX), .5), d.f32(0), d.f32(1));
-	const cv = std.clamp(__tsover_add(__tsover_mul(__tsover_sub(fy, .5), p.childMapY), .5), d.f32(0), d.f32(1));
-	const px = d.u32(std.min(__tsover_mul(cu, fw), __tsover_sub(fw, 1)));
-	const py = d.u32(std.min(__tsover_mul(cv, fh), __tsover_sub(fh, 1)));
-	const texel = std.textureLoad(reactionChildLayout.$.childTex, d.vec2u(px, py), 0);
-	const cov = std.clamp(texel.w, d.f32(0), d.f32(1));
-	const rgb = texel.xyz.div(std.max(texel.w, d.f32(.001)));
-	const luma = std.dot(rgb, d.vec3f(.2126, .7152, .0722));
-	const gain = __tsover_add(d.f32(1), __tsover_mul(p.childContrast, d.f32(CHILD_CONTRAST_MAX)));
-	const shaped = std.clamp(__tsover_add(__tsover_mul(__tsover_sub(luma, p.childThreshold), gain), .5), d.f32(0), d.f32(1));
+	const dims = textureDimensions(reactionChildLayout.$.childTex);
+	const fw = f32(dims.x);
+	const fh = f32(dims.y);
+	const fx = __tsover_div(__tsover_add(f32(cx), .5), f32(N));
+	const fy = __tsover_div(__tsover_add(f32(cy), .5), f32(N));
+	const cu = clamp(__tsover_add(__tsover_mul(__tsover_sub(fx, .5), p.childMapX), .5), f32(0), f32(1));
+	const cv = clamp(__tsover_add(__tsover_mul(__tsover_sub(fy, .5), p.childMapY), .5), f32(0), f32(1));
+	const px = u32(min(__tsover_mul(cu, fw), __tsover_sub(fw, 1)));
+	const py = u32(min(__tsover_mul(cv, fh), __tsover_sub(fh, 1)));
+	const texel = textureLoad(reactionChildLayout.$.childTex, vec2u(px, py), 0);
+	const cov = clamp(texel.w, f32(0), f32(1));
+	const luma = dot(texel.xyz.div(max(texel.w, f32(.001))), vec3f(.2126, .7152, .0722));
+	const gain = __tsover_add(f32(1), __tsover_mul(p.childContrast, f32(CHILD_CONTRAST_MAX)));
+	const shaped = clamp(__tsover_add(__tsover_mul(__tsover_sub(luma, p.childThreshold), gain), .5), f32(0), f32(1));
 	let signed = __tsover_mul(__tsover_sub(shaped, .5), 2);
-	signed = std.select(signed, __tsover_mul(signed, -1), p.childInvert > .5);
+	signed = select(signed, __tsover_mul(signed, -1), p.childInvert > .5);
 	return __tsover_mul(signed, cov);
 }), {
 	v: 1,
@@ -1828,19 +1828,19 @@ const rdChildDrive = tgpu.fn([d.u32, d.u32], d.f32)(/* @__PURE__ */ (($) => (glo
 	},
 	externals: () => ({
 		reactionChildLayout,
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		N,
 		CHILD_CONTRAST_MAX
 	})
 }) && $.f)({})).$name("reactionDiffusionChildDrive");
-const reactionKernelChild = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const reactionKernelChild = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
 	const p = reactionChildLayout.$.params;
-	const idx = __tsover_add(__tsover_mul(cy, d.u32(N)), cx);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
 	const self = reactionChildLayout.$.readBuf[idx];
-	const ii = d.i32(cy);
-	const ji = d.i32(cx);
+	const ii = i32(cy);
+	const ji = i32(cx);
 	const L = nbrStateChild(ii, ji, 0, -1);
 	const R = nbrStateChild(ii, ji, 0, 1);
 	const T = nbrStateChild(ii, ji, -1, 0);
@@ -1852,25 +1852,25 @@ const reactionKernelChild = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (glo
 	const lapU = __tsover_sub(__tsover_add(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(L.x, R.x), T.x), B.x), .2), __tsover_mul(__tsover_add(__tsover_add(__tsover_add(TL.x, TR.x), BL.x), BR.x), .05)), self.x);
 	const lapV = __tsover_sub(__tsover_add(__tsover_mul(__tsover_add(__tsover_add(__tsover_add(L.y, R.y), T.y), B.y), .2), __tsover_mul(__tsover_add(__tsover_add(__tsover_add(TL.y, TR.y), BL.y), BR.y), .05)), self.y);
 	const mod = __tsover_mul(rdChildDrive(cx, cy), p.childInfluence);
-	const feedCell = std.clamp(__tsover_add(p.feed, __tsover_mul(mod, d.f32(CHILD_DFEED))), d.f32(CHILD_FEED_MIN), d.f32(CHILD_FEED_MAX));
-	const killCell = std.clamp(__tsover_sub(p.kill, __tsover_mul(mod, d.f32(CHILD_DKILL))), d.f32(CHILD_KILL_MIN), d.f32(CHILD_KILL_MAX));
+	const feedCell = clamp(__tsover_add(p.feed, __tsover_mul(mod, f32(CHILD_DFEED))), f32(CHILD_FEED_MIN), f32(CHILD_FEED_MAX));
+	const killCell = clamp(__tsover_sub(p.kill, __tsover_mul(mod, f32(CHILD_DKILL))), f32(CHILD_KILL_MIN), f32(CHILD_KILL_MAX));
 	const U = self.x;
 	const V = self.y;
 	const uvv = __tsover_mul(__tsover_mul(U, V), V);
 	let newU = __tsover_add(U, __tsover_add(__tsover_sub(lapU, uvv), __tsover_mul(feedCell, __tsover_sub(1, U))));
 	let newV = __tsover_add(V, __tsover_sub(__tsover_add(__tsover_mul(p.dv, lapV), uvv), __tsover_mul(__tsover_add(feedCell, killCell), V)));
 	if (p.cursorActive > 0) {
-		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 dxp = __tsover_sub(cellX, p.cursorX);
 		const dyp = __tsover_sub(cellY, p.cursorY);
 		const distSq = __tsover_add(__tsover_mul(dxp, dxp), __tsover_mul(dyp, dyp));
-		const inf = __tsover_mul(std.exp(__tsover_mul(__tsover_div(distSq, std.max(p.brushRadSq, d.f32(1))), -1)), p.cursorActive);
-		newV = std.min(__tsover_add(newV, __tsover_mul(inf, p.brushStrength)), d.f32(1));
+		const inf = __tsover_mul(exp(__tsover_mul(__tsover_div(distSq, max(p.brushRadSq, f32(1))), -1)), p.cursorActive);
+		newV = min(__tsover_add(newV, __tsover_mul(inf, p.brushStrength)), f32(1));
 	}
-	newU = std.clamp(newU, 0, 1);
-	newV = std.clamp(newV, 0, 1);
-	reactionChildLayout.$.writeBuf[idx] = d.vec2f(newU, newV);
+	newU = clamp(newU, 0, 1);
+	newV = clamp(newV, 0, 1);
+	reactionChildLayout.$.writeBuf[idx] = vec2f(newU, newV);
 }), {
 	v: 1,
 	name: void 0,
@@ -2781,11 +2781,11 @@ const reactionKernelChild = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (glo
 	},
 	externals: () => ({
 		reactionChildLayout,
-		d,
+		d: data_exports,
 		N,
 		nbrStateChild,
 		rdChildDrive,
-		std,
+		std: std_exports,
 		CHILD_DFEED,
 		CHILD_FEED_MIN,
 		CHILD_FEED_MAX,
@@ -2794,13 +2794,13 @@ const reactionKernelChild = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (glo
 		CHILD_KILL_MAX
 	})
 }) && $.f)({})).$name("reactionDiffusionReactChild");
-const seedKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const seedKernel = 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 s = __tsover_mul(std.sin(__tsover_add(__tsover_mul(d.f32(cx), 12.9898), __tsover_mul(d.f32(cy), 78.233))), 43758.5453);
-	const h = __tsover_sub(s, std.floor(s));
-	const vSeed = std.select(d.f32(0), d.f32(1), h < SEED_DENSITY);
-	seedLayout.$.stateBuf[idx] = d.vec2f(1, vSeed);
+	const idx = __tsover_add(__tsover_mul(cy, u32(N)), cx);
+	const s = __tsover_mul(sin(__tsover_add(__tsover_mul(f32(cx), 12.9898), __tsover_mul(f32(cy), 78.233))), 43758.5453);
+	const h = __tsover_sub(s, floor(s));
+	const vSeed = select(f32(0), f32(1), h < SEED_DENSITY);
+	seedLayout.$.stateBuf[idx] = vec2f(1, vSeed);
 }), {
 	v: 1,
 	name: void 0,
@@ -2977,18 +2977,18 @@ const seedKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis._
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
-		std,
+		std: std_exports,
 		SEED_DENSITY,
 		seedLayout
 	})
 }) && $.f)({})).$name("reactionDiffusionSeed");
-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 s = outputLayout.$.srcBuf[idx];
-	std.textureStore(outputLayout.$.outTex, d.vec2u(cx, cy), d.vec4f(s.x, s.y, 0, 0));
+	textureStore(outputLayout.$.outTex, vec2u(cx, cy), vec4f(s.x, s.y, 0, 0));
 }), {
 	v: 1,
 	name: void 0,
@@ -3100,24 +3100,22 @@ const outputKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		N,
 		outputLayout,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("reactionDiffusionOutput");
-const rdSampleUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, featureSize) => {
+const rdSampleUV = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, featureSize) => {
 	"use gpu";
 	const view = __tsover_div(1, featureSize);
-	const sx = std.min(aspect, 1);
-	const sy = std.min(__tsover_div(1, aspect), 1);
-	const fx = __tsover_add(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), sx), view), .5);
-	const fy = __tsover_add(__tsover_mul(__tsover_mul(__tsover_sub(uv.y, .5), sy), view), .5);
-	return d.vec2f(fx, fy);
+	const sx = min(aspect, 1);
+	const sy = min(__tsover_div(1, aspect), 1);
+	return vec2f(__tsover_add(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), sx), view), .5), __tsover_add(__tsover_mul(__tsover_mul(__tsover_sub(uv.y, .5), sy), view), .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -3249,18 +3247,18 @@ const rdSampleUV = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({})).$name("reactionDiffusionSampleUV");
-const rdRampT = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((v, contrast, threshold) => {
+const rdRampT = src_default.fn([
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((v, contrast, threshold) => {
 	"use gpu";
-	const w = std.max(__tsover_sub(.6, __tsover_mul(contrast, .55)), .02);
-	return std.smoothstep(__tsover_sub(threshold, w), __tsover_add(threshold, w), v);
+	const w = max(__tsover_sub(.6, __tsover_mul(contrast, .55)), .02);
+	return smoothstep(__tsover_sub(threshold, w), __tsover_add(threshold, w), v);
 }), {
 	v: 1,
 	name: void 0,
@@ -3326,11 +3324,11 @@ const rdRampT = tgpu.fn([
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const rdSeg = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, offset) => {
+const rdSeg = src_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((t, offset) => {
 	"use gpu";
-	return std.clamp(__tsover_sub(__tsover_mul(t, 2), offset), 0, 1);
+	return clamp(__tsover_sub(__tsover_mul(t, 2), offset), 0, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -3367,16 +3365,16 @@ const rdSeg = tgpu.fn([d.f32, d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const rdPickSeg = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lo, hi, t) => {
+const rdPickSeg = src_default.fn([
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((lo, hi, t) => {
 	"use gpu";
 	const useHi = t > .5;
-	return d.vec4f(std.select(lo.x, hi.x, useHi), std.select(lo.y, hi.y, useHi), std.select(lo.z, hi.z, useHi), std.select(lo.w, hi.w, useHi));
+	return vec4f(select(lo.x, hi.x, useHi), select(lo.y, hi.y, useHi), select(lo.z, hi.z, useHi), select(lo.w, hi.w, useHi));
 }), {
 	v: 1,
 	name: void 0,
@@ -3501,17 +3499,17 @@ const rdPickSeg = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const rdShiftUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, ox, oy) => {
+const rdShiftUV = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, ox, oy) => {
 	"use gpu";
-	return d.vec2f(__tsover_add(uv.x, ox), __tsover_add(uv.y, oy));
+	return vec2f(__tsover_add(uv.x, ox), __tsover_add(uv.y, oy));
 }), {
 	v: 1,
 	name: void 0,
@@ -3559,30 +3557,30 @@ const rdShiftUV = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({})).$name("reactionDiffusionShiftUV");
-const rdShade = tgpu.fn([
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, vL, vR, vT, vB, relief, lightAngle) => {
+const rdShade = src_default.fn([
+	vec4f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, vL, vR, vT, vB, relief, lightAngle) => {
 	"use gpu";
-	const gx = __tsover_mul(__tsover_sub(vR, vL), d.f32(RELIEF_STRENGTH));
-	const gy = __tsover_mul(__tsover_sub(vB, vT), d.f32(RELIEF_STRENGTH));
-	const n = std.normalize(d.vec3f(-gx, -gy, d.f32(1)));
+	const gx = __tsover_mul(__tsover_sub(vR, vL), f32(RELIEF_STRENGTH));
+	const gy = __tsover_mul(__tsover_sub(vB, vT), f32(RELIEF_STRENGTH));
+	const n = normalize(vec3f(-gx, -gy, f32(1)));
 	const ang = __tsover_mul(lightAngle, DEG2RAD);
-	const lightDir = std.normalize(d.vec3f(__tsover_mul(std.cos(ang), RELIEF_LIGHT_XY), __tsover_mul(std.sin(ang), RELIEF_LIGHT_XY), RELIEF_LIGHT_Z));
-	const diff = std.clamp(std.dot(n, lightDir), d.f32(0), d.f32(1));
-	const shade = __tsover_add(RELIEF_AMBIENT, __tsover_mul(__tsover_sub(d.f32(1), RELIEF_AMBIENT), diff));
-	const halfVec = std.normalize(lightDir.add(d.vec3f(d.f32(0), d.f32(0), d.f32(1))));
-	const spec = __tsover_mul(std.pow(std.clamp(std.dot(n, halfVec), d.f32(0), d.f32(1)), d.f32(RELIEF_SHININESS)), RELIEF_SPEC);
-	const litRgb = base.xyz.mul(shade).add(d.vec3f(spec, spec, spec));
-	const outRgb = std.mix(base.xyz, litRgb, relief);
-	return d.vec4f(outRgb.x, outRgb.y, outRgb.z, base.w);
+	const lightDir = normalize(vec3f(__tsover_mul(cos(ang), RELIEF_LIGHT_XY), __tsover_mul(sin(ang), RELIEF_LIGHT_XY), RELIEF_LIGHT_Z));
+	const diff = clamp(dot(n, lightDir), f32(0), f32(1));
+	const shade = __tsover_add(RELIEF_AMBIENT, __tsover_mul(__tsover_sub(f32(1), RELIEF_AMBIENT), diff));
+	const halfVec = normalize(lightDir.add(vec3f(f32(0), f32(0), f32(1))));
+	const spec = __tsover_mul(pow(clamp(dot(n, halfVec), f32(0), f32(1)), f32(RELIEF_SHININESS)), RELIEF_SPEC);
+	const litRgb = base.xyz.mul(shade).add(vec3f(spec, spec, spec));
+	const outRgb = mix(base.xyz, litRgb, relief);
+	return vec4f(outRgb.x, outRgb.y, outRgb.z, base.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -4056,9 +4054,9 @@ const rdShade = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		RELIEF_STRENGTH,
-		std,
+		std: std_exports,
 		DEG2RAD,
 		RELIEF_LIGHT_XY,
 		RELIEF_LIGHT_Z,
@@ -4365,8 +4363,8 @@ const componentDefinition = {
 		if (!root) return null;
 		const hasChild = !!childNode;
 		const childTexture = hasChild && convertToTexture ? convertToTexture(childNode) : null;
-		const bufferA = createStateBuffer(root, d.vec2f, COUNT);
-		const bufferB = createStateBuffer(root, d.vec2f, COUNT);
+		const bufferA = createStateBuffer(root, vec2f, COUNT);
+		const bufferB = createStateBuffer(root, vec2f, COUNT);
 		const outTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [N, N],
 			format: STATE_FORMAT

package/dist/core/{RectangularCoordinates-p3250IKV.js → RectangularCoordinates-DFQm4y6H.js}

@@ -1,20 +1,20 @@
-import { Bt as ZERO, Ht as call, J as std, Lt as sampleRemappedExpr, Tn as d, cn as unpremultiplyAlpha, jt as composeEdgeRemapExpr, n as tgpu, qt as mixExpr } from "./coords-BkIjixe_.js";
-import { c as transformPosition, s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, It as sin, N as unpremultiplyAlpha, Vt as data_exports, an as f32, c as sampleRemappedExpr, d as ZERO, et as src_default, n as composeEdgeRemapExpr, nt as std_exports, p as call, v as mixExpr, vt as cos } from "./edges-BXNBKxSN.js";
+import { c as transformPosition, s as transformEdges } from "./transformations-CsPUHppB.js";
 var PI = Math.PI;
 var TAU = Math.PI * 2;
-const rectCoordsUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, scale, uv, aspect) => {
+const rectCoordsUV = src_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, scale, uv, aspect) => {
 	"use gpu";
 	const theta = __tsover_sub(__tsover_mul(uv.x, TAU), PI);
 	const r = __tsover_mul(uv.y, scale);
-	const rectX = __tsover_mul(r, std.cos(theta));
-	const rectY = __tsover_mul(r, std.sin(theta));
-	const centerPos = d.vec2f(center.x, __tsover_sub(1, center.y));
-	return d.vec2f(__tsover_add(__tsover_div(rectX, aspect), centerPos.x), __tsover_add(rectY, centerPos.y));
+	const rectX = __tsover_mul(r, cos(theta));
+	const rectY = __tsover_mul(r, sin(theta));
+	const centerPos = vec2f(center.x, __tsover_sub(1, center.y));
+	return vec2f(__tsover_add(__tsover_div(rectX, aspect), centerPos.x), __tsover_add(rectY, centerPos.y));
 }), {
 	v: 1,
 	name: void 0,
@@ -176,8 +176,8 @@ const rectCoordsUV = tgpu.fn([
 	externals: () => ({
 		TAU,
 		PI,
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {