shaders 3.0.447 → 3.0.449

package/dist/core/{Surface3D-TsGPzdGm.js → Surface3D-CLjX61TZ.js}

@@ -1,5 +1,7 @@
-import { Bt as ZERO, Ft as edgeWrapUV, Ht as call, It as edges_exports, J as std, Jt as vec4, Nt as edgeMirrorUV, Tn as d, X as createGuardedCompute, Z as createStateBuffer, cn as unpremultiplyAlpha, n as tgpu, pt as noise_exports, ut as mxNoiseFloat2 } from "./coords-BkIjixe_.js";
-import { a as transformColor, s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, At as pow, Ct as floor, Dt as min, Et as max, Gt as textureStorage2d, It as sin, Lt as smoothstep, N as unpremultiplyAlpha, Ot as mix, St as exp2, Ut as arrayOf, Vt as data_exports, Xt as struct, _t as clamp, an as f32, at as textureStore, bt as dot, d as ZERO, et as src_default, i as edgeMirrorUV, in as vec4f, kt as normalize, mt as abs, nn as vec3f, nt as std_exports, o as edgeWrapUV, p as call, pt as select, s as edges_exports, sn as u32, tn as vec2u, vt as cos, xt as exp, y as vec4 } from "./edges-BXNBKxSN.js";
+import { p as noise_exports, u as mxNoiseFloat2 } from "./noise-wTSHXgFz.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { a as transformColor, s as transformEdges } from "./transformations-CsPUHppB.js";
 var WAVE_GRID = 256;
 var WAVE_CELLS = WAVE_GRID * WAVE_GRID;
 var WAVE_MAX = WAVE_GRID - 1;
@@ -9,63 +11,63 @@ var COMPUTE_H = 900;
 var STATE_FORMAT = "rgba16float";
 var DEG_TO_RAD = Math.PI / 180;
 var TWO_PI = Math.PI * 2;
-var S3Params = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	amp: d.f32,
-	freq: d.f32,
-	seed: d.f32,
-	edgePin: d.f32,
-	cursorIntensity: d.f32,
-	t: d.f32,
-	aspect: d.f32,
-	focal: d.f32,
-	camPos: d.vec3f,
-	camForward: d.vec3f,
-	camRight: d.vec3f,
-	camUp: d.vec3f,
-	lighting: d.f32,
-	glossiness: d.f32,
-	highlights: d.f32,
-	lightX: d.f32,
-	lightY: d.f32,
-	lightZ: d.f32,
-	lightColor: d.vec3f,
-	nearCutoff: d.f32,
-	farCutoff: d.f32,
-	cursorWaveX: d.f32,
-	cursorWaveY: d.f32,
-	mouseSpeed: d.f32,
-	dt: d.f32,
-	decay: d.f32,
-	radius: d.f32,
-	waveSpeed: d.f32
+var S3Params = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	amp: f32,
+	freq: f32,
+	seed: f32,
+	edgePin: f32,
+	cursorIntensity: f32,
+	t: f32,
+	aspect: f32,
+	focal: f32,
+	camPos: vec3f,
+	camForward: vec3f,
+	camRight: vec3f,
+	camUp: vec3f,
+	lighting: f32,
+	glossiness: f32,
+	highlights: f32,
+	lightX: f32,
+	lightY: f32,
+	lightZ: f32,
+	lightColor: vec3f,
+	nearCutoff: f32,
+	farCutoff: f32,
+	cursorWaveX: f32,
+	cursorWaveY: f32,
+	mouseSpeed: f32,
+	dt: f32,
+	decay: f32,
+	radius: f32,
+	waveSpeed: f32
 }), "S3Params");
-var propagateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var propagateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	readSrc: {
-		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		storage: arrayOf(f32, WAVE_CELLS),
 		access: "readonly"
 	},
 	writeBuf: {
-		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		storage: arrayOf(f32, WAVE_CELLS),
 		access: "mutable"
 	},
 	readBuf: {
-		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		storage: arrayOf(f32, WAVE_CELLS),
 		access: "mutable"
 	},
 	params: { uniform: S3Params }
 }), "propagateLayout");
-var computeLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var computeLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	readBuf: {
-		storage: d.arrayOf(d.f32, WAVE_CELLS),
+		storage: arrayOf(f32, WAVE_CELLS),
 		access: "readonly"
 	},
 	params: { uniform: S3Params },
-	uvMaskTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
-	litTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	uvMaskTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
+	litTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "computeLayout");
 function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 	const invTotalWeight = 1 / (2 - Math.pow(.5, Math.max(octaveCount, 1) - 1));
