shaders 3.0.447 → 3.0.449

package/dist/core/{IsometricCubes-ChKqYTIw.js → IsometricCubes-CIieztxI.js}

@@ -1,12 +1,12 @@
-import { Ht as call, J as std, Jt as vec4, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, qt as mixExpr } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Ct as floor, Dt as min, Et as max, H as mixColorsLinear, It as sin, Lt as smoothstep, Pt as round, U as mixColorsVariants, Vt as data_exports, an as f32, bt as dot, ct as fwidth, et as src_default, mt as abs, nn as vec3f, nt as std_exports, p as call, pt as select, v as mixExpr, vt as cos, wt as fract, y as vec4, zt as step } from "./edges-BXNBKxSN.js";
+import { a as transformColor, o as transformColorSpace, r as transformAngle, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
 var SQRT3 = Math.sqrt(3);
 var SQRT3_2 = Math.sqrt(3) / 2;
 var INV_2_SQRT3 = 2 / Math.sqrt(3);
-var flooredMod2 = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, m) => {
+var flooredMod2 = src_default.fn([vec2f, vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, m) => {
 	"use gpu";
-	return d.vec2f(__tsover_sub(p.x, __tsover_mul(m.x, std.floor(__tsover_div(p.x, m.x)))), __tsover_sub(p.y, __tsover_mul(m.y, std.floor(__tsover_div(p.y, m.y)))));
+	return vec2f(__tsover_sub(p.x, __tsover_mul(m.x, floor(__tsover_div(p.x, m.x)))), __tsover_sub(p.y, __tsover_mul(m.y, floor(__tsover_div(p.y, m.y)))));
 }), {
 	v: 1,
 	name: void 0,
@@ -108,58 +108,53 @@ var flooredMod2 = tgpu.fn([d.vec2f, d.vec2f], d.vec2f)(/* @__PURE__ */ (($) => (
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const isoCubeField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness) => {
+const isoCubeField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, thickness, rotation, softness) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const correctedUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const correctedUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const ang = -__tsover_mul(rotation, DEG_TO_RAD);
-	const cosR = std.cos(ang);
-	const sinR = std.sin(ang);
+	const cosR = cos(ang);
+	const sinR = sin(ang);
 	const centerX = __tsover_mul(aspect, .5);
 	const centerY = .5;
 	const cx = __tsover_sub(correctedUV.x, centerX);
 	const cy = __tsover_sub(correctedUV.y, centerY);
-	const scaledUV = d.vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
-	const s = d.vec2f(1, SQRT3);
+	const scaledUV = vec2f(__tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX), __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY)).mul(cells);
+	const s = vec2f(1, SQRT3);
 	const sh = s.mul(.5);
 	const a = flooredMod2(scaledUV, s).sub(sh);
 	const b = flooredMod2(scaledUV.sub(sh), s).sub(sh);
-	const gv = std.select(b, a, std.dot(a, a) < std.dot(b, b));
+	const gv = select(b, a, dot(a, a) < dot(b, b));
 	const id = scaledUV.sub(gv);
-	const s0 = std.dot(gv, d.vec2f(0, 1));
-	const s1 = std.dot(gv, d.vec2f(-SQRT3_2, -.5));
-	const s2 = std.dot(gv, d.vec2f(SQRT3_2, -.5));
-	const isTop = s0 >= std.max(s1, s2);
-	const isLeft = s1 >= s2;
-	const tone = std.select(std.select(.74, .5, isLeft), 1, isTop);
-	const ix = std.round(__tsover_mul(id.x, 2));
-	const iy = std.round(__tsover_mul(id.y, INV_2_SQRT3));
-	const q0 = std.fract(d.vec2f(ix, iy).mul(d.vec2f(123.34, 345.45)));
-	const q1 = q0.add(std.dot(q0, q0.add(34.345)));
-	const rand = std.fract(__tsover_mul(q1.x, q1.y));
-	const mx = std.max(s0, std.max(s1, s2));
-	const mn = std.min(s0, std.min(s1, s2));
+	const s0 = dot(gv, vec2f(0, 1));
+	const s1 = dot(gv, vec2f(-SQRT3_2, -.5));
+	const s2 = dot(gv, vec2f(SQRT3_2, -.5));
+	const isTop = s0 >= max(s1, s2);
+	const tone = select(select(.74, .5, s1 >= s2), 1, isTop);
+	const q0 = fract(vec2f(round(__tsover_mul(id.x, 2)), round(__tsover_mul(id.y, INV_2_SQRT3))).mul(vec2f(123.34, 345.45)));
+	const q1 = q0.add(dot(q0, q0.add(34.345)));
+	const rand = fract(__tsover_mul(q1.x, q1.y));
+	const mx = max(s0, max(s1, s2));
+	const mn = min(s0, min(s1, s2));
 	const midScore = __tsover_sub(__tsover_sub(__tsover_add(__tsover_add(s0, s1), s2), mx), mn);
 	const internal = __tsover_sub(mx, midScore);
-	const pAbs = d.vec2f(std.abs(gv.x), std.abs(gv.y));
-	const hexDist = std.max(std.dot(pAbs, d.vec2f(.5, SQRT3_2)), pAbs.x);
-	const rimDist = __tsover_sub(.5, hexDist);
-	const edgeField = std.min(internal, rimDist);
+	const pAbs = vec2f(abs(gv.x), abs(gv.y));
+	const hexDist = max(dot(pAbs, vec2f(.5, SQRT3_2)), pAbs.x);
+	const edgeField = min(internal, __tsover_sub(.5, hexDist));
 	const lineWidth = __tsover_mul(thickness, .02);
-	const aa = __tsover_add(__tsover_mul(std.fwidth(scaledUV.x), .5), __tsover_mul(softness, .5));
-	const wire = __tsover_mul(__tsover_sub(1, std.smoothstep(__tsover_sub(lineWidth, aa), __tsover_add(lineWidth, aa), edgeField)), std.step(1e-4, lineWidth));
-	return d.vec3f(rand, tone, wire);
+	const aa = __tsover_add(__tsover_mul(fwidth(scaledUV.x), .5), __tsover_mul(softness, .5));
+	return vec3f(rand, tone, __tsover_mul(__tsover_sub(1, smoothstep(__tsover_sub(lineWidth, aa), __tsover_add(lineWidth, aa), edgeField)), step(1e-4, lineWidth)));
 }), {
 	v: 1,
 	name: void 0,
@@ -1053,9 +1048,9 @@ const isoCubeField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		SQRT3,
 		flooredMod2,
 		SQRT3_2,

package/dist/core/{Kaleidoscope-C8_-tC6T.js → Kaleidoscope-CUMvqmfN.js}

@@ -1,29 +1,29 @@
-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 } from "./coords-BkIjixe_.js";
-import { c as transformPosition, s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Ct as floor, It as sin, N as unpremultiplyAlpha, Tt as length, Vt as data_exports, an as f32, c as sampleRemappedExpr, d as ZERO, et as src_default, gt as atan2, n as composeEdgeRemapExpr, nt as std_exports, p as call, pt as select, vt as cos } from "./edges-BXNBKxSN.js";
+import { c as transformPosition, s as transformEdges } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
 var TAU = Math.PI * 2;
