shaders 3.0.448 → 3.0.450

package/dist/core/{GridDistortion-D_21zIrm.js → GridDistortion-BpqDvqj6.js}

@@ -1,57 +1,58 @@
-import { Bt as ZERO, Gt as expr, Ht as call, J as std, Lt as sampleRemappedExpr, Tn as d, X as createGuardedCompute, Z as createStateBuffer, cn as unpremultiplyAlpha, jt as composeEdgeRemapExpr, n as tgpu } from "./coords-BkIjixe_.js";
-import { s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { Ct as exp, Gt as arrayOf, N as unpremultiplyAlpha, Ot as max, Qt as struct, Tt as floor, Ut as data_exports, c as sampleRemappedExpr, d as ZERO, et as src_default, g as expr, ht as abs, ln as u32, mt as select, n as composeEdgeRemapExpr, nt as std_exports, on as vec4f, ot as textureStore, p as call, qt as textureStorage2d, rn as vec2u, sn as f32, tn as vec2f, yt as clamp } from "./edges-BZUKQxSE.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BoeIXi0l.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var DEFAULT_GRID_SIZE = 20;
 var MIN_GRID = 8;
 var MAX_GRID = 128;
 var MAX_CELLS = MAX_GRID * MAX_GRID;
 var STATE_FORMAT = "rgba16float";
 var clampGrid = (v) => Math.max(MIN_GRID, Math.min(MAX_GRID, Math.floor(v)));
-var updateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var updateLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	buffer: {
-		storage: d.arrayOf(d.vec4f, MAX_CELLS),
+		storage: arrayOf(vec4f, MAX_CELLS),
 		access: "mutable"
 	},
-	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-		cursorX: d.f32,
-		cursorY: d.f32,
-		mouseVelX: d.f32,
-		mouseVelY: d.f32,
-		dt: d.f32,
-		decay: d.f32,
-		intensity: d.f32,
-		radius: d.f32,
-		aspect: d.f32
+	params: { uniform: /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+		cursorX: f32,
+		cursorY: f32,
+		mouseVelX: f32,
+		mouseVelY: f32,
+		dt: f32,
+		decay: f32,
+		intensity: f32,
+		radius: f32,
+		aspect: f32
 	}), "uniform") }
 }), "updateLayout");
-var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var outputLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	buffer: {
-		storage: d.arrayOf(d.vec4f, MAX_CELLS),
+		storage: arrayOf(vec4f, MAX_CELLS),
 		access: "readonly"
 	},
-	dispTex: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") }
+	dispTex: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") }
 }), "outputLayout");
 function makeUpdateKernel(gridSize) {
-	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 = updateLayout.$.params;
-		const idx = __tsover_add(__tsover_mul(cy, d.u32(gridSize)), cx);
+		const idx = __tsover_add(__tsover_mul(cy, u32(gridSize)), cx);
 		const cell = updateLayout.$.buffer[idx];
 		let dx = __tsover_mul(cell.x, __tsover_sub(1, __tsover_mul(p.decay, p.dt)));
 		let dy = __tsover_mul(cell.y, __tsover_sub(1, __tsover_mul(p.decay, p.dt)));
-		const cellX = __tsover_div(__tsover_add(d.f32(cx), .5), d.f32(gridSize));
-		const cellY = __tsover_div(__tsover_add(d.f32(cy), .5), d.f32(gridSize));
-		const ddx = std.select(__tsover_sub(cellX, p.cursorX), __tsover_mul(__tsover_sub(cellX, p.cursorX), p.aspect), p.aspect >= 1);
-		const ddy = std.select(__tsover_div(__tsover_sub(cellY, p.cursorY), p.aspect), __tsover_sub(cellY, p.cursorY), p.aspect >= 1);
+		const cellX = __tsover_div(__tsover_add(f32(cx), .5), f32(gridSize));
+		const cellY = __tsover_div(__tsover_add(f32(cy), .5), f32(gridSize));
+		const ddx = select(__tsover_sub(cellX, p.cursorX), __tsover_mul(__tsover_sub(cellX, p.cursorX), p.aspect), p.aspect >= 1);
+		const ddy = select(__tsover_div(__tsover_sub(cellY, p.cursorY), p.aspect), __tsover_sub(cellY, p.cursorY), p.aspect >= 1);
 		const distSq = __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy));
 		const radius2 = __tsover_mul(p.radius, 2);