-	return tgpu.fn([d.vec2f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
+	return src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv) => {
 		"use gpu";
 		const p = computeLayout.$.params;
 		const u = uv.x;
@@ -73,76 +75,75 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 		const amp = p.amp;
 		const freq = p.freq;
 		const seedU = p.seed;
-		let waveVal = d.f32(0);
+		let waveVal = f32(0);
 		if (waveType === 1) {
-			let accSin = d.f32(0);
+			let accSin = f32(0);
 			for (let i = 0; i < octaveCount; i++) {
-				const iF = d.f32(i);
-				const scale = std.exp2(iF);
-				const weight = std.exp2(__tsover_mul(iF, -1));
-				const cu$1 = std.cos(__tsover_mul(iF, 1.111));
-				const su = std.sin(__tsover_mul(iF, 1.111));
+				const iF = f32(i);
+				const scale = exp2(iF);
+				const weight = exp2(__tsover_mul(iF, -1));
+				const cu$1 = cos(__tsover_mul(iF, 1.111));
+				const su = sin(__tsover_mul(iF, 1.111));
 				const ru = __tsover_sub(__tsover_mul(u, cu$1), __tsover_mul(v, su));
 				const phase = __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(__tsover_mul(ru, freq), scale), TWO_PI), __tsover_mul(p.t, __tsover_add(1, __tsover_mul(iF, .2)))), __tsover_mul(seedU, __tsover_add(1, __tsover_mul(iF, .5))));
-				accSin = __tsover_add(accSin, __tsover_mul(std.sin(phase), weight));
+				accSin = __tsover_add(accSin, __tsover_mul(sin(phase), weight));
 			}
 			waveVal = __tsover_mul(accSin, invTotalWeight);
 		} else if (waveType === 2) {
-			let accR = d.f32(0);
+			let accR = f32(0);
 			for (let i = 0; i < octaveCount; i++) {
-				const iF = d.f32(i);
-				const scale = std.exp2(iF);
-				const weight = std.exp2(__tsover_mul(iF, -1));
-				const driftX = std.cos(__tsover_mul(iF, 2.39996));
-				const driftY = std.sin(__tsover_mul(iF, 2.39996));
-				const coord = d.vec2f(__tsover_add(__tsover_add(__tsover_mul(__tsover_mul(u, freq), scale), __tsover_mul(p.t, __tsover_mul(driftX, .3))), seedU), __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(v, freq), scale), __tsover_mul(p.t, __tsover_mul(driftY, .3))), __tsover_mul(seedU, .7)));
+				const iF = f32(i);
+				const scale = exp2(iF);
+				const weight = exp2(__tsover_mul(iF, -1));
+				const driftX = cos(__tsover_mul(iF, 2.39996));
+				const driftY = sin(__tsover_mul(iF, 2.39996));
+				const coord = vec2f(__tsover_add(__tsover_add(__tsover_mul(__tsover_mul(u, freq), scale), __tsover_mul(p.t, __tsover_mul(driftX, .3))), seedU), __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(v, freq), scale), __tsover_mul(p.t, __tsover_mul(driftY, .3))), __tsover_mul(seedU, .7)));
 				accR = __tsover_add(accR, __tsover_mul(mxNoiseFloat2(coord), weight));
 			}
 			const n = __tsover_mul(accR, invTotalWeight);
-			waveVal = __tsover_sub(__tsover_mul(__tsover_sub(1, std.abs(n)), 2), 1);
+			waveVal = __tsover_sub(__tsover_mul(__tsover_sub(1, abs(n)), 2), 1);
 		} else {
 			const warpFreq = __tsover_mul(freq, .5);
-			const wx = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_add(__tsover_mul(u, warpFreq), __tsover_mul(p.t, .1)), seedU), __tsover_add(__tsover_mul(v, warpFreq), __tsover_mul(seedU, 1.3))));
-			const wy = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_add(__tsover_mul(u, warpFreq), seedU), 17.3), __tsover_add(__tsover_add(__tsover_add(__tsover_mul(v, warpFreq), __tsover_mul(p.t, .07)), seedU), 31.1)));
+			const wx = mxNoiseFloat2(vec2f(__tsover_add(__tsover_add(__tsover_mul(u, warpFreq), __tsover_mul(p.t, .1)), seedU), __tsover_add(__tsover_mul(v, warpFreq), __tsover_mul(seedU, 1.3))));
+			const wy = mxNoiseFloat2(vec2f(__tsover_add(__tsover_add(__tsover_mul(u, warpFreq), seedU), 17.3), __tsover_add(__tsover_add(__tsover_add(__tsover_mul(v, warpFreq), __tsover_mul(p.t, .07)), seedU), 31.1)));
 			const wu = __tsover_add(u, __tsover_mul(wx, .4));
 			const wv = __tsover_add(v, __tsover_mul(wy, .4));