-const kaleidoscopeUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, segments, angle, uv, aspect) => {
+const kaleidoscopeUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, segments, angle, uv, aspect) => {
 	"use gpu";
-	const aspectCorrectedUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
-	const centerPos = d.vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
+	const aspectCorrectedUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const centerPos = vec2f(__tsover_mul(center.x, aspect), __tsover_sub(1, center.y));
 	const delta = aspectCorrectedUV.sub(centerPos);
-	const radius = std.length(delta);
-	const currentAngle = std.atan2(delta.y, delta.x);
+	const radius = length(delta);
+	const currentAngle = atan2(delta.y, delta.x);
 	const rotatedAngle = __tsover_add(currentAngle, __tsover_mul(angle, DEG_TO_RAD));
 	const segmentAngle = __tsover_div(TAU, segments);
 	const segTwo = __tsover_mul(segmentAngle, 2);
-	const wrappedAngle = __tsover_sub(rotatedAngle, __tsover_mul(segTwo, std.floor(__tsover_div(rotatedAngle, segTwo))));
-	const finalAngle = std.select(wrappedAngle, __tsover_sub(segTwo, wrappedAngle), wrappedAngle > segmentAngle);
-	const kaleidoscopeX = __tsover_mul(std.cos(finalAngle), radius);
-	const kaleidoscopeY = __tsover_mul(std.sin(finalAngle), radius);
-	const kaleidoscopePos = centerPos.add(d.vec2f(kaleidoscopeX, kaleidoscopeY));
-	return d.vec2f(__tsover_div(kaleidoscopePos.x, aspect), kaleidoscopePos.y);
+	const wrappedAngle = __tsover_sub(rotatedAngle, __tsover_mul(segTwo, floor(__tsover_div(rotatedAngle, segTwo))));
+	const finalAngle = select(wrappedAngle, __tsover_sub(segTwo, wrappedAngle), wrappedAngle > segmentAngle);
+	const kaleidoscopeX = __tsover_mul(cos(finalAngle), radius);
+	const kaleidoscopeY = __tsover_mul(sin(finalAngle), radius);
+	const kaleidoscopePos = centerPos.add(vec2f(kaleidoscopeX, kaleidoscopeY));
+	return vec2f(__tsover_div(kaleidoscopePos.x, aspect), kaleidoscopePos.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -333,8 +333,8 @@ const kaleidoscopeUV = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		DEG_TO_RAD,
 		TAU
 	})

package/dist/core/{KeyFrames-xR9ZzHKj.js → KeyFrames-mI1J02zX.js}