-		if (distSq < __tsover_mul(radius2, radius2) && __tsover_add(std.abs(p.mouseVelX), std.abs(p.mouseVelY)) > .01) {
-			const influence = std.exp(__tsover_mul(__tsover_div(distSq, __tsover_mul(p.radius, p.radius)), -1));
+		if (distSq < __tsover_mul(radius2, radius2) && __tsover_add(abs(p.mouseVelX), abs(p.mouseVelY)) > .01) {
+			const influence = exp(__tsover_mul(__tsover_div(distSq, __tsover_mul(p.radius, p.radius)), -1));
 			dx = __tsover_add(dx, __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(p.mouseVelX, influence), p.intensity), p.dt), .5));
 			dy = __tsover_add(dy, __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(p.mouseVelY, influence), p.intensity), p.dt), .5));
 		}
-		dx = std.clamp(dx, -1, 1);
-		dy = std.clamp(dy, -1, 1);
-		updateLayout.$.buffer[idx] = d.vec4f(dx, dy, 0, 0);
+		dx = clamp(dx, -1, 1);
+		dy = clamp(dy, -1, 1);
+		updateLayout.$.buffer[idx] = vec4f(dx, dy, 0, 0);
 	}), {
 		v: 1,
 		name: void 0,
@@ -649,18 +650,18 @@ function makeUpdateKernel(gridSize) {
 		},
 		externals: () => ({
 			updateLayout,
-			d,
+			d: data_exports,
 			gridSize,
-			std
+			std: std_exports
 		})
 	}) && $.f)({})).$name("gridDistortionUpdate");
 }
 function makeOutputKernel(gridSize) {
-	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 idx = __tsover_add(__tsover_mul(cy, d.u32(gridSize)), cx);
+		const idx = __tsover_add(__tsover_mul(cy, u32(gridSize)), cx);
 		const cell = outputLayout.$.buffer[idx];
-		std.textureStore(outputLayout.$.dispTex, d.vec2u(cx, cy), d.vec4f(cell.x, cell.y, 0, 1));
+		textureStore(outputLayout.$.dispTex, vec2u(cx, cy), vec4f(cell.x, cell.y, 0, 1));
 	}), {
 		v: 1,
 		name: void 0,
@@ -772,25 +773,25 @@ function makeOutputKernel(gridSize) {
 			]
 		},
 		externals: () => ({
-			d,
+			d: data_exports,
 			gridSize,
 			outputLayout,
-			std
+			std: std_exports
 		})
 	}) && $.f)({})).$name("gridDistortionOutput");
 }
-const gridCellSnap = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, gridSize, aspect) => {
+const gridCellSnap = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, gridSize, aspect) => {
 	"use gpu";
 	const isWide = aspect > 1;
-	const cellsX = std.max(std.select(__tsover_mul(gridSize, aspect), gridSize, isWide), 1);
-	const cellsY = std.max(std.select(gridSize, __tsover_div(gridSize, aspect), isWide), 1);
-	const cellIndexX = std.floor(__tsover_mul(uv.x, cellsX));
-	const cellIndexY = std.floor(__tsover_mul(uv.y, cellsY));
-	return d.vec2f(__tsover_div(__tsover_add(cellIndexX, .5), cellsX), __tsover_div(__tsover_add(cellIndexY, .5), cellsY));
+	const cellsX = max(select(__tsover_mul(gridSize, aspect), gridSize, isWide), 1);
+	const cellsY = max(select(gridSize, __tsover_div(gridSize, aspect), isWide), 1);
+	const cellIndexX = floor(__tsover_mul(uv.x, cellsX));
+	const cellIndexY = floor(__tsover_mul(uv.y, cellsY));
+	return vec2f(__tsover_div(__tsover_add(cellIndexX, .5), cellsX), __tsover_div(__tsover_add(cellIndexY, .5), cellsY));
 }), {
 	v: 1,
 	name: void 0,
@@ -957,14 +958,14 @@ const gridCellSnap = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const gridDistortOffsetUV = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, disp) => {
+const gridDistortOffsetUV = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, disp) => {
 	"use gpu";
 	const maxDisp = .1;
-	const clamped = std.clamp(disp, d.vec2f(-maxDisp, -maxDisp), d.vec2f(maxDisp, maxDisp));
+	const clamped = clamp(disp, vec2f(-maxDisp, -maxDisp), vec2f(maxDisp, maxDisp));
 	return uv.sub(clamped);
 }), {
 	v: 1,
@@ -1037,8 +1038,8 @@ const gridDistortOffsetUV = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {
@@ -1134,23 +1135,23 @@ const componentDefinition = {
 		const root = gpu?.root;
 		if (!root) return null;
 		const gridSize = clampGrid(getCpuValue("gridSize") ?? DEFAULT_GRID_SIZE);
-		const buffer = createStateBuffer(root, d.vec4f, MAX_CELLS);
+		const buffer = createStateBuffer(root, vec4f, MAX_CELLS);
 		const dispTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [gridSize, gridSize],
 			format: STATE_FORMAT
 		}).$usage("storage", "sampled"), "dispTex");
 		onCleanup(() => dispTex.destroy());
 		const displacement = registerComputeTexture(dispTex);