-			let accW = d.f32(0);
+			let accW = f32(0);
 			for (let i = 0; i < octaveCount; i++) {
-				const iF = d.f32(i);
-				const scale = std.exp2(iF);
-				const weight = std.exp2(__tsover_mul(iF, -1));
-				const driftX = std.cos(__tsover_mul(iF, 2.39996));
-				const driftY = std.sin(__tsover_mul(iF, 2.39996));
-				const coord = d.vec2f(__tsover_add(__tsover_add(__tsover_mul(__tsover_mul(wu, freq), scale), __tsover_mul(p.t, __tsover_mul(driftX, .3))), seedU), __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(wv, freq), scale), __tsover_mul(p.t, __tsover_mul(driftY, .3))), __tsover_mul(seedU, .7)));
+				const iF = f32(i);
+				const scale = exp2(iF);
+				const weight = exp2(__tsover_mul(iF, -1));
+				const driftX = cos(__tsover_mul(iF, 2.39996));
+				const driftY = sin(__tsover_mul(iF, 2.39996));
+				const coord = vec2f(__tsover_add(__tsover_add(__tsover_mul(__tsover_mul(wu, freq), scale), __tsover_mul(p.t, __tsover_mul(driftX, .3))), seedU), __tsover_add(__tsover_add(__tsover_mul(__tsover_mul(wv, freq), scale), __tsover_mul(p.t, __tsover_mul(driftY, .3))), __tsover_mul(seedU, .7)));
 				accW = __tsover_add(accW, __tsover_mul(mxNoiseFloat2(coord), weight));
 			}
 			waveVal = __tsover_mul(accW, invTotalWeight);
 		}
 		const cu = __tsover_mul(__tsover_sub(u, .5), 2);
 		const cv = __tsover_mul(__tsover_sub(v, .5), 2);
-		const inner = std.max(std.abs(cu), std.abs(cv));
-		const pinFalloff = std.smoothstep(.6, 1, inner);
-		const pinMask = std.mix(d.f32(1), __tsover_sub(1, pinFalloff), p.edgePin);
+		const pinFalloff = smoothstep(.6, 1, max(abs(cu), abs(cv)));
+		const pinMask = mix(f32(1), __tsover_sub(1, pinFalloff), p.edgePin);
 		const baseHeight = __tsover_mul(__tsover_mul(waveVal, amp), pinMask);
 		if (cursorEnabled) {
-			const H = d.f32(WAVE_HALFEXTENT);
+			const H = f32(WAVE_HALFEXTENT);
 			const waveU = __tsover_add(__tsover_div(__tsover_sub(uv.x, .5), H), .5);
 			const waveV = __tsover_add(__tsover_div(__tsover_sub(uv.y, .5), H), .5);
-			const Nm1 = d.f32(WAVE_MAX);
-			const gx = __tsover_mul(std.clamp(waveU, 0, 1), Nm1);
-			const gy = __tsover_mul(std.clamp(waveV, 0, 1), Nm1);
-			const ix = d.u32(std.clamp(gx, 0, Nm1));
-			const iy = d.u32(std.clamp(gy, 0, Nm1));
-			const ix1 = std.min(__tsover_add(ix, d.u32(1)), d.u32(WAVE_MAX));
-			const iy1 = std.min(__tsover_add(iy, d.u32(1)), d.u32(WAVE_MAX));
-			const fx = __tsover_sub(gx, std.floor(gx));
-			const fy = __tsover_sub(gy, std.floor(gy));
-			const W = d.u32(WAVE_GRID);
+			const Nm1 = f32(WAVE_MAX);
+			const gx = __tsover_mul(clamp(waveU, 0, 1), Nm1);
+			const gy = __tsover_mul(clamp(waveV, 0, 1), Nm1);
+			const ix = u32(clamp(gx, 0, Nm1));
+			const iy = u32(clamp(gy, 0, Nm1));
+			const ix1 = min(__tsover_add(ix, u32(1)), u32(WAVE_MAX));
+			const iy1 = min(__tsover_add(iy, u32(1)), u32(WAVE_MAX));
+			const fx = __tsover_sub(gx, floor(gx));
+			const fy = __tsover_sub(gy, floor(gy));
+			const W = u32(WAVE_GRID);
 			const v00 = computeLayout.$.readBuf[__tsover_add(__tsover_mul(iy, W), ix)];
 			const v10 = computeLayout.$.readBuf[__tsover_add(__tsover_mul(iy, W), ix1)];
 			const v01 = computeLayout.$.readBuf[__tsover_add(__tsover_mul(iy1, W), ix)];
 			const v11 = computeLayout.$.readBuf[__tsover_add(__tsover_mul(iy1, W), ix1)];
-			const waveSample = std.mix(std.mix(v00, v10, fx), std.mix(v01, v11, fx), fy);
+			const waveSample = mix(mix(v00, v10, fx), mix(v01, v11, fx), fy);
 			return __tsover_add(baseHeight, __tsover_mul(waveSample, __tsover_mul(p.cursorIntensity, .05)));
 		} else return baseHeight;
 	}), {
@@ -1761,10 +1762,10 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 		},
 		externals: () => ({
 			computeLayout,
-			d,
+			d: data_exports,
 			waveType,
 			octaveCount,
-			std,
+			std: std_exports,
 			TWO_PI,
 			invTotalWeight,
 			noise: noise_exports,
@@ -1776,14 +1777,14 @@ function buildHeightFn(waveType, octaveCount, cursorEnabled) {
 	}) && $.f)({})).$name("surface3dHeight");
 }
 function makePropagateKernel() {
-	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";
-		if (cx > d.u32(0) && cx < d.u32(WAVE_MAX) && cy > d.u32(0) && cy < d.u32(WAVE_MAX)) {
+		if (cx > u32(0) && cx < u32(WAVE_MAX) && cy > u32(0) && cy < u32(WAVE_MAX)) {
 			const p = propagateLayout.$.params;
-			const gs = d.u32(WAVE_GRID);
+			const gs = u32(WAVE_GRID);
 			const idx = __tsover_add(__tsover_mul(cy, gs), cx);
-			const left = propagateLayout.$.readSrc[__tsover_sub(idx, d.u32(1))];
-			const right = propagateLayout.$.readSrc[__tsover_add(idx, d.u32(1))];
+			const left = propagateLayout.$.readSrc[__tsover_sub(idx, u32(1))];
+			const right = propagateLayout.$.readSrc[__tsover_add(idx, u32(1))];
 			const up = propagateLayout.$.readSrc[__tsover_sub(idx, gs)];
 			const down = propagateLayout.$.readSrc[__tsover_add(idx, gs)];
 			const center = propagateLayout.$.readSrc[idx];
@@ -1793,14 +1794,14 @@ function makePropagateKernel() {
 			const k2 = __tsover_mul(.5, __tsover_mul(p.waveSpeed, p.waveSpeed));
 			const lap = __tsover_sub(sum, __tsover_mul(center, 4));
 			let next = __tsover_mul(__tsover_sub(__tsover_add(__tsover_mul(center, 2), __tsover_mul(lap, k2)), prev), dampFactor);
-			const cellU = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(WAVE_GRID));
-			const cellV = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(WAVE_GRID));
+			const cellU = __tsover_div(__tsover_add(f32(cx), .5), f32(WAVE_GRID));
+			const cellV = __tsover_div(__tsover_add(f32(cy), .5), f32(WAVE_GRID));
 			const ddx = __tsover_sub(cellU, p.cursorWaveX);
 			const ddy = __tsover_sub(cellV, p.cursorWaveY);
 			const distSq = __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy));
 			const influenceRadius = __tsover_mul(p.radius, 3);
 			if (distSq < __tsover_mul(influenceRadius, influenceRadius) && p.mouseSpeed > .01) {
-				const influence = std.exp(__tsover_mul(__tsover_div(distSq, std.max(__tsover_mul(p.radius, p.radius), d.f32(1e-4))), -1));
+				const influence = exp(__tsover_mul(__tsover_div(distSq, max(__tsover_mul(p.radius, p.radius), f32(1e-4))), -1));
 				next = __tsover_sub(next, __tsover_mul(__tsover_mul(__tsover_mul(influence, p.mouseSpeed), p.dt), 3));
 			}
 			propagateLayout.$.writeBuf[idx] = next;
@@ -2462,39 +2463,39 @@ function makePropagateKernel() {
 			]
 		},
 		externals: () => ({
-			d,
+			d: data_exports,
 			WAVE_MAX,
 			propagateLayout,
 			WAVE_GRID,
-			std
+			std: std_exports
 		})
 	}) && $.f)({})).$name("surface3dPropagate");
 }
 function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cursorEnabled) {
 	const heightFn = buildHeightFn(waveType, octaveCount, cursorEnabled);
-	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 = computeLayout.$.params;
-		const screenU = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(COMPUTE_W));
-		const screenV = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(COMPUTE_H));
+		const screenU = __tsover_div(__tsover_add(f32(cx), .5), f32(COMPUTE_W));
+		const screenV = __tsover_div(__tsover_add(f32(cy), .5), f32(COMPUTE_H));
 		const ndcX = __tsover_mul(__tsover_mul(__tsover_sub(screenU, .5), 2), p.aspect);
 		const ndcY = __tsover_mul(__tsover_mul(__tsover_sub(screenV, .5), 2), -1);
-		const rayDir = std.normalize(p.camForward.mul(p.focal).add(p.camRight.mul(ndcX)).add(p.camUp.mul(ndcY)));
+		const rayDir = normalize(p.camForward.mul(p.focal).add(p.camRight.mul(ndcX)).add(p.camUp.mul(ndcY)));
 		const STEPS = 32;
 		const REFINE = 6;
-		const rayDownComp = std.max(__tsover_mul(rayDir.z, -1), d.f32(.05));
+		const rayDownComp = max(__tsover_mul(rayDir.z, -1), f32(.05));
 		const tToBase = __tsover_div(p.camPos.z, rayDownComp);
-		const marchTotal = std.min(__tsover_add(tToBase, 1.5), 15);
-		const stepSize = __tsover_div(marchTotal, d.f32(STEPS));
-		let tMarch = d.f32(0);
-		let hit = d.f32(0);
+		const marchTotal = min(__tsover_add(tToBase, 1.5), 15);
+		const stepSize = __tsover_div(marchTotal, f32(STEPS));
+		let tMarch = f32(0);
+		let hit = f32(0);
 		const u0 = __tsover_add(__tsover_mul(p.camPos.x, .5), .5);
 		const v0 = __tsover_add(__tsover_mul(p.camPos.y, .5), .5);
-		let prevDiff = __tsover_sub(p.camPos.z, heightFn(d.vec2f(u0, v0)));
+		let prevDiff = __tsover_sub(p.camPos.z, heightFn(vec2f(u0, v0)));
 		for (let s = 0; s < STEPS; s++) {
 			tMarch = __tsover_add(tMarch, stepSize);
 			const pos = p.camPos.add(rayDir.mul(tMarch));
-			const h = heightFn(d.vec2f(__tsover_add(__tsover_mul(pos.x, .5), .5), __tsover_add(__tsover_mul(pos.y, .5), .5)));
+			const h = heightFn(vec2f(__tsover_add(__tsover_mul(pos.x, .5), .5), __tsover_add(__tsover_mul(pos.y, .5), .5)));
 			const diff = __tsover_sub(pos.z, h);
 			if (diff < 0 && prevDiff > 0) {
 				hit = 1;
@@ -2507,52 +2508,52 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 		for (let r = 0; r < REFINE; r++) {
 			const tMid = __tsover_mul(__tsover_add(tLow, tHigh), .5);
 			const pMid = p.camPos.add(rayDir.mul(tMid));
-			if (__tsover_sub(pMid.z, heightFn(d.vec2f(__tsover_add(__tsover_mul(pMid.x, .5), .5), __tsover_add(__tsover_mul(pMid.y, .5), .5)))) > 0) tLow = tMid;
+			if (__tsover_sub(pMid.z, heightFn(vec2f(__tsover_add(__tsover_mul(pMid.x, .5), .5), __tsover_add(__tsover_mul(pMid.y, .5), .5)))) > 0) tLow = tMid;
 			else tHigh = tMid;
 		}
 		const finalT = __tsover_mul(__tsover_add(tLow, tHigh), .5);
 		const hitPos = p.camPos.add(rayDir.mul(finalT));
 		const hitU = __tsover_add(__tsover_mul(hitPos.x, .5), .5);
 		const hitV = __tsover_add(__tsover_mul(hitPos.y, .5), .5);
-		const rawSampleUV = d.vec2f(hitU, __tsover_sub(1, hitV));
-		let finalUV = d.vec2f(rawSampleUV.x, rawSampleUV.y);
-		let outOfBoundsMask = d.f32(1);
+		const rawSampleUV = vec2f(hitU, __tsover_sub(1, hitV));
+		let finalUV = vec2f(rawSampleUV.x, rawSampleUV.y);
+		let outOfBoundsMask = f32(1);
 		if (edgeMode === 2) finalUV = edgeMirrorUV(rawSampleUV);
 		else if (edgeMode === 3) finalUV = edgeWrapUV(rawSampleUV);
 		else if (edgeMode === 1) {
 			const inside = rawSampleUV.x >= 0 && rawSampleUV.x <= 1 && rawSampleUV.y >= 0 && rawSampleUV.y <= 1;
-			outOfBoundsMask = std.select(d.f32(0), d.f32(1), inside);
-		} else finalUV = std.clamp(rawSampleUV, d.vec2f(0, 0), d.vec2f(1, 1));
-		let lit = d.vec3f(1, 1, 1);
+			outOfBoundsMask = select(f32(0), f32(1), inside);
+		} else finalUV = clamp(rawSampleUV, vec2f(0, 0), vec2f(1, 1));
+		let lit = vec3f(1, 1, 1);
 		if (lightingEnabled) {
 			const normalEps = .01;
-			const hC = heightFn(d.vec2f(hitU, hitV));
-			const hR = heightFn(d.vec2f(__tsover_add(hitU, normalEps), hitV));
-			const hUp = heightFn(d.vec2f(hitU, __tsover_add(hitV, normalEps)));
+			const hC = heightFn(vec2f(hitU, hitV));
+			const hR = heightFn(vec2f(__tsover_add(hitU, normalEps), hitV));
+			const hUp = heightFn(vec2f(hitU, __tsover_add(hitV, normalEps)));
 			const dhdu = __tsover_div(__tsover_sub(hR, hC), normalEps);
 			const dhdv = __tsover_div(__tsover_sub(hUp, hC), normalEps);
-			const nrm = std.normalize(d.vec3f(__tsover_mul(dhdu, -.5), __tsover_mul(dhdv, -.5), 1));
-			const lightDir = std.normalize(d.vec3f(p.lightX, p.lightY, p.lightZ));
+			const nrm = normalize(vec3f(__tsover_mul(dhdu, -.5), __tsover_mul(dhdv, -.5), 1));
+			const lightDir = normalize(vec3f(p.lightX, p.lightY, p.lightZ));
 			const viewDir = rayDir.mul(-1);
-			const diffuse = std.clamp(std.dot(nrm, lightDir), 0, 1);
-			const halfVec = std.normalize(lightDir.add(viewDir));
+			const diffuse = clamp(dot(nrm, lightDir), 0, 1);
+			const halfVec = normalize(lightDir.add(viewDir));
 			const specPow = __tsover_add(__tsover_mul(p.glossiness, 128), 4);
-			const specular = __tsover_mul(std.pow(std.clamp(std.dot(nrm, halfVec), 0, 1), specPow), p.highlights);
-			const ambient = d.vec3f(.4, .4, .4);
+			const specular = __tsover_mul(pow(clamp(dot(nrm, halfVec), 0, 1), specPow), p.highlights);
+			const ambient = vec3f(.4, .4, .4);
 			const tintedDiffuse = p.lightColor.mul(__tsover_mul(diffuse, .6));
 			const tintedSpec = p.lightColor.mul(specular);
 			const totalLight = ambient.add(tintedDiffuse).add(tintedSpec);
-			lit = std.clamp(std.mix(d.vec3f(1, 1, 1), totalLight, p.lighting), d.vec3f(0, 0, 0), d.vec3f(3, 3, 3));
+			lit = clamp(mix(vec3f(1, 1, 1), totalLight, p.lighting), vec3f(0, 0, 0), vec3f(3, 3, 3));
 		}
-		const CUTOFF_RANGE = d.f32(15);
+		const CUTOFF_RANGE = f32(15);
 		const edgeAA = .05;
 		const nearT = __tsover_mul(p.nearCutoff, CUTOFF_RANGE);
 		const farT = __tsover_mul(p.farCutoff, CUTOFF_RANGE);
-		const nearMask = std.smoothstep(__tsover_sub(nearT, edgeAA), __tsover_add(nearT, edgeAA), finalT);
-		const farMask = std.smoothstep(__tsover_add(farT, edgeAA), __tsover_sub(farT, edgeAA), finalT);
+		const nearMask = smoothstep(__tsover_sub(nearT, edgeAA), __tsover_add(nearT, edgeAA), finalT);
+		const farMask = smoothstep(__tsover_add(farT, edgeAA), __tsover_sub(farT, edgeAA), finalT);
 		const finalMask = __tsover_mul(__tsover_mul(hit, outOfBoundsMask), __tsover_mul(nearMask, farMask));
-		std.textureStore(computeLayout.$.uvMaskTex, d.vec2u(cx, cy), d.vec4f(finalUV.x, finalUV.y, finalMask, 0));
-		std.textureStore(computeLayout.$.litTex, d.vec2u(cx, cy), d.vec4f(lit, 0));
+		textureStore(computeLayout.$.uvMaskTex, vec2u(cx, cy), vec4f(finalUV.x, finalUV.y, finalMask, 0));
+		textureStore(computeLayout.$.litTex, vec2u(cx, cy), vec4f(lit, 0));
 	}), {
 		v: 1,
 		name: void 0,
@@ -4255,10 +4256,10 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 		},
 		externals: () => ({
 			computeLayout,
-			d,
+			d: data_exports,
 			COMPUTE_W,
 			COMPUTE_H,
-			std,
+			std: std_exports,
 			heightFn,
 			edgeMode,
 			edges: edges_exports,
@@ -4266,14 +4267,13 @@ function makeComputeKernel(waveType, octaveCount, edgeMode, lightingEnabled, cur
 		})
 	}) && $.f)({})).$name("surface3dRaymarch");
 }
-const surface3dCompose = tgpu.fn([
-	d.vec4f,
-	d.vec3f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, lit, mask) => {
+const surface3dCompose = src_default.fn([
+	vec4f,
+	vec3f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, lit, mask) => {
 	"use gpu";
-	const finalRgb = std.clamp(childColor.xyz.mul(lit), d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
-	return d.vec4f(finalRgb, __tsover_mul(childColor.w, mask));
+	return vec4f(clamp(childColor.xyz.mul(lit), vec3f(0, 0, 0), vec3f(1, 1, 1)), __tsover_mul(childColor.w, mask));
 }), {
 	v: 1,
 	name: void 0,
@@ -4365,8 +4365,8 @@ const surface3dCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {
@@ -4709,9 +4709,9 @@ const componentDefinition = {
 		});
 		const uvMaskMap = registerComputeTexture(uvMaskTex);
 		const litMap = registerComputeTexture(litTex);
-		const bufferA = createStateBuffer(root, d.f32, WAVE_CELLS);
-		const bufferB = createStateBuffer(root, d.f32, WAVE_CELLS);
-		const readBuf = createStateBuffer(root, d.f32, WAVE_CELLS);
+		const bufferA = createStateBuffer(root, f32, WAVE_CELLS);
+		const bufferB = createStateBuffer(root, f32, WAVE_CELLS);
+		const readBuf = createStateBuffer(root, f32, WAVE_CELLS);
 		const paramsU = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(S3Params), "paramsU");
 		let curW = Math.max(1, Math.round(dimensions.width));
 		let curH = Math.max(1, Math.round(dimensions.height));
@@ -4857,17 +4857,17 @@ const componentDefinition = {
 				t: animT,
 				aspect,
 				focal,
-				camPos: d.vec3f(camPos[0], camPos[1], camPos[2]),
-				camForward: d.vec3f(fwd[0], fwd[1], fwd[2]),
-				camRight: d.vec3f(camRight[0], camRight[1], camRight[2]),
-				camUp: d.vec3f(camUp[0], camUp[1], camUp[2]),
+				camPos: vec3f(camPos[0], camPos[1], camPos[2]),
+				camForward: vec3f(fwd[0], fwd[1], fwd[2]),
+				camRight: vec3f(camRight[0], camRight[1], camRight[2]),
+				camUp: vec3f(camUp[0], camUp[1], camUp[2]),
 				lighting: (getCpuValue("lighting") ?? 30) * .035,
 				glossiness: (getCpuValue("glossiness") ?? 0) * .01,
 				highlights: (getCpuValue("highlights") ?? 15) * .04,
 				lightX: getCpuValue("lightX") ?? .4,
 				lightY: getCpuValue("lightY") ?? -.6,
 				lightZ: getCpuValue("lightZ") ?? .7,
-				lightColor: d.vec3f(lc?.x ?? 1, lc?.y ?? 1, lc?.z ?? 1),
+				lightColor: vec3f(lc?.x ?? 1, lc?.y ?? 1, lc?.z ?? 1),
 				nearCutoff: getCpuValue("nearCutoff") ?? 0,
 				farCutoff: getCpuValue("farCutoff") ?? 1,
 				cursorWaveX: (cursorWorldUVx - .5) / WAVE_HALFEXTENT + .5,

package/dist/core/{Swirl-nXMWVY2X.js → Swirl-DDQif_lC.js}

@@ -1,29 +1,26 @@
-import { Et as mixColorStopsRuntime, Ht as call, J as std, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig, t as animatedTime } from "./porters-BmU6G9TR.js";
-const swirlField = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, detail, blend, animTime) => {
+import { $t as vec2f, H as mixColorsLinear, It as sin, Lt as smoothstep, U as mixColorsVariants, Vt as data_exports, an as f32, et as src_default, nt as std_exports, p as call, vt as cos } from "./edges-BXNBKxSN.js";
+import { S as mixColorStopsRuntime, h as colorStopsPropConfig, t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const swirlField = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, detail, blend, animTime) => {
 	"use gpu";
 	const t = animTime;
 	const freq1 = detail;
-	const d1 = d.vec2f(__tsover_add(uv.x, __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(freq1, 1.7)), __tsover_mul(t, .8))), .12), __tsover_mul(std.cos(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(freq1, .9)), __tsover_mul(t, .5))), .05))), __tsover_add(uv.y, __tsover_add(__tsover_mul(std.cos(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(freq1, 1.3)), __tsover_mul(t, .6))), .12), __tsover_mul(std.sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(freq1, 1.1)), __tsover_mul(t, .7))), .05))));
-	const pattern1 = std.sin(__tsover_add(__tsover_add(__tsover_mul(d1.x, __tsover_mul(freq1, 2.1)), __tsover_mul(d1.y, __tsover_mul(freq1, 1.8))), __tsover_mul(t, .4)));
+	const d1 = vec2f(__tsover_add(uv.x, __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(freq1, 1.7)), __tsover_mul(t, .8))), .12), __tsover_mul(cos(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(freq1, .9)), __tsover_mul(t, .5))), .05))), __tsover_add(uv.y, __tsover_add(__tsover_mul(cos(__tsover_sub(__tsover_mul(uv.x, __tsover_mul(freq1, 1.3)), __tsover_mul(t, .6))), .12), __tsover_mul(sin(__tsover_add(__tsover_mul(uv.y, __tsover_mul(freq1, 1.1)), __tsover_mul(t, .7))), .05))));
+	const pattern1 = sin(__tsover_add(__tsover_add(__tsover_mul(d1.x, __tsover_mul(freq1, 2.1)), __tsover_mul(d1.y, __tsover_mul(freq1, 1.8))), __tsover_mul(t, .4)));
 	const freq2 = __tsover_mul(detail, 2.1);
-	const d2 = d.vec2f(__tsover_add(d1.x, __tsover_add(__tsover_mul(std.cos(__tsover_sub(__tsover_mul(d1.y, __tsover_mul(freq2, 2.7)), __tsover_mul(t, .45))), .07), __tsover_mul(std.sin(__tsover_add(__tsover_mul(d1.x, __tsover_mul(freq2, 1.9)), __tsover_mul(t, .6))), .04))), __tsover_add(d1.y, __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(d1.x, __tsover_mul(freq2, 2.3)), __tsover_mul(t, .65))), .07), __tsover_mul(std.cos(__tsover_sub(__tsover_mul(d1.y, __tsover_mul(freq2, 1.6)), __tsover_mul(t, .4))), .04))));
-	const pattern2 = std.cos(__tsover_add(__tsover_sub(__tsover_mul(d2.x, __tsover_mul(freq2, 1.4)), __tsover_mul(d2.y, __tsover_mul(freq2, 1.9))), __tsover_mul(t, .35)));
+	const d2 = vec2f(__tsover_add(d1.x, __tsover_add(__tsover_mul(cos(__tsover_sub(__tsover_mul(d1.y, __tsover_mul(freq2, 2.7)), __tsover_mul(t, .45))), .07), __tsover_mul(sin(__tsover_add(__tsover_mul(d1.x, __tsover_mul(freq2, 1.9)), __tsover_mul(t, .6))), .04))), __tsover_add(d1.y, __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(d1.x, __tsover_mul(freq2, 2.3)), __tsover_mul(t, .65))), .07), __tsover_mul(cos(__tsover_sub(__tsover_mul(d1.y, __tsover_mul(freq2, 1.6)), __tsover_mul(t, .4))), .04))));
+	const pattern2 = cos(__tsover_add(__tsover_sub(__tsover_mul(d2.x, __tsover_mul(freq2, 1.4)), __tsover_mul(d2.y, __tsover_mul(freq2, 1.9))), __tsover_mul(t, .35)));
 	const freq3 = __tsover_mul(detail, 3.7);
-	const d3 = d.vec2f(__tsover_add(d2.x, __tsover_add(__tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(d2.y, __tsover_mul(freq3, 1.8)), __tsover_mul(t, .85))), .04), __tsover_mul(std.cos(__tsover_sub(__tsover_mul(d2.x, __tsover_mul(freq3, 1.3)), __tsover_mul(t, .55))), .025)), __tsover_mul(std.sin(__tsover_add(__tsover_mul(__tsover_add(d2.x, d2.y), __tsover_mul(freq3, .7)), __tsover_mul(t, .9))), .02))), __tsover_add(d2.y, __tsover_add(__tsover_add(__tsover_mul(std.cos(__tsover_sub(__tsover_mul(d2.x, __tsover_mul(freq3, 1.6)), __tsover_mul(t, .75))), .04), __tsover_mul(std.sin(__tsover_add(__tsover_mul(d2.y, __tsover_mul(freq3, 1.1)), __tsover_mul(t, .5))), .025)), __tsover_mul(std.cos(__tsover_sub(__tsover_mul(__tsover_add(d2.x, d2.y), __tsover_mul(freq3, .8)), __tsover_mul(t, .95))), .02))));
-	const pattern3 = std.sin(__tsover_sub(__tsover_add(__tsover_mul(d3.x, __tsover_mul(freq3, 1.1)), __tsover_mul(d3.y, __tsover_mul(freq3, 1.5))), __tsover_mul(t, .55)));
+	const d3 = vec2f(__tsover_add(d2.x, __tsover_add(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(d2.y, __tsover_mul(freq3, 1.8)), __tsover_mul(t, .85))), .04), __tsover_mul(cos(__tsover_sub(__tsover_mul(d2.x, __tsover_mul(freq3, 1.3)), __tsover_mul(t, .55))), .025)), __tsover_mul(sin(__tsover_add(__tsover_mul(__tsover_add(d2.x, d2.y), __tsover_mul(freq3, .7)), __tsover_mul(t, .9))), .02))), __tsover_add(d2.y, __tsover_add(__tsover_add(__tsover_mul(cos(__tsover_sub(__tsover_mul(d2.x, __tsover_mul(freq3, 1.6)), __tsover_mul(t, .75))), .04), __tsover_mul(sin(__tsover_add(__tsover_mul(d2.y, __tsover_mul(freq3, 1.1)), __tsover_mul(t, .5))), .025)), __tsover_mul(cos(__tsover_sub(__tsover_mul(__tsover_add(d2.x, d2.y), __tsover_mul(freq3, .8)), __tsover_mul(t, .95))), .02))));
+	const pattern3 = sin(__tsover_sub(__tsover_add(__tsover_mul(d3.x, __tsover_mul(freq3, 1.1)), __tsover_mul(d3.y, __tsover_mul(freq3, 1.5))), __tsover_mul(t, .55)));
 	const combinedPattern = __tsover_add(__tsover_add(__tsover_mul(pattern1, .45), __tsover_mul(pattern2, .35)), __tsover_mul(pattern3, .2));
 	const blendBias = __tsover_mul(__tsover_sub(blend, 50), .006);
-	const normalizedPattern = __tsover_add(__tsover_add(__tsover_mul(combinedPattern, .5), .5), blendBias);
-	const blendFactor = std.smoothstep(.3, .7, normalizedPattern);
-	const shimmer = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(t, 2.5), __tsover_mul(combinedPattern, 8))), .015), 1);
-	return d.vec2f(blendFactor, shimmer);
+	return vec2f(smoothstep(.3, .7, __tsover_add(__tsover_add(__tsover_mul(combinedPattern, .5), .5), blendBias)), __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(t, 2.5), __tsover_mul(combinedPattern, 8))), .015), 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -1047,8 +1044,8 @@ const swirlField = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Teardrop-Bjtkigk4.js → Teardrop-CvpdElTs.js}

@@ -1,15 +1,16 @@
-import { C as ShapeMask, F as sdf_exports, Ht as call, I as shapeLocalCoords, Jt as vec4, R as strokeMaskFromSdf, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, z as teardropSdf } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-const teardropShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
+import { $t as vec2f, H as mixColorsLinear, U as mixColorsVariants, an as f32, et as src_default, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { g as shapeLocalCoords, h as sdf_exports, n as ShapeMask, v as strokeMaskFromSdf, y as teardropSdf } from "./sdf-R0EN3EvS.js";
+import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const teardropShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, height, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);