@@ -1,5 +1,6 @@
-import { Bt as ZERO, J as std, Tn as d, X as createGuardedCompute, Xt as formatFloat, Yt as Expr, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor } from "./transformations-t0d2-uSX.js";
+import { Ct as floor, Dt as min, Et as max, Gt as textureStorage2d, It as sin, Ot as mix, Rt as sqrt, Vt as data_exports, Wt as texture2d, Xt as struct, _t as clamp, an as f32, at as textureStore, b as Expr, d as ZERO, et as src_default, in as vec4f, it as textureLoad, mt as abs, nt as std_exports, on as i32, pt as select, rt as textureDimensions, sn as u32, tn as vec2u, vt as cos, wt as fract, x as formatFloat, xt as exp } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute } from "./compute-BjeJ0sIA.js";
+import { a as transformColor } from "./transformations-CsPUHppB.js";
 var MAX_TRACKERS = 64;
 var TRAIL_LEN = 12;
 var TRAIL_EVERY = 8;
@@ -9,36 +10,36 @@ var STATE_FORMAT = "rgba32float";
 var FEAT_GRID = 96;
 var REFERENCE_HEIGHT = 1080;
 var TWO_PI = 6.283185307179586;
-var TrackParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	dt: d.f32,
-	trackersF: d.f32,
-	agility: d.f32,
-	threshold: d.f32,
-	variance: d.f32,
-	lifespan: d.f32
+var TrackParams = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	dt: f32,
+	trackersF: f32,
+	agility: f32,
+	threshold: f32,
+	variance: f32,
+	lifespan: f32
 }), "TrackParams");
-var featureLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-	src: { texture: d.texture2d(d.f32) },
-	grid: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
+var featureLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	src: { texture: texture2d(f32) },
+	grid: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
 	params: { uniform: TrackParams }
 }), "featureLayout");
-var trackLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-	src: { texture: d.texture2d(d.f32) },
+var trackLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+	src: { texture: texture2d(f32) },
 	featGrid: {
-		texture: d.texture2d(d.f32),
+		texture: texture2d(f32),
 		sampleType: "unfilterable-float"
 	},
 	prev: {
-		texture: d.texture2d(d.f32),
+		texture: texture2d(f32),
 		sampleType: "unfilterable-float"
 	},
-	next: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
-	present: { storageTexture: d.textureStorage2d(STATE_FORMAT, "write-only") },
+	next: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
+	present: { storageTexture: textureStorage2d(STATE_FORMAT, "write-only") },
 	params: { uniform: TrackParams }
 }), "trackLayout");
-const trackHash = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x) => {
+const trackHash = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x) => {
 	"use gpu";
-	return std.fract(__tsover_mul(std.sin(x), 43758.5453123));
+	return fract(__tsover_mul(sin(x), 43758.5453123));
 }), {
 	v: 1,
 	name: void 0,
@@ -71,20 +72,20 @@ const trackHash = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
 function buildScoreFn(mode) {
-	return tgpu.fn([d.vec4f], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c) => {
+	return src_default.fn([vec4f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((c) => {
 		"use gpu";
-		const a = std.max(c.w, 1e-4);
-		const lumaU = std.clamp(__tsover_div(__tsover_add(__tsover_add(__tsover_mul(c.x, .299), __tsover_mul(c.y, .587)), __tsover_mul(c.z, .114)), a), 0, 1);
-		let score = d.f32(0);
+		const a = max(c.w, 1e-4);
+		const lumaU = clamp(__tsover_div(__tsover_add(__tsover_add(__tsover_mul(c.x, .299), __tsover_mul(c.y, .587)), __tsover_mul(c.z, .114)), a), 0, 1);
+		let score = f32(0);
 		if (mode === "alpha") score = c.w;
-		else if (mode === "dark") score = __tsover_mul(__tsover_sub(1, lumaU), std.select(d.f32(0), d.f32(1), c.w > .5));
-		else if (mode === "red") score = __tsover_mul(__tsover_mul(__tsover_mul(std.clamp(__tsover_div(c.x, a), 0, 1), std.select(d.f32(0), d.f32(1), c.x >= c.y)), std.select(d.f32(0), d.f32(1), c.x >= c.z)), std.select(d.f32(0), d.f32(1), c.w > .02));
-		else if (mode === "green") score = __tsover_mul(__tsover_mul(__tsover_mul(std.clamp(__tsover_div(c.y, a), 0, 1), std.select(d.f32(0), d.f32(1), c.y >= c.x)), std.select(d.f32(0), d.f32(1), c.y >= c.z)), std.select(d.f32(0), d.f32(1), c.w > .02));
-		else if (mode === "blue") score = __tsover_mul(__tsover_mul(__tsover_mul(std.clamp(__tsover_div(c.z, a), 0, 1), std.select(d.f32(0), d.f32(1), c.z >= c.x)), std.select(d.f32(0), d.f32(1), c.z >= c.y)), std.select(d.f32(0), d.f32(1), c.w > .02));
-		else score = __tsover_mul(lumaU, std.select(d.f32(0), d.f32(1), c.w > .02));
+		else if (mode === "dark") score = __tsover_mul(__tsover_sub(1, lumaU), select(f32(0), f32(1), c.w > .5));
+		else if (mode === "red") score = __tsover_mul(__tsover_mul(__tsover_mul(clamp(__tsover_div(c.x, a), 0, 1), select(f32(0), f32(1), c.x >= c.y)), select(f32(0), f32(1), c.x >= c.z)), select(f32(0), f32(1), c.w > .02));
+		else if (mode === "green") score = __tsover_mul(__tsover_mul(__tsover_mul(clamp(__tsover_div(c.y, a), 0, 1), select(f32(0), f32(1), c.y >= c.x)), select(f32(0), f32(1), c.y >= c.z)), select(f32(0), f32(1), c.w > .02));
+		else if (mode === "blue") score = __tsover_mul(__tsover_mul(__tsover_mul(clamp(__tsover_div(c.z, a), 0, 1), select(f32(0), f32(1), c.z >= c.x)), select(f32(0), f32(1), c.z >= c.y)), select(f32(0), f32(1), c.w > .02));
+		else score = __tsover_mul(lumaU, select(f32(0), f32(1), c.w > .02));
 		return score;
 	}), {
 		v: 1,
@@ -832,31 +833,31 @@ function buildScoreFn(mode) {
 			]
 		},
 		externals: () => ({
-			std,
-			d,
+			std: std_exports,
+			d: data_exports,
 			mode
 		})
 	}) && $.f)({})).$name(`keyframesScore_${mode}`);
 }
 function buildFeatureKernel(scoreFn) {
-	return tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
+	return src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((gx, gy) => {
 		"use gpu";
-		const srcDims = std.textureDimensions(featureLayout.$.src);
-		const srcW = d.f32(srcDims.x);
-		const srcH = d.f32(srcDims.y);
-		const g = d.f32(FEAT_GRID);
-		const cu = __tsover_div(__tsover_add(d.f32(gx), .5), g);
-		const cv = __tsover_div(__tsover_add(d.f32(gy), .5), g);
+		const srcDims = textureDimensions(featureLayout.$.src);
+		const srcW = f32(srcDims.x);
+		const srcH = f32(srcDims.y);
+		const g = f32(FEAT_GRID);
+		const cu = __tsover_div(__tsover_add(f32(gx), .5), g);
+		const cv = __tsover_div(__tsover_add(f32(gy), .5), g);
 		const q = __tsover_div(.25, g);
-		let score = d.f32(0);
+		let score = f32(0);
 		for (let sy = 0; sy < 2; sy++) for (let sx = 0; sx < 2; sx++) {
-			const u = __tsover_add(cu, __tsover_mul(__tsover_mul(__tsover_sub(d.f32(sx), .5), 2), q));
-			const v = __tsover_add(cv, __tsover_mul(__tsover_mul(__tsover_sub(d.f32(sy), .5), 2), q));
-			const tx = d.u32(std.clamp(__tsover_mul(u, srcW), d.f32(0), __tsover_sub(srcW, 1)));
-			const ty = d.u32(std.clamp(__tsover_mul(v, srcH), d.f32(0), __tsover_sub(srcH, 1)));
-			score = std.max(score, scoreFn(std.textureLoad(featureLayout.$.src, d.vec2u(tx, ty), 0)));
+			const u = __tsover_add(cu, __tsover_mul(__tsover_mul(__tsover_sub(f32(sx), .5), 2), q));
+			const v = __tsover_add(cv, __tsover_mul(__tsover_mul(__tsover_sub(f32(sy), .5), 2), q));
+			const tx = u32(clamp(__tsover_mul(u, srcW), f32(0), __tsover_sub(srcW, 1)));
+			const ty = u32(clamp(__tsover_mul(v, srcH), f32(0), __tsover_sub(srcH, 1)));
+			score = max(score, scoreFn(textureLoad(featureLayout.$.src, vec2u(tx, ty), 0)));
 		}
-		std.textureStore(featureLayout.$.grid, d.vec2u(gx, gy), d.vec4f(score, 0, 0, 1));
+		textureStore(featureLayout.$.grid, vec2u(gx, gy), vec4f(score, 0, 0, 1));
 	}), {
 		v: 1,
 		name: void 0,
@@ -1296,9 +1297,9 @@ function buildFeatureKernel(scoreFn) {
 			]
 		},
 		externals: () => ({
-			std,
+			std: std_exports,
 			featureLayout,
-			d,
+			d: data_exports,
 			FEAT_GRID,
 			scoreFn
 		})
@@ -1306,12 +1307,12 @@ function buildFeatureKernel(scoreFn) {
 }
 function buildTrackKernel(mode, scoreFn) {
 	const score = scoreFn ?? buildScoreFn(mode);
-	return tgpu.fn([d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ti) => {
+	return src_default.fn([u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((ti) => {
 		"use gpu";
 		const P = trackLayout.$.params;
-		const iF = d.f32(ti);
-		const head = std.textureLoad(trackLayout.$.prev, d.vec2u(d.u32(0), ti), 0);
-		const meta = std.textureLoad(trackLayout.$.prev, d.vec2u(d.u32(1), ti), 0);
+		const iF = f32(ti);
+		const head = textureLoad(trackLayout.$.prev, vec2u(u32(0), ti), 0);
+		const meta = textureLoad(trackLayout.$.prev, vec2u(u32(1), ti), 0);
 		let posX = head.x;
 		let posY = head.y;
 		let frame = head.z;
@@ -1322,33 +1323,33 @@ function buildTrackKernel(mode, scoreFn) {
 		if (head.w < .5) {
 			posX = __tsover_add(.15, __tsover_mul(.7, trackHash(__tsover_add(__tsover_mul(iF, 7.31), 1.3))));
 			posY = __tsover_add(.15, __tsover_mul(.7, trackHash(__tsover_add(__tsover_mul(iF, 11.93), 4.7))));
-			frame = d.f32(0);
-			genStart = d.f32(0);
-			missStreak = d.f32(0);
-			gen = d.f32(1);
+			frame = f32(0);
+			genStart = f32(0);
+			missStreak = f32(0);
+			gen = f32(1);
 		}
 		frame = __tsover_add(frame, 1);
-		const minFeat = std.max(P.threshold, .02);
-		const Lpref = std.max(__tsover_sub(1, __tsover_mul(P.variance, trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 6.13), __tsover_mul(gen, .37)), 2.9)))), minFeat);
-		const srcDims = std.textureDimensions(trackLayout.$.src);
-		const srcW = d.f32(srcDims.x);
-		const srcH = d.f32(srcDims.y);
+		const minFeat = max(P.threshold, .02);
+		const Lpref = max(__tsover_sub(1, __tsover_mul(P.variance, trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 6.13), __tsover_mul(gen, .37)), 2.9)))), minFeat);
+		const srcDims = textureDimensions(trackLayout.$.src);
+		const srcW = f32(srcDims.x);
+		const srcH = f32(srcDims.y);
 		const radius = __tsover_add(.035, __tsover_mul(.11, P.agility));
-		let sumW = d.f32(0);
-		let sumX = d.f32(0);
-		let sumY = d.f32(0);
+		let sumW = f32(0);
+		let sumX = f32(0);
+		let sumY = f32(0);
 		for (let dy = -3; dy <= 3; dy++) for (let dx = -3; dx <= 3; dx++) {
-			const ox = __tsover_mul(__tsover_div(d.f32(dx), 3), radius);
-			const oy = __tsover_mul(__tsover_div(d.f32(dy), 3), radius);
-			const cx01 = std.clamp(__tsover_add(posX, ox), .02, .98);
-			const cy01 = std.clamp(__tsover_add(posY, oy), .02, .98);
-			const tx = d.u32(std.clamp(__tsover_mul(cx01, srcW), d.f32(0), __tsover_sub(srcW, 1)));
-			const ty = d.u32(std.clamp(__tsover_mul(cy01, srcH), d.f32(0), __tsover_sub(srcH, 1)));
-			const s = score(std.textureLoad(trackLayout.$.src, d.vec2u(tx, ty), 0));
-			const gate = std.select(d.f32(0), d.f32(1), s > minFeat);
+			const ox = __tsover_mul(__tsover_div(f32(dx), 3), radius);
+			const oy = __tsover_mul(__tsover_div(f32(dy), 3), radius);
+			const cx01 = clamp(__tsover_add(posX, ox), .02, .98);
+			const cy01 = clamp(__tsover_add(posY, oy), .02, .98);
+			const tx = u32(clamp(__tsover_mul(cx01, srcW), f32(0), __tsover_sub(srcW, 1)));
+			const ty = u32(clamp(__tsover_mul(cy01, srcH), f32(0), __tsover_sub(srcH, 1)));
+			const s = score(textureLoad(trackLayout.$.src, vec2u(tx, ty), 0));
+			const gate = select(f32(0), f32(1), s > minFeat);
 			const dBand = __tsover_sub(s, Lpref);
-			const aff = __tsover_mul(std.exp(__tsover_mul(__tsover_mul(dBand, dBand), -24)), gate);
-			const off = __tsover_div(std.sqrt(__tsover_add(__tsover_mul(ox, ox), __tsover_mul(oy, oy))), std.max(radius, .001));
+			const aff = __tsover_mul(exp(__tsover_mul(__tsover_mul(dBand, dBand), -24)), gate);
+			const off = __tsover_div(sqrt(__tsover_add(__tsover_mul(ox, ox), __tsover_mul(oy, oy))), max(radius, .001));
 			const w = __tsover_mul(aff, __tsover_sub(1, __tsover_mul(.3, off)));
 			sumW = __tsover_add(sumW, w);
 			sumX = __tsover_add(sumX, __tsover_mul(cx01, w));
@@ -1361,22 +1362,22 @@ function buildTrackKernel(mode, scoreFn) {
 			bestX = __tsover_div(sumX, sumW);
 			bestY = __tsover_div(sumY, sumW);
 		}
-		missStreak = std.select(__tsover_add(missStreak, 1), d.f32(0), locked);
+		missStreak = select(__tsover_add(missStreak, 1), f32(0), locked);
 		if (!locked) {
-			const g = d.f32(FEAT_GRID);
-			let bestW = d.f32(0);
+			const g = f32(FEAT_GRID);
+			let bestW = f32(0);
 			let tgtX = posX;
 			let tgtY = posY;
 			for (let gy = 0; gy < FEAT_GRID; gy++) for (let gx = 0; gx < FEAT_GRID; gx++) {
-				const cs = std.textureLoad(trackLayout.$.featGrid, d.vec2u(d.u32(gx), d.u32(gy)), 0).x;
-				const cGate = std.select(d.f32(0), d.f32(1), cs > minFeat);
+				const cs = textureLoad(trackLayout.$.featGrid, vec2u(u32(gx), u32(gy)), 0).x;
+				const cGate = select(f32(0), f32(1), cs > minFeat);
 				const dB = __tsover_sub(cs, Lpref);
-				const aff = __tsover_mul(std.exp(__tsover_mul(__tsover_mul(dB, dB), -14)), cGate);
-				const cx = __tsover_div(__tsover_add(d.f32(gx), .5), g);
-				const cy = __tsover_div(__tsover_add(d.f32(gy), .5), g);
+				const aff = __tsover_mul(exp(__tsover_mul(__tsover_mul(dB, dB), -14)), cGate);
+				const cx = __tsover_div(__tsover_add(f32(gx), .5), g);
+				const cy = __tsover_div(__tsover_add(f32(gy), .5), g);
 				const ddx = __tsover_sub(cx, posX);
 				const ddy = __tsover_sub(cy, posY);
-				const pref = __tsover_add(.6, __tsover_mul(.8, trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 3.17), __tsover_mul(d.f32(gx), 13.71)), __tsover_mul(d.f32(gy), 29.37)))));
+				const pref = __tsover_add(.6, __tsover_mul(.8, trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 3.17), __tsover_mul(f32(gx), 13.71)), __tsover_mul(f32(gy), 29.37)))));
 				const wgt = __tsover_div(__tsover_mul(aff, pref), __tsover_add(1, __tsover_mul(5, __tsover_add(__tsover_mul(ddx, ddx), __tsover_mul(ddy, ddy)))));
 				if (wgt > bestW) {
 					bestW = wgt;
@@ -1385,82 +1386,82 @@ function buildTrackKernel(mode, scoreFn) {
 				}
 			}
 			if (bestW > .02) {
-				bestX = std.clamp(__tsover_add(tgtX, __tsover_div(__tsover_sub(trackHash(__tsover_add(__tsover_mul(iF, 5.77), __tsover_mul(gen, 2.13))), .5), g)), .02, .98);
-				bestY = std.clamp(__tsover_add(tgtY, __tsover_div(__tsover_sub(trackHash(__tsover_add(__tsover_mul(iF, 8.31), __tsover_mul(gen, 4.97))), .5), g)), .02, .98);
+				bestX = clamp(__tsover_add(tgtX, __tsover_div(__tsover_sub(trackHash(__tsover_add(__tsover_mul(iF, 5.77), __tsover_mul(gen, 2.13))), .5), g)), .02, .98);
+				bestY = clamp(__tsover_add(tgtY, __tsover_div(__tsover_sub(trackHash(__tsover_add(__tsover_mul(iF, 8.31), __tsover_mul(gen, 4.97))), .5), g)), .02, .98);
 			} else {
-				const ang = __tsover_add(__tsover_mul(trackHash(__tsover_add(__tsover_mul(iF, 13.77), __tsover_mul(gen, 3.19))), TWO_PI), __tsover_mul(std.sin(__tsover_add(__tsover_mul(frame, .02), iF)), 1.4));
-				bestX = std.clamp(__tsover_add(posX, __tsover_mul(std.cos(ang), .08)), .03, .97);
-				bestY = std.clamp(__tsover_add(posY, __tsover_mul(std.sin(ang), .08)), .03, .97);
+				const ang = __tsover_add(__tsover_mul(trackHash(__tsover_add(__tsover_mul(iF, 13.77), __tsover_mul(gen, 3.19))), TWO_PI), __tsover_mul(sin(__tsover_add(__tsover_mul(frame, .02), iF)), 1.4));
+				bestX = clamp(__tsover_add(posX, __tsover_mul(cos(ang), .08)), .03, .97);
+				bestY = clamp(__tsover_add(posY, __tsover_mul(sin(ang), .08)), .03, .97);
 			}
 		}
 		const maxStep = __tsover_mul(P.dt, __tsover_add(.15, __tsover_mul(1.4, P.agility)));
 		const dX = __tsover_sub(bestX, posX);
 		const dY = __tsover_sub(bestY, posY);
-		const dist = std.sqrt(__tsover_add(__tsover_mul(dX, dX), __tsover_mul(dY, dY)));
-		const stepK = std.min(d.f32(1), __tsover_div(maxStep, std.max(dist, 1e-5)));
+		const dist = sqrt(__tsover_add(__tsover_mul(dX, dX), __tsover_mul(dY, dY)));
+		const stepK = min(f32(1), __tsover_div(maxStep, max(dist, 1e-5)));
 		posX = __tsover_add(posX, __tsover_mul(dX, stepK));
 		posY = __tsover_add(posY, __tsover_mul(dY, stepK));
-		let crowded = d.f32(0);
-		const iN = d.i32(ti);
+		let crowded = f32(0);
+		const iN = i32(ti);
 		for (let k = 0; k < iN; k++) {
-			const kF = d.f32(k);
-			const other = std.textureLoad(trackLayout.$.prev, d.vec2u(d.u32(0), d.u32(k)), 0);
+			const kF = f32(k);
+			const other = textureLoad(trackLayout.$.prev, vec2u(u32(0), u32(k)), 0);
 			const odx = __tsover_sub(other.x, posX);
 			const ody = __tsover_sub(other.y, posY);
-			const near = std.select(d.f32(0), d.f32(1), std.sqrt(__tsover_add(__tsover_mul(odx, odx), __tsover_mul(ody, ody))) < .022);
-			crowded = std.max(crowded, __tsover_mul(__tsover_mul(near, other.w), std.select(d.f32(0), d.f32(1), kF < P.trackersF)));
+			const near = select(f32(0), f32(1), sqrt(__tsover_add(__tsover_mul(odx, odx), __tsover_mul(ody, ody))) < .022);
+			crowded = max(crowded, __tsover_mul(__tsover_mul(near, other.w), select(f32(0), f32(1), kF < P.trackersF)));
 		}
-		crowdStreak = std.select(d.f32(0), __tsover_add(crowdStreak, 1), crowded > .5);
+		crowdStreak = select(f32(0), __tsover_add(crowdStreak, 1), crowded > .5);
 		if (crowdStreak > 30) {
 			const hopAng = __tsover_mul(trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 9.13), __tsover_mul(gen, 5.77)), 2.3)), TWO_PI);
 			const hopDist = __tsover_add(.05, __tsover_mul(.08, trackHash(__tsover_add(__tsover_mul(iF, 4.71), __tsover_mul(gen, 8.11)))));
-			posX = std.clamp(__tsover_add(posX, __tsover_mul(std.cos(hopAng), hopDist)), .03, .97);
-			posY = std.clamp(__tsover_add(posY, __tsover_mul(std.sin(hopAng), hopDist)), .03, .97);
+			posX = clamp(__tsover_add(posX, __tsover_mul(cos(hopAng), hopDist)), .03, .97);
+			posY = clamp(__tsover_add(posY, __tsover_mul(sin(hopAng), hopDist)), .03, .97);
 			gen = __tsover_add(gen, 1);
 			genStart = frame;
-			missStreak = d.f32(0);
-			crowdStreak = d.f32(0);
+			missStreak = f32(0);
+			crowdStreak = f32(0);
 		}
 		const lifeFrames = __tsover_mul(__tsover_mul(P.lifespan, 60), __tsover_add(.7, __tsover_mul(.6, trackHash(__tsover_add(__tsover_mul(iF, 4.77), __tsover_mul(gen, 1.31))))));