-		const updateParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(d.struct({
-			cursorX: d.f32,
-			cursorY: d.f32,
-			mouseVelX: d.f32,
-			mouseVelY: d.f32,
-			dt: d.f32,
-			decay: d.f32,
-			intensity: d.f32,
-			radius: d.f32,
-			aspect: d.f32
+		const updateParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createUniform(struct({
+			cursorX: f32,
+			cursorY: f32,
+			mouseVelX: f32,
+			mouseVelY: f32,
+			dt: f32,
+			decay: f32,
+			intensity: f32,
+			radius: f32,
+			aspect: f32
 		})), "updateParams");
 		let curW = Math.max(1, Math.round(dimensions.width));
 		let curH = Math.max(1, Math.round(dimensions.height));

package/dist/core/{Group-DXiB5Qrx.js → Group-bwQnJRec.js}

@@ -1,4 +1,4 @@
-import { Bt as ZERO } from "./coords-BkIjixe_.js";
+import { d as ZERO } from "./edges-BZUKQxSE.js";
 const componentDefinition = {
 	name: "Group",
 	category: "Utilities",

package/dist/core/{HTMLInCanvas-xXPLTYIv.js → HTMLInCanvas-gCf64ozE.js}

@@ -1,4 +1,4 @@
-import { Ht as call, Jt as vec4, in as srgbToLinear } from "./coords-BkIjixe_.js";
+import { k as srgbToLinear, p as call, y as vec4 } from "./edges-BZUKQxSE.js";
 const componentDefinition = {
 	name: "HTMLInCanvas",
 	deprecatedNames: ["DOMTexture"],

package/dist/core/{Halftone-DszIQsyx.js → Halftone-B_WouxiP.js}

@@ -1,28 +1,27 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, r as transformAngle } from "./transformations-t0d2-uSX.js";
+import { At as mix, Dt as length, Et as fract, N as unpremultiplyAlpha, Ot as max, Rt as sin, St as dot, Ut as data_exports, _ as floatE, bt as cos, d as ZERO, et as src_default, in as vec3f, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, y as vec4, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { a as transformColor, r as transformAngle } from "./transformations-CsPUHppB.js";
 var SMOOTHNESS = .1;
 var DEG_TO_RAD = Math.PI / 180;
 var transformStyle = (value) => value === "cmyk" ? 1 : 0;
 var styleModeOf = (raw) => typeof raw === "number" ? raw : raw === "cmyk" ? 1 : 0;
-const halftoneClassic = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, uv, aspect, angleDeg, frequency) => {
+const halftoneClassic = src_default.fn([
+	vec4f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((childColor, uv, aspect, angleDeg, frequency) => {
 	"use gpu";
-	const aspectUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const c = std.cos(angleRad);
-	const s = std.sin(angleRad);
-	const rotatedUV = d.vec2f(std.dot(aspectUV, d.vec2f(c, __tsover_mul(s, -1))), std.dot(aspectUV, d.vec2f(s, c)));
-	const gridUV = std.fract(rotatedUV.mul(frequency)).sub(d.vec2f(.5, .5));
-	const brightness = std.dot(d.vec3f(childColor.x, childColor.y, childColor.z), d.vec3f(.299, .587, .114));
+	const c = cos(angleRad);
+	const s = sin(angleRad);
+	const gridUV = fract(vec2f(dot(aspectUV, vec2f(c, __tsover_mul(s, -1))), dot(aspectUV, vec2f(s, c))).mul(frequency)).sub(vec2f(.5, .5));
+	const brightness = dot(vec3f(childColor.x, childColor.y, childColor.z), vec3f(.299, .587, .114));
 	const dotSize = __tsover_add(__tsover_mul(brightness, .7), .15);
-	const dist = std.length(gridUV);
-	const dotPattern = __tsover_sub(1, std.smoothstep(__tsover_sub(dotSize, SMOOTHNESS), __tsover_add(dotSize, SMOOTHNESS), dist));
-	return d.vec4f(__tsover_mul(childColor.x, dotPattern), __tsover_mul(childColor.y, dotPattern), __tsover_mul(childColor.z, dotPattern), __tsover_mul(childColor.w, dotPattern));
+	const dist = length(gridUV);
+	const dotPattern = __tsover_sub(1, smoothstep(__tsover_sub(dotSize, SMOOTHNESS), __tsover_add(dotSize, SMOOTHNESS), dist));
+	return vec4f(__tsover_mul(childColor.x, dotPattern), __tsover_mul(childColor.y, dotPattern), __tsover_mul(childColor.z, dotPattern), __tsover_mul(childColor.w, dotPattern));
 }), {
 	v: 1,
 	name: void 0,
@@ -371,22 +370,22 @@ const halftoneClassic = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		SMOOTHNESS
 	})
 }) && $.f)({}));
-const halftonePlateUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, misprintAngleDeg, plateIndexDeg, misprint, aspect) => {
+const halftonePlateUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, misprintAngleDeg, plateIndexDeg, misprint, aspect) => {
 	"use gpu";
 	const angleRad = __tsover_mul(__tsover_add(misprintAngleDeg, plateIndexDeg), DEG_TO_RAD);
-	return d.vec2f(__tsover_add(uv.x, __tsover_mul(std.cos(angleRad), misprint)), __tsover_add(uv.y, __tsover_div(__tsover_mul(std.sin(angleRad), misprint), aspect)));
+	return vec2f(__tsover_add(uv.x, __tsover_mul(cos(angleRad), misprint)), __tsover_add(uv.y, __tsover_div(__tsover_mul(sin(angleRad), misprint), aspect)));
 }), {
 	v: 1,
 	name: void 0,
@@ -493,13 +492,13 @@ const halftonePlateUV = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const halftoneChannelK = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
+const halftoneChannelK = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
 	"use gpu";
-	return __tsover_sub(1, std.max(std.max(s.x, s.y), s.z));
+	return __tsover_sub(1, max(max(s.x, s.y), s.z));
 }), {
 	v: 1,
 	name: void 0,
@@ -544,12 +543,12 @@ const halftoneChannelK = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (glob
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const halftoneChannelC = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
+const halftoneChannelC = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
 	"use gpu";
 	const k = halftoneChannelK(s);
-	const invK = std.max(__tsover_sub(1, k), 1e-4);
+	const invK = max(__tsover_sub(1, k), 1e-4);
 	return __tsover_div(__tsover_sub(__tsover_sub(1, s.x), k), invK);
 }), {
 	v: 1,
@@ -612,13 +611,13 @@ const halftoneChannelC = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (glob
 	},
 	externals: () => ({
 		halftoneChannelK,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const halftoneChannelM = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
+const halftoneChannelM = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
 	"use gpu";
 	const k = halftoneChannelK(s);
-	const invK = std.max(__tsover_sub(1, k), 1e-4);
+	const invK = max(__tsover_sub(1, k), 1e-4);
 	return __tsover_div(__tsover_sub(__tsover_sub(1, s.y), k), invK);
 }), {
 	v: 1,
@@ -681,13 +680,13 @@ const halftoneChannelM = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (glob
 	},
 	externals: () => ({
 		halftoneChannelK,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const halftoneChannelY = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
+const halftoneChannelY = src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((s) => {
 	"use gpu";
 	const k = halftoneChannelK(s);
-	const invK = std.max(__tsover_sub(1, k), 1e-4);
+	const invK = max(__tsover_sub(1, k), 1e-4);
 	return __tsover_div(__tsover_sub(__tsover_sub(1, s.z), k), invK);
 }), {
 	v: 1,
@@ -750,26 +749,24 @@ const halftoneChannelY = tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (glob
 	},
 	externals: () => ({
 		halftoneChannelK,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const halftonePlateGrid = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angleDeg, intensity, frequency) => {
+const halftonePlateGrid = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angleDeg, intensity, frequency) => {
 	"use gpu";
-	const aspectUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const c = std.cos(angleRad);
-	const s = std.sin(angleRad);
-	const rotatedUV = d.vec2f(std.dot(aspectUV, d.vec2f(c, __tsover_mul(s, -1))), std.dot(aspectUV, d.vec2f(s, c)));
-	const grid = std.fract(rotatedUV.mul(frequency)).sub(d.vec2f(.5, .5));
-	const dist = std.length(grid);
+	const c = cos(angleRad);
+	const s = sin(angleRad);
+	const dist = length(fract(vec2f(dot(aspectUV, vec2f(c, __tsover_mul(s, -1))), dot(aspectUV, vec2f(s, c))).mul(frequency)).sub(vec2f(.5, .5)));
 	const size = __tsover_sub(__tsover_mul(intensity, .75), SMOOTHNESS);
-	return __tsover_sub(1, std.smoothstep(__tsover_sub(size, SMOOTHNESS), __tsover_add(size, SMOOTHNESS), dist));
+	return __tsover_sub(1, smoothstep(__tsover_sub(size, SMOOTHNESS), __tsover_add(size, SMOOTHNESS), dist));
 }), {
 	v: 1,
 	name: void 0,
@@ -1015,15 +1012,15 @@ const halftonePlateGrid = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		SMOOTHNESS
 	})
 }) && $.f)({}));