-		const expired = __tsover_mul(std.select(d.f32(0), d.f32(1), __tsover_sub(frame, genStart) > lifeFrames), std.select(d.f32(0), d.f32(1), P.lifespan > .01));
-		const lost = std.select(d.f32(0), d.f32(1), missStreak > 90);
+		const expired = __tsover_mul(select(f32(0), f32(1), __tsover_sub(frame, genStart) > lifeFrames), select(f32(0), f32(1), P.lifespan > .01));
+		const lost = select(f32(0), f32(1), missStreak > 90);
 		if (__tsover_add(expired, lost) > .5) {
 			posX = __tsover_add(.1, __tsover_mul(.8, trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 7.31), __tsover_mul(gen, 13.7)), __tsover_mul(frame, .013)))));
 			posY = __tsover_add(.1, __tsover_mul(.8, trackHash(__tsover_add(__tsover_add(__tsover_mul(iF, 11.93), __tsover_mul(gen, 17.3)), __tsover_mul(frame, .019)))));
 			gen = __tsover_add(gen, 1);
 			genStart = frame;
-			missStreak = d.f32(0);
-			crowdStreak = d.f32(0);
+			missStreak = f32(0);
+			crowdStreak = f32(0);
 		}
-		const writeIdx = __tsover_mod(std.floor(__tsover_div(frame, d.f32(TRAIL_EVERY))), d.f32(TRAIL_LEN));
-		const shouldWrite = std.select(d.f32(0), d.f32(1), __tsover_mod(frame, d.f32(TRAIL_EVERY)) < .5);
+		const writeIdx = __tsover_mod(floor(__tsover_div(frame, f32(TRAIL_EVERY))), f32(TRAIL_LEN));
+		const shouldWrite = select(f32(0), f32(1), __tsover_mod(frame, f32(TRAIL_EVERY)) < .5);
 		let bbMinX = posX;
 		let bbMinY = posY;
 		let bbMaxX = posX;
 		let bbMaxY = posY;
 		for (let j = 0; j < TRAIL_LEN; j++) {
-			const jF = d.f32(j);
-			let e = std.textureLoad(trackLayout.$.prev, d.vec2u(d.u32(__tsover_add(2, j)), ti), 0);
-			const isSlot = std.select(d.f32(0), d.f32(1), std.abs(__tsover_sub(jF, writeIdx)) < .5);
+			const jF = f32(j);
+			let e = textureLoad(trackLayout.$.prev, vec2u(u32(__tsover_add(2, j)), ti), 0);
+			const isSlot = select(f32(0), f32(1), abs(__tsover_sub(jF, writeIdx)) < .5);
 			const doWrite = __tsover_mul(isSlot, shouldWrite);
-			e = std.mix(e, d.vec4f(posX, posY, frame, gen), doWrite);
-			std.textureStore(trackLayout.$.next, d.vec2u(d.u32(__tsover_add(2, j)), ti), e);
-			std.textureStore(trackLayout.$.present, d.vec2u(d.u32(__tsover_add(2, j)), ti), e);
-			const live = __tsover_mul(std.select(d.f32(0), d.f32(1), std.abs(__tsover_sub(e.w, gen)) < .5), std.select(d.f32(0), d.f32(1), e.z > .5));
-			bbMinX = std.min(bbMinX, std.mix(posX, e.x, live));
-			bbMinY = std.min(bbMinY, std.mix(posY, e.y, live));
-			bbMaxX = std.max(bbMaxX, std.mix(posX, e.x, live));
-			bbMaxY = std.max(bbMaxY, std.mix(posY, e.y, live));
+			e = mix(e, vec4f(posX, posY, frame, gen), doWrite);
+			textureStore(trackLayout.$.next, vec2u(u32(__tsover_add(2, j)), ti), e);
+			textureStore(trackLayout.$.present, vec2u(u32(__tsover_add(2, j)), ti), e);
+			const live = __tsover_mul(select(f32(0), f32(1), abs(__tsover_sub(e.w, gen)) < .5), select(f32(0), f32(1), e.z > .5));
+			bbMinX = min(bbMinX, mix(posX, e.x, live));
+			bbMinY = min(bbMinY, mix(posY, e.y, live));
+			bbMaxX = max(bbMaxX, mix(posX, e.x, live));
+			bbMaxY = max(bbMaxY, mix(posY, e.y, live));
 		}
-		const bbOut = d.vec4f(bbMinX, bbMinY, bbMaxX, bbMaxY);
-		std.textureStore(trackLayout.$.next, d.vec2u(d.u32(AABB_COL), ti), bbOut);
-		std.textureStore(trackLayout.$.present, d.vec2u(d.u32(AABB_COL), ti), bbOut);
-		const headOut = d.vec4f(posX, posY, frame, __tsover_add(genStart, 1));
-		const metaOut = d.vec4f(missStreak, sumW, gen, crowdStreak);
-		std.textureStore(trackLayout.$.next, d.vec2u(d.u32(0), ti), headOut);
-		std.textureStore(trackLayout.$.present, d.vec2u(d.u32(0), ti), headOut);
-		std.textureStore(trackLayout.$.next, d.vec2u(d.u32(1), ti), metaOut);
-		std.textureStore(trackLayout.$.present, d.vec2u(d.u32(1), ti), metaOut);
+		const bbOut = vec4f(bbMinX, bbMinY, bbMaxX, bbMaxY);
+		textureStore(trackLayout.$.next, vec2u(u32(AABB_COL), ti), bbOut);
+		textureStore(trackLayout.$.present, vec2u(u32(AABB_COL), ti), bbOut);
+		const headOut = vec4f(posX, posY, frame, __tsover_add(genStart, 1));
+		const metaOut = vec4f(missStreak, sumW, gen, crowdStreak);
+		textureStore(trackLayout.$.next, vec2u(u32(0), ti), headOut);
+		textureStore(trackLayout.$.present, vec2u(u32(0), ti), headOut);
+		textureStore(trackLayout.$.next, vec2u(u32(1), ti), metaOut);
+		textureStore(trackLayout.$.present, vec2u(u32(1), ti), metaOut);
 	}), {
 		v: 1,
 		name: void 0,
@@ -4986,8 +4987,8 @@ function buildTrackKernel(mode, scoreFn) {
 		},
 		externals: () => ({
 			trackLayout,
-			d,
-			std,
+			d: data_exports,
+			std: std_exports,
 			trackHash,
 			score,
 			FEAT_GRID,