-const halftoneTransmission = tgpu.fn([d.vec4f, d.f32], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((inkColor, inkMask) => {
+const halftoneTransmission = src_default.fn([vec4f, f32], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((inkColor, inkMask) => {
 	"use gpu";
-	return std.mix(d.vec3f(1, 1, 1), d.vec3f(inkColor.x, inkColor.y, inkColor.z), d.vec3f(__tsover_mul(inkMask, inkColor.w)));
+	return mix(vec3f(1, 1, 1), vec3f(inkColor.x, inkColor.y, inkColor.z), vec3f(__tsover_mul(inkMask, inkColor.w)));
 }), {
 	v: 1,
 	name: void 0,
@@ -1104,8 +1101,8 @@ const halftoneTransmission = tgpu.fn([d.vec4f, d.f32], d.vec3f)(/* @__PURE__ */
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Heart-COpnSJPD.js → Heart-Bmt2TLNz.js}

@@ -1,14 +1,15 @@
-import { A as heartSdf, 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 } 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 heartShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
+import { H as mixColorsLinear, U as mixColorsVariants, et as src_default, p as call, sn as f32, tn as vec2f, y as vec4 } from "./edges-BZUKQxSE.js";
+import { g as shapeLocalCoords, h as sdf_exports, n as ShapeMask, u as heartSdf, v as strokeMaskFromSdf } from "./sdf-o99ONcMJ.js";
+import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const heartShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{Heatmap-CMm8SD-P.js → Heatmap-Ruef741_.js}

@@ -1,8 +1,10 @@
-import { Et as mixColorStopsRuntime, F as sdf_exports, Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, pt as noise_exports, st as hash12, y as sdf3d_exports, yt as value12 } 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 { h as colorStopsPropConfig, t as animatedTime } from "./porters-BmU6G9TR.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { At as mix, Ct as exp, Et as fract, H as mixColorsLinear, Mt as pow, Ot as max, Rt as sin, U as mixColorsVariants, Ut as data_exports, bt as cos, et as src_default, ht as abs, in as vec3f, kt as min, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, y as vec4, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { S as mixColorStopsRuntime, h as colorStopsPropConfig, t as animatedTime } from "./porters-DogLzpKT.js";
+import { p as noise_exports, s as hash12, y as value12 } from "./noise-Cq0KUOSC.js";
+import { h as sdf_exports } from "./sdf-o99ONcMJ.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-Dg4GQ5vW.js";
+import { n as glass_exports } from "./glass-BVqgjSPg.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS } = sdf3d_exports;
@@ -37,19 +39,19 @@ var DEFAULT_STOPS = [
 		position: 1
 	}
 ];
-const heatmapShadow = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((a, b, tk, phase) => {
+const heatmapShadow = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((a, b, tk, phase) => {
 	"use gpu";
-	const posS = std.mix(-.6, .6, tk);
-	const wob = __tsover_sub(value12(d.vec2f(__tsover_add(__tsover_mul(b, 4), __tsover_mul(phase, 13.7)), __tsover_add(__tsover_mul(tk, 3), __tsover_mul(phase, 7.1)))), .5);
+	const posS = mix(-.6, .6, tk);
+	const wob = __tsover_sub(value12(vec2f(__tsover_add(__tsover_mul(b, 4), __tsover_mul(phase, 13.7)), __tsover_add(__tsover_mul(tk, 3), __tsover_mul(phase, 7.1)))), .5);
 	const aEff = __tsover_add(__tsover_sub(a, posS), __tsover_mul(wob, .12));
-	const band = std.exp(__tsover_div(__tsover_mul(__tsover_mul(aEff, aEff), -1), __tsover_mul(.16, .16)));
-	const gate = __tsover_mul(std.smoothstep(0, .15, tk), __tsover_sub(1, std.smoothstep(.85, 1, tk)));
-	return std.clamp(__tsover_mul(band, gate), 0, 1);
+	const band = exp(__tsover_div(__tsover_mul(__tsover_mul(aEff, aEff), -1), __tsover_mul(.16, .16)));
+	const gate = __tsover_mul(smoothstep(0, .15, tk), __tsover_sub(1, smoothstep(.85, 1, tk)));
+	return clamp(__tsover_mul(band, gate), 0, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -272,55 +274,55 @@ const heatmapShadow = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		noise: noise_exports,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const heatmapHeatField = tgpu.fn([
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.vec4f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fieldRaw, sdfUV, animTime, p0, scale) => {
+const heatmapHeatField = src_default.fn([
+	f32,
+	vec2f,
+	f32,
+	vec4f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((fieldRaw, sdfUV, animTime, p0, scale) => {
 	"use gpu";
 	const innerGlow = p0.x;
 	const outerGlow = p0.y;
 	const contour = p0.z;
 	const angleDeg = p0.w;
-	const scl = std.max(scale, .001);
+	const scl = max(scale, .001);
 	const f = __tsover_div(fieldRaw, scl);
-	const inside = __tsover_sub(1, std.smoothstep(-.003, .003, f));
+	const inside = __tsover_sub(1, smoothstep(-.003, .003, f));
 	const angleRad = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const dirX = std.cos(angleRad);
-	const dirY = std.sin(angleRad);
+	const dirX = cos(angleRad);
+	const dirY = sin(angleRad);
 	const a = __tsover_add(__tsover_mul(dirX, __tsover_sub(sdfUV.x, .5)), __tsover_mul(dirY, __tsover_sub(sdfUV.y, .5)));
 	const b = __tsover_sub(__tsover_mul(dirY, __tsover_sub(sdfUV.x, .5)), __tsover_mul(dirX, __tsover_sub(sdfUV.y, .5)));
 	const tBase = __tsover_sub(__tsover_mul(.1, animTime), .3);
-	const t0 = std.fract(tBase);
-	const t1 = std.fract(__tsover_add(tBase, __tsover_div(1, 3)));
-	const t2 = std.fract(__tsover_add(tBase, __tsover_div(2, 3)));
-	const innerBlur = std.exp(__tsover_div(__tsover_mul(std.max(__tsover_mul(f, -1), 0), -1), .12));
+	const t0 = fract(tBase);
+	const t1 = fract(__tsover_add(tBase, __tsover_div(1, 3)));
+	const t2 = fract(__tsover_add(tBase, __tsover_div(2, 3)));
+	const innerBlur = exp(__tsover_div(__tsover_mul(max(__tsover_mul(f, -1), 0), -1), .12));
 	let inner = __tsover_add(.8, __tsover_mul(.8, innerBlur));
-	inner = std.mix(inner, 0, heatmapShadow(a, b, t0, 1));
-	inner = std.mix(inner, 0, heatmapShadow(a, b, t1, 2));
-	inner = std.mix(inner, 0, heatmapShadow(a, b, t2, 3));
+	inner = mix(inner, 0, heatmapShadow(a, b, t0, 1));
+	inner = mix(inner, 0, heatmapShadow(a, b, t1, 2));
+	inner = mix(inner, 0, heatmapShadow(a, b, t2, 3));
 	inner = __tsover_mul(inner, __tsover_mul(2, innerGlow));
-	inner = __tsover_add(inner, __tsover_mul(__tsover_mul(contour, 2), std.exp(__tsover_div(__tsover_mul(std.abs(f), -1), .03))));
-	inner = __tsover_mul(std.min(inner, 1), inside);
-	inner = std.pow(std.max(inner, 0), 1.2);
-	const outerBlur = std.exp(__tsover_div(__tsover_mul(std.max(f, 0), -1), __tsover_add(.05, __tsover_mul(.15, outerGlow))));
-	const t3 = std.fract(__tsover_sub(__tsover_mul(tBase, 3), .1));
-	const yy = std.fract(__tsover_sub(__tsover_mul(a, 1.2), t3));
-	const animatedMask = __tsover_add(.5, __tsover_mul(std.smoothstep(.3, .65, yy), __tsover_sub(1, std.smoothstep(.65, 1, yy))));
-	const outer = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(.9, std.pow(outerBlur, .8)), animatedMask), 5), outerGlow), outerGlow), __tsover_sub(1, inside));
-	let heat = std.clamp(__tsover_add(inner, outer), 0, 1);
-	const frame = __tsover_mul(__tsover_mul(__tsover_mul(std.smoothstep(-.06, .1, sdfUV.x), __tsover_sub(1, std.smoothstep(.9, 1.06, sdfUV.x))), std.smoothstep(-.06, .1, sdfUV.y)), __tsover_sub(1, std.smoothstep(.9, 1.06, sdfUV.y)));
+	inner = __tsover_add(inner, __tsover_mul(__tsover_mul(contour, 2), exp(__tsover_div(__tsover_mul(abs(f), -1), .03))));
+	inner = __tsover_mul(min(inner, 1), inside);
+	inner = pow(max(inner, 0), 1.2);
+	const outerBlur = exp(__tsover_div(__tsover_mul(max(f, 0), -1), __tsover_add(.05, __tsover_mul(.15, outerGlow))));
+	const t3 = fract(__tsover_sub(__tsover_mul(tBase, 3), .1));
+	const yy = fract(__tsover_sub(__tsover_mul(a, 1.2), t3));
+	const animatedMask = __tsover_add(.5, __tsover_mul(smoothstep(.3, .65, yy), __tsover_sub(1, smoothstep(.65, 1, yy))));
+	const outer = __tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(__tsover_mul(.9, pow(outerBlur, .8)), animatedMask), 5), outerGlow), outerGlow), __tsover_sub(1, inside));
+	let heat = clamp(__tsover_add(inner, outer), 0, 1);
+	const frame = __tsover_mul(__tsover_mul(__tsover_mul(smoothstep(-.06, .1, sdfUV.x), __tsover_sub(1, smoothstep(.9, 1.06, sdfUV.x))), smoothstep(-.06, .1, sdfUV.y)), __tsover_sub(1, smoothstep(.9, 1.06, sdfUV.y)));
 	heat = __tsover_mul(heat, frame);
-	heat = __tsover_add(heat, __tsover_mul(.005, __tsover_sub(hash12(d.vec2f(__tsover_mul(sdfUV.x, 991.3), __tsover_mul(sdfUV.y, 787.7))), .5)));
-	const coverage = __tsover_mul(std.clamp(__tsover_add(inside, outer), 0, 1), frame);
-	return d.vec2f(std.clamp(heat, 0, 1), coverage);
+	heat = __tsover_add(heat, __tsover_mul(.005, __tsover_sub(hash12(vec2f(__tsover_mul(sdfUV.x, 991.3), __tsover_mul(sdfUV.y, 787.7))), .5)));
+	const coverage = __tsover_mul(clamp(__tsover_add(inside, outer), 0, 1), frame);
+	return vec2f(clamp(heat, 0, 1), coverage);
 }), {
 	v: 1,
 	name: void 0,
@@ -1298,16 +1300,16 @@ const heatmapHeatField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		DEG_TO_RAD,
 		heatmapShadow,
 		noise: noise_exports,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const heatmapCompose = tgpu.fn([d.f32, d.vec4f], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coverage, ramp) => {
+const heatmapCompose = src_default.fn([f32, vec4f], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((coverage, ramp) => {
 	"use gpu";
-	return d.vec4f(std.clamp(ramp.xyz, d.vec3f(0), d.vec3f(1)), __tsover_mul(ramp.w, coverage));
+	return vec4f(clamp(ramp.xyz, vec3f(0), vec3f(1)), __tsover_mul(ramp.w, coverage));
 }), {
 	v: 1,
 	name: void 0,
@@ -1372,8 +1374,8 @@ const heatmapCompose = tgpu.fn([d.f32, d.vec4f], d.vec4f)(/* @__PURE__ */ (($) =
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {