shaders 3.0.447 → 3.0.449

package/dist/core/{BrushedMetal-B10fDdGt.js → BrushedMetal-B06tUygH.js}

@@ -1,8 +1,10 @@
-import { F as sdf_exports, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, n as tgpu, pt as noise_exports, ut as mxNoiseFloat2, y as sdf3d_exports } from "./coords-BkIjixe_.js";
-import { n as glass_exports } from "./glass-sOqjtPJD.js";
-import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { $t as vec2f, At as pow, Et as max, It as sin, Lt as smoothstep, Mt as reflect, Ot as mix, Tt as length, Ut as arrayOf, Vt as data_exports, _ as floatE, _t as clamp, an as f32, bt as dot, et as src_default, in as vec4f, kt as normalize, mt as abs, nn as vec3f, nt as std_exports, p as call, pt as select, vt as cos, xt as exp, y as vec4 } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { p as noise_exports, u as mxNoiseFloat2 } from "./noise-wTSHXgFz.js";
+import { h as sdf_exports } from "./sdf-R0EN3EvS.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-CtKwBX8c.js";
+import { n as glass_exports } from "./glass-IfoQ8Prf.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV, offsetUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType } = sdf3d_exports;
@@ -28,32 +30,32 @@ var BLUR_W = (() => {
 	const sum = raw.reduce((a, b) => a + b, 0);
 	return raw.map((w) => w / sum);
 })();
-var BRUSH_BLUR_W = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.const(d.arrayOf(d.f32, 9), BLUR_W), "BRUSH_BLUR_W");
-const brushedStudio = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rx, ry, envC, envS, keyRad, drift, envStr) => {
+var BRUSH_BLUR_W = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.const(arrayOf(f32, 9), BLUR_W), "BRUSH_BLUR_W");
+const brushedStudio = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rx, ry, envC, envS, keyRad, drift, envStr) => {
 	"use gpu";
 	const ex = __tsover_sub(__tsover_mul(rx, envC), __tsover_mul(ry, envS));
 	const ey = __tsover_add(__tsover_mul(rx, envS), __tsover_mul(ry, envC));
-	const p = d.vec2f(ex, ey);
-	const sky = std.smoothstep(-.7, .85, ey);
+	const p = vec2f(ex, ey);
+	const sky = smoothstep(-.7, .85, ey);
 	let lum = __tsover_mul(__tsover_mul(sky, sky), .38);
 	const r0 = __tsover_mul(keyRad, 1);
-	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(std.smoothstep(r0, __tsover_mul(r0, .2), std.length(p.sub(d.vec2f(__tsover_add(0, drift), .55)))), 1.7), envStr));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep(r0, __tsover_mul(r0, .2), length(p.sub(vec2f(__tsover_add(0, drift), .55)))), 1.7), envStr));
 	const r1 = __tsover_mul(keyRad, 1.15);
-	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(std.smoothstep(r1, __tsover_mul(r1, .2), std.length(p.sub(d.vec2f(__tsover_add(-.55, drift), .18)))), 1.05), envStr));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep(r1, __tsover_mul(r1, .2), length(p.sub(vec2f(__tsover_add(-.55, drift), .18)))), 1.05), envStr));
 	const r2 = __tsover_mul(keyRad, 1);
-	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(std.smoothstep(r2, __tsover_mul(r2, .2), std.length(p.sub(d.vec2f(__tsover_add(.55, drift), .1)))), 1), envStr));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep(r2, __tsover_mul(r2, .2), length(p.sub(vec2f(__tsover_add(.55, drift), .1)))), 1), envStr));
 	const r3 = __tsover_mul(keyRad, 1.3);
-	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(std.smoothstep(r3, __tsover_mul(r3, .2), std.length(p.sub(d.vec2f(__tsover_add(.2, drift), -.5)))), .7), envStr));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep(r3, __tsover_mul(r3, .2), length(p.sub(vec2f(__tsover_add(.2, drift), -.5)))), .7), envStr));
 	const r4 = __tsover_mul(keyRad, 1.1);
-	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(std.smoothstep(r4, __tsover_mul(r4, .2), std.length(p.sub(d.vec2f(__tsover_add(-.35, drift), -.25)))), .85), envStr));
+	lum = __tsover_add(lum, __tsover_mul(__tsover_mul(smoothstep(r4, __tsover_mul(r4, .2), length(p.sub(vec2f(__tsover_add(-.35, drift), -.25)))), .85), envStr));
 	return lum;
 }), {
 	v: 1,
@@ -585,23 +587,23 @@ const brushedStudio = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
-const brushedMetalComposite = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.vec2f,
-	d.vec2f,
-	d.vec3f,
-	d.vec3f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, uv, viewportSize, lightColor, darkColor, p0, p1, p2) => {
+const brushedMetalComposite = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	vec2f,
+	vec2f,
+	vec3f,
+	vec3f,
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, uv, viewportSize, lightColor, darkColor, p0, p1, p2) => {
 	"use gpu";
 	const scl = p0.x;
 	const edgeSoftness = p0.y;
@@ -616,77 +618,72 @@ const brushedMetalComposite = tgpu.fn([
 	const animTime = p2.z;
 	const volumetric = p2.w;
 	const aspect = __tsover_div(viewportSize.x, viewportSize.y);
-	const sharpEdge = std.max(__tsover_mul(edgeSoftness, .5), .001);
+	const sharpEdge = max(__tsover_mul(edgeSoftness, .5), .001);
 	const pxH = __tsover_div(1, viewportSize.y);
 	const sdfRaw = surf0.x;
 	const sdf = __tsover_div(sdfRaw, scl);
-	if (sdf > __tsover_mul(pxH, 2)) return d.vec4f(0, 0, 0, 0);
-	const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
-	const btx = std.cos(__tsover_mul(brushAngle, DEG_TO_RAD));
-	const bty = std.sin(__tsover_mul(brushAngle, DEG_TO_RAD));
-	const envC = std.cos(__tsover_mul(envRotation, DEG_TO_RAD));
-	const envS = std.sin(__tsover_mul(envRotation, DEG_TO_RAD));
+	if (sdf > __tsover_mul(pxH, 2)) return vec4f(0, 0, 0, 0);
+	const lx = cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const ly = sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+	const btx = cos(__tsover_mul(brushAngle, DEG_TO_RAD));
+	const bty = sin(__tsover_mul(brushAngle, DEG_TO_RAD));
+	const envC = cos(__tsover_mul(envRotation, DEG_TO_RAD));
+	const envS = sin(__tsover_mul(envRotation, DEG_TO_RAD));
 	const EPS = .01;
 	const gradX = __tsover_div(__tsover_sub(surfX.x, sdfRaw), EPS);
 	const gradY = __tsover_div(__tsover_sub(surfY.x, sdfRaw), EPS);
-	const ddx = std.clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -5, 5);
-	const ddy = std.clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -5, 5);
-	const nVol = std.normalize(d.vec3f(ddx, ddy, -1));
-	const rimT = std.clamp(__tsover_div(__tsover_mul(sdf, -1), .05), 0, 1);
+	const nVol = normalize(vec3f(clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -5, 5), clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -5, 5), -1));
+	const rimT = clamp(__tsover_div(__tsover_mul(sdf, -1), .05), 0, 1);
 	const rimBevel = __tsover_mul(__tsover_sub(1, rimT), 1.6);
-	const nFlat = std.normalize(d.vec3f(__tsover_mul(gradX, rimBevel), __tsover_mul(gradY, rimBevel), -1));
-	const nGeo = std.select(nFlat, nVol, volumetric > .5);
-	const pdx = std.select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
-	const pdy = std.select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
+	const nGeo = select(normalize(vec3f(__tsover_mul(gradX, rimBevel), __tsover_mul(gradY, rimBevel), -1)), nVol, volumetric > .5);
+	const pdx = select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
+	const pdy = select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
 	const bix = __tsover_mul(bty, -1);
 	const biy = btx;
 	const along = __tsover_add(__tsover_mul(pdx, btx), __tsover_mul(pdy, bty));
 	const across = __tsover_add(__tsover_mul(pdx, bix), __tsover_mul(pdy, biy));
 	const dens = __tsover_mul(grainScale, 150);
-	const driftA = __tsover_mul(std.sin(__tsover_mul(animTime, .05)), .35);
+	const driftA = __tsover_mul(sin(__tsover_mul(animTime, .05)), .35);
 	const aniso = anisotropy;
-	const sheen0 = mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(along, 1.3), driftA), __tsover_mul(across, 6.5)));
-	const line0 = __tsover_add(mxNoiseFloat2(d.vec2f(__tsover_mul(along, 4.5), __tsover_mul(across, dens))), __tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(along, 8), 3.1), __tsover_add(__tsover_mul(__tsover_mul(across, dens), 2.3), 7.7))), .5));
+	const sheen0 = mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(along, 1.3), driftA), __tsover_mul(across, 6.5)));
+	const line0 = __tsover_add(mxNoiseFloat2(vec2f(__tsover_mul(along, 4.5), __tsover_mul(across, dens))), __tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(along, 8), 3.1), __tsover_add(__tsover_mul(__tsover_mul(across, dens), 2.3), 7.7))), .5));
 	const sheenAmt = __tsover_add(__tsover_mul(aniso, .5), .08);
 	const lineAmt = __tsover_mul(grain, .16);
 	const pAcross = __tsover_add(__tsover_mul(sheen0, sheenAmt), __tsover_mul(line0, lineAmt));
-	const pAlong = __tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_add(__tsover_mul(__tsover_add(along, 11.7), 1.3), driftA), __tsover_mul(across, 6.5))), __tsover_mul(sheenAmt, .12));
-	const n = std.normalize(d.vec3f(__tsover_add(__tsover_add(nGeo.x, __tsover_mul(bix, pAcross)), __tsover_mul(btx, pAlong)), __tsover_add(__tsover_add(nGeo.y, __tsover_mul(biy, pAcross)), __tsover_mul(bty, pAlong)), nGeo.z));
+	const pAlong = __tsover_mul(mxNoiseFloat2(vec2f(__tsover_add(__tsover_mul(__tsover_add(along, 11.7), 1.3), driftA), __tsover_mul(across, 6.5))), __tsover_mul(sheenAmt, .12));
+	const n = normalize(vec3f(__tsover_add(__tsover_add(nGeo.x, __tsover_mul(bix, pAcross)), __tsover_mul(btx, pAlong)), __tsover_add(__tsover_add(nGeo.y, __tsover_mul(biy, pAcross)), __tsover_mul(bty, pAlong)), nGeo.z));
 	const fov = .6;
-	const viewI = std.normalize(d.vec3f(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), aspect), fov), __tsover_mul(__tsover_sub(uv.y, .5), fov), 1));
-	const cosView = std.clamp(__tsover_mul(std.dot(n, viewI), -1), 0, 1);
+	const viewI = normalize(vec3f(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), aspect), fov), __tsover_mul(__tsover_sub(uv.y, .5), fov), 1));
+	const cosView = clamp(__tsover_mul(dot(n, viewI), -1), 0, 1);
 	const grazing = __tsover_sub(1, cosView);
-	const R = std.reflect(viewI, n);
+	const R = reflect(viewI, n);
 	const envStr = environment;
-	const rough = std.clamp(roughness, 0, 1);
-	const keyRad = std.mix(.42, .16, __tsover_sub(1, rough));
-	const drift = __tsover_mul(std.sin(__tsover_mul(animTime, .07)), .05);
+	const rough = clamp(roughness, 0, 1);
+	const keyRad = mix(.42, .16, __tsover_sub(1, rough));
+	const drift = __tsover_mul(sin(__tsover_mul(animTime, .07)), .05);
 	const smear = __tsover_mul(__tsover_mul(aniso, __tsover_add(__tsover_mul(rough, .6), .25)), .42);
 	const step = __tsover_div(smear, 4);
-	let envLum = d.f32(0);
+	let envLum = f32(0);
 	for (let i = 0; i < 9; i++) {
-		const off = __tsover_mul(step, __tsover_sub(d.f32(i), 4));
+		const off = __tsover_mul(step, __tsover_sub(f32(i), 4));
 		envLum = __tsover_add(envLum, __tsover_mul(brushedStudio(__tsover_add(R.x, __tsover_mul(btx, off)), __tsover_add(R.y, __tsover_mul(bty, off)), envC, envS, keyRad, drift, envStr), BRUSH_BLUR_W.$[i]));
 	}
-	const t0 = d.vec3f(btx, bty, 0);
-	const T3 = std.normalize(t0.sub(n.mul(std.dot(n, t0))));
-	const B3 = d.vec3f(__tsover_sub(__tsover_mul(n.y, T3.z), __tsover_mul(n.z, T3.y)), __tsover_sub(__tsover_mul(n.z, T3.x), __tsover_mul(n.x, T3.z)), __tsover_sub(__tsover_mul(n.x, T3.y), __tsover_mul(n.y, T3.x)));
-	const L = std.normalize(d.vec3f(lx, ly, -.7));
-	const H = std.normalize(L.sub(viewI));
-	const hT = std.dot(H, T3);
-	const hB = std.dot(H, B3);
-	const hN = std.clamp(std.abs(std.dot(H, n)), 1e-4, 1);
-	const baseA = std.mix(.05, .45, rough);
+	const t0 = vec3f(btx, bty, 0);
+	const T3 = normalize(t0.sub(n.mul(dot(n, t0))));
+	const B3 = vec3f(__tsover_sub(__tsover_mul(n.y, T3.z), __tsover_mul(n.z, T3.y)), __tsover_sub(__tsover_mul(n.z, T3.x), __tsover_mul(n.x, T3.z)), __tsover_sub(__tsover_mul(n.x, T3.y), __tsover_mul(n.y, T3.x)));
+	const H = normalize(normalize(vec3f(lx, ly, -.7)).sub(viewI));
+	const hT = dot(H, T3);
+	const hB = dot(H, B3);
+	const hN = clamp(abs(dot(H, n)), 1e-4, 1);
+	const baseA = mix(.05, .45, rough);
 	const aAlong = __tsover_mul(baseA, __tsover_add(1, __tsover_mul(aniso, 7)));
-	const aAcross = std.max(__tsover_mul(baseA, __tsover_sub(1, __tsover_mul(aniso, .55))), .02);
+	const aAcross = max(__tsover_mul(baseA, __tsover_sub(1, __tsover_mul(aniso, .55))), .02);
 	const expo = __tsover_div(__tsover_add(__tsover_mul(__tsover_div(hT, aAlong), __tsover_div(hT, aAlong)), __tsover_mul(__tsover_div(hB, aAcross), __tsover_div(hB, aAcross))), __tsover_mul(__tsover_add(hN, 1), .5));
-	const spec = __tsover_mul(std.exp(__tsover_mul(expo, -1)), std.mix(.45, 1.1, __tsover_sub(1, rough)));
-	const fres = __tsover_add(1, __tsover_mul(std.pow(grazing, d.f32(3)), .6));
-	const lit = std.clamp(__tsover_mul(__tsover_add(envLum, spec), fres), 0, 1.7);
-	const rgb = std.mix(darkColor, lightColor, d.vec3f(lit));
-	const transition = std.smoothstep(0, 1, std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharpEdge), 32), 0, 1));
-	return d.vec4f(rgb.x, rgb.y, rgb.z, transition);
+	const spec = __tsover_mul(exp(__tsover_mul(expo, -1)), mix(.45, 1.1, __tsover_sub(1, rough)));
+	const fres = __tsover_add(1, __tsover_mul(pow(grazing, f32(3)), .6));
+	const rgb = mix(darkColor, lightColor, vec3f(clamp(__tsover_mul(__tsover_add(envLum, spec), fres), 0, 1.7)));
+	const transition = smoothstep(0, 1, clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharpEdge), 32), 0, 1));
+	return vec4f(rgb.x, rgb.y, rgb.z, transition);
 }), {
 	v: 1,
 	name: void 0,
@@ -2711,8 +2708,8 @@ const brushedMetalComposite = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		DEG_TO_RAD,
 		noise: noise_exports,
 		brushedStudio,

package/dist/core/{Bulge-C1Pq4DHk.js → Bulge-BpSOQfH0.js}

@@ -1,31 +1,31 @@
-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";
-const bulgeUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, strength, radius, falloff, uv, aspect) => {
+import { $t as vec2f, Et as max, Lt as smoothstep, N as unpremultiplyAlpha, Tt as length, Vt as data_exports, an as f32, c as sampleRemappedExpr, d as ZERO, et as src_default, n as composeEdgeRemapExpr, nt as std_exports, p as call } from "./edges-BXNBKxSN.js";
+import { c as transformPosition, s as transformEdges } from "./transformations-CsPUHppB.js";
+const bulgeUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, strength, radius, falloff, 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 distance = std.length(delta);
+	const distance = length(delta);
 	const effectRadius = __tsover_mul(radius, .5);
-	const innerRadius = __tsover_mul(effectRadius, std.max(__tsover_sub(__tsover_sub(1, falloff), .001), 0));
-	const smoothFalloff = __tsover_sub(1, std.smoothstep(innerRadius, effectRadius, distance));
+	const innerRadius = __tsover_mul(effectRadius, max(__tsover_sub(__tsover_sub(1, falloff), .001), 0));
+	const smoothFalloff = __tsover_sub(1, smoothstep(innerRadius, effectRadius, distance));
 	const normalizedDist = __tsover_div(distance, effectRadius);
 	const distSq = __tsover_mul(normalizedDist, normalizedDist);
-	const quadraticFalloff = std.max(0, __tsover_sub(1, distSq));
+	const quadraticFalloff = max(0, __tsover_sub(1, distSq));
 	const falloffTotal = __tsover_mul(smoothFalloff, quadraticFalloff);
 	const negStrength = __tsover_mul(strength, -1);
 	const displacementAmount = __tsover_mul(negStrength, falloffTotal);
 	const scaleFactor = __tsover_add(1, displacementAmount);
 	const bulgedDelta = delta.mul(scaleFactor);
 	const bulgedUV = centerPos.add(bulgedDelta);
-	return d.vec2f(__tsover_div(bulgedUV.x, aspect), bulgedUV.y);
+	return vec2f(__tsover_div(bulgedUV.x, aspect), bulgedUV.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -334,8 +334,8 @@ const bulgeUV = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{CRTScreen-Ctx0Mxtb.js → CRTScreen-DdGcEvk2.js}

@@ -1,12 +1,12 @@
-import { Bt as ZERO, Ht as call, J as std, Kt as floatE, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-const crtSampleUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, colorShift, dir) => {
+import { $t as vec2f, It as sin, Lt as smoothstep, N as unpremultiplyAlpha, Ot as mix, Tt as length, Vt as data_exports, _ as floatE, an as f32, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call, wt as fract } from "./edges-BXNBKxSN.js";
+const crtSampleUV = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, colorShift, dir) => {
 	"use gpu";
 	const scaledColorShift = __tsover_mul(colorShift, .002);
-	return d.vec2f(__tsover_add(uv.x, __tsover_mul(scaledColorShift, dir)), uv.y);
+	return vec2f(__tsover_add(uv.x, __tsover_mul(scaledColorShift, dir)), uv.y);
 }), {
 	v: 1,
 	name: void 0,
@@ -63,43 +63,41 @@ const crtSampleUV = tgpu.fn([
 		]]]],
 		"externalNames": ["d"]
 	},
-	externals: () => ({ d })
+	externals: () => ({ d: data_exports })
 }) && $.f)({}));
-const crtCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((redSample, greenSample, blueSample, uv, aspect, pixelSize, scanlineIntensity, scanlineFrequency, brightness, contrast, vignetteIntensity, vignetteRadius) => {
+const crtCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((redSample, greenSample, blueSample, uv, aspect, pixelSize, scanlineIntensity, scanlineFrequency, brightness, contrast, vignetteIntensity, vignetteRadius) => {
 	"use gpu";
-	const adjustedColor = d.vec3f(redSample.x, greenSample.y, blueSample.z).sub(d.vec3f(.5)).mul(contrast).add(d.vec3f(.5)).mul(brightness);
+	const adjustedColor = vec3f(redSample.x, greenSample.y, blueSample.z).sub(vec3f(.5)).mul(contrast).add(vec3f(.5)).mul(brightness);
 	const scanlinePosition = __tsover_mul(uv.y, scanlineFrequency);
-	const scanlineWave = std.sin(__tsover_mul(scanlinePosition, __tsover_mul(3.14159, 2)));
+	const scanlineWave = sin(__tsover_mul(scanlinePosition, __tsover_mul(3.14159, 2)));
 	const scanlineEffect = __tsover_sub(1, __tsover_mul(scanlineIntensity, __tsover_add(__tsover_mul(scanlineWave, .5), .5)));
 	const scanlinedColor = adjustedColor.mul(scanlineEffect);
 	const phosphorScale = __tsover_mul(pixelSize, .5);
-	const pixelPhase = std.fract(uv.mul(phosphorScale));
-	const redMask = __tsover_add(__tsover_mul(std.sin(__tsover_mul(pixelPhase.x, 6.28318)), .1), .95);
-	const greenMask = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(pixelPhase.x, 6.28318), 2.09)), .1), .95);
-	const blueMask = __tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(pixelPhase.x, 6.28318), 4.18)), .1), .95);
-	const phosphorColor = d.vec3f(__tsover_mul(scanlinedColor.x, redMask), __tsover_mul(scanlinedColor.y, greenMask), __tsover_mul(scanlinedColor.z, blueMask));
-	const centeredUV = uv.sub(d.vec2f(.5, .5));
-	const aspectCorrectedUV = d.vec2f(__tsover_mul(centeredUV.x, aspect), centeredUV.y);
-	const vignetteDistance = std.length(aspectCorrectedUV);
+	const pixelPhase = fract(uv.mul(phosphorScale));
+	const redMask = __tsover_add(__tsover_mul(sin(__tsover_mul(pixelPhase.x, 6.28318)), .1), .95);
+	const greenMask = __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(pixelPhase.x, 6.28318), 2.09)), .1), .95);
+	const blueMask = __tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(pixelPhase.x, 6.28318), 4.18)), .1), .95);
+	const phosphorColor = vec3f(__tsover_mul(scanlinedColor.x, redMask), __tsover_mul(scanlinedColor.y, greenMask), __tsover_mul(scanlinedColor.z, blueMask));
+	const centeredUV = uv.sub(vec2f(.5, .5));
+	const vignetteDistance = length(vec2f(__tsover_mul(centeredUV.x, aspect), centeredUV.y));
 	const innerEdge = __tsover_sub(1, __tsover_mul(vignetteRadius, .9));
 	const outerEdge = __tsover_add(innerEdge, .5);
-	const vignetteValue = __tsover_sub(1, std.smoothstep(innerEdge, outerEdge, vignetteDistance));
-	const vignette = std.mix(1, vignetteValue, vignetteIntensity);
+	const vignette = mix(1, __tsover_sub(1, smoothstep(innerEdge, outerEdge, vignetteDistance)), vignetteIntensity);
 	const finalColor = phosphorColor.mul(vignette);
-	return d.vec4f(finalColor.x, finalColor.y, finalColor.z, 1);
+	return vec4f(finalColor.x, finalColor.y, finalColor.z, 1);
 }), {
 	v: 1,
 	name: void 0,
@@ -660,8 +658,8 @@ const crtCompose = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{CarbonFiber-DSSARe6R.js → CarbonFiber-Dy7Osb3V.js}

@@ -1,7 +1,9 @@
-import { F as sdf_exports, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, n as tgpu, pt as noise_exports, ut as mxNoiseFloat2, y as sdf3d_exports } from "./coords-BkIjixe_.js";
-import { n as glass_exports } from "./glass-sOqjtPJD.js";
-import { a as transformColor, c as transformPosition } from "./transformations-t0d2-uSX.js";
-import { n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-PQqKLQXO.js";
+import { $t as vec2f, At as pow, Ct as floor, Dt as min, Et as max, It as sin, Lt as smoothstep, Mt as reflect, Ot as mix, Tt as length, Vt as data_exports, _ as floatE, _t as clamp, an as f32, bt as dot, et as src_default, in as vec4f, kt as normalize, mt as abs, nn as vec3f, nt as std_exports, p as call, pt as select, vt as cos, wt as fract, xt as exp, y as vec4 } from "./edges-BXNBKxSN.js";
+import { p as noise_exports, u as mxNoiseFloat2 } from "./noise-wTSHXgFz.js";
+import { h as sdf_exports } from "./sdf-R0EN3EvS.js";
+import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-CtKwBX8c.js";
+import { n as glass_exports } from "./glass-IfoQ8Prf.js";
+import { a as transformColor, c as transformPosition } from "./transformations-CsPUHppB.js";
 var { sdfSpaceUV, offsetUV } = glass_exports;
 var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
 var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType } = sdf3d_exports;
@@ -13,19 +15,19 @@ var DEFAULT_SHAPE_CONFIG = JSON.stringify({
 	radius: .35
 });
 function buildCarbonFiberComposite(weaveStyle) {
-	return tgpu.fn([
-		d.vec4f,
-		d.vec4f,
-		d.vec4f,
-		d.vec2f,
-		d.vec2f,
-		d.vec2f,
-		d.vec3f,
-		d.vec3f,
-		d.vec4f,
-		d.vec4f,
-		d.vec4f
-	], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, uv, viewportSize, lightColor, darkColor, p0, p1, p2) => {
+	return src_default.fn([
+		vec4f,
+		vec4f,
+		vec4f,
+		vec2f,
+		vec2f,
+		vec2f,
+		vec3f,
+		vec3f,
+		vec4f,
+		vec4f,
+		vec4f
+	], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((surf0, surfX, surfY, sdfUV, uv, viewportSize, lightColor, darkColor, p0, p1, p2) => {
 		"use gpu";
 		const scl = p0.x;
 		const edgeSoftness = p0.y;
@@ -40,29 +42,26 @@ function buildCarbonFiberComposite(weaveStyle) {
 		const lightAngle = p2.z;
 		const volumetric = p2.w;
 		const aspect = __tsover_div(viewportSize.x, viewportSize.y);
-		const sharpEdge = std.max(__tsover_mul(edgeSoftness, .5), .001);
+		const sharpEdge = max(__tsover_mul(edgeSoftness, .5), .001);
 		const pxH = __tsover_div(1, viewportSize.y);
 		const sdfRaw = surf0.x;
 		const sdf = __tsover_div(sdfRaw, scl);
-		if (sdf > __tsover_mul(pxH, 2)) return d.vec4f(0, 0, 0, 0);
-		const lx = std.cos(__tsover_mul(lightAngle, DEG_TO_RAD));
-		const ly = std.sin(__tsover_mul(lightAngle, DEG_TO_RAD));
-		const wtx = std.cos(__tsover_mul(weaveAngle, DEG_TO_RAD));
-		const wty = std.sin(__tsover_mul(weaveAngle, DEG_TO_RAD));
-		const envC = std.cos(__tsover_mul(envRotation, DEG_TO_RAD));
-		const envS = std.sin(__tsover_mul(envRotation, DEG_TO_RAD));
+		if (sdf > __tsover_mul(pxH, 2)) return vec4f(0, 0, 0, 0);
+		const lx = cos(__tsover_mul(lightAngle, DEG_TO_RAD));
+		const ly = sin(__tsover_mul(lightAngle, DEG_TO_RAD));
+		const wtx = cos(__tsover_mul(weaveAngle, DEG_TO_RAD));
+		const wty = sin(__tsover_mul(weaveAngle, DEG_TO_RAD));
+		const envC = cos(__tsover_mul(envRotation, DEG_TO_RAD));
+		const envS = sin(__tsover_mul(envRotation, DEG_TO_RAD));
 		const EPS = .01;
 		const gradX = __tsover_div(__tsover_sub(surfX.x, sdfRaw), EPS);
 		const gradY = __tsover_div(__tsover_sub(surfY.x, sdfRaw), EPS);
-		const ddx = std.clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -5, 5);
-		const ddy = std.clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -5, 5);
-		const nVol = std.normalize(d.vec3f(ddx, ddy, -1));
-		const rimT = std.clamp(__tsover_div(__tsover_mul(sdf, -1), .05), 0, 1);
+		const nVol = normalize(vec3f(clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -5, 5), clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -5, 5), -1));
+		const rimT = clamp(__tsover_div(__tsover_mul(sdf, -1), .05), 0, 1);
 		const rimBevel = __tsover_mul(__tsover_sub(1, rimT), 1.6);
-		const nFlat = std.normalize(d.vec3f(__tsover_mul(gradX, rimBevel), __tsover_mul(gradY, rimBevel), -1));
-		const nGeo = std.select(nFlat, nVol, volumetric > .5);
-		const pdx = std.select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
-		const pdy = std.select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
+		const nGeo = select(normalize(vec3f(__tsover_mul(gradX, rimBevel), __tsover_mul(gradY, rimBevel), -1)), nVol, volumetric > .5);
+		const pdx = select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
+		const pdy = select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
 		const wbx = __tsover_mul(wty, -1);
 		const wby = wtx;
 		const warp = __tsover_add(__tsover_mul(pdx, wtx), __tsover_mul(pdy, wty));
@@ -70,77 +69,75 @@ function buildCarbonFiberComposite(weaveStyle) {
 		const wScale = weaveScale;
 		const wA = __tsover_mul(warp, wScale);
 		const wB = __tsover_mul(weft, wScale);
-		const cellX = std.floor(wA);
-		const cellY = std.floor(wB);
-		const fA = __tsover_sub(std.fract(wA), .5);
-		const fB = __tsover_sub(std.fract(wB), .5);
-		let parity = d.f32(0);
+		const cellX = floor(wA);
+		const cellY = floor(wB);
+		const fA = __tsover_sub(fract(wA), .5);
+		const fB = __tsover_sub(fract(wB), .5);
+		let parity = f32(0);
 		if (weaveStyle === "plain") {
 			const s2 = __tsover_add(cellX, cellY);
-			parity = __tsover_sub(s2, __tsover_mul(2, std.floor(__tsover_div(s2, 2))));
+			parity = __tsover_sub(s2, __tsover_mul(2, floor(__tsover_div(s2, 2))));
 		} else {
 			const s4 = __tsover_add(__tsover_sub(cellX, cellY), 64);
-			const m4 = __tsover_sub(s4, __tsover_mul(4, std.floor(__tsover_div(s4, 4))));
-			parity = std.select(d.f32(0), d.f32(1), m4 >= 2);
+			const m4 = __tsover_sub(s4, __tsover_mul(4, floor(__tsover_div(s4, 4))));
+			parity = select(f32(0), f32(1), m4 >= 2);
 		}
-		const fiberX = std.mix(wtx, wbx, parity);
-		const fiberY = std.mix(wty, wby, parity);
-		const crossX = std.mix(wbx, wtx, parity);
-		const crossY = std.mix(wby, wty, parity);
-		const acrossLocal = std.mix(fB, fA, parity);
-		const alongLocal = std.mix(warp, weft, parity);
+		const fiberX = mix(wtx, wbx, parity);
+		const fiberY = mix(wty, wby, parity);
+		const crossX = mix(wbx, wtx, parity);
+		const crossY = mix(wby, wty, parity);
+		const acrossLocal = mix(fB, fA, parity);
+		const alongLocal = mix(warp, weft, parity);
 		const reliefAmt = __tsover_mul(relief, .32);
-		const bulge = __tsover_mul(std.sin(__tsover_mul(acrossLocal, PI)), reliefAmt);
-		const filJit = __tsover_mul(mxNoiseFloat2(d.vec2f(__tsover_mul(alongLocal, 2), __tsover_mul(acrossLocal, 40))), .18);
-		const filament = __tsover_mul(__tsover_add(std.sin(__tsover_mul(acrossLocal, TWO_PI_SEVEN)), filJit), .13);
+		const bulge = __tsover_mul(sin(__tsover_mul(acrossLocal, PI)), reliefAmt);
+		const filJit = __tsover_mul(mxNoiseFloat2(vec2f(__tsover_mul(alongLocal, 2), __tsover_mul(acrossLocal, 40))), .18);
+		const filament = __tsover_mul(__tsover_add(sin(__tsover_mul(acrossLocal, TWO_PI_SEVEN)), filJit), .13);
 		const crossTilt = __tsover_add(bulge, filament);
-		const n = std.normalize(d.vec3f(__tsover_add(nGeo.x, __tsover_mul(crossX, crossTilt)), __tsover_add(nGeo.y, __tsover_mul(crossY, crossTilt)), nGeo.z));
-		const edge = std.min(__tsover_sub(.5, std.abs(fA)), __tsover_sub(.5, std.abs(fB)));
-		const ao = std.mix(.5, 1, std.smoothstep(0, .05, edge));
+		const n = normalize(vec3f(__tsover_add(nGeo.x, __tsover_mul(crossX, crossTilt)), __tsover_add(nGeo.y, __tsover_mul(crossY, crossTilt)), nGeo.z));
+		const ao = mix(.5, 1, smoothstep(0, .05, min(__tsover_sub(.5, abs(fA)), __tsover_sub(.5, abs(fB)))));
 		const fov = .6;
-		const viewI = std.normalize(d.vec3f(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), aspect), fov), __tsover_mul(__tsover_sub(uv.y, .5), fov), 1));
-		const cosView = std.clamp(__tsover_mul(std.dot(n, viewI), -1), 0, 1);
+		const viewI = normalize(vec3f(__tsover_mul(__tsover_mul(__tsover_sub(uv.x, .5), aspect), fov), __tsover_mul(__tsover_sub(uv.y, .5), fov), 1));
+		const cosView = clamp(__tsover_mul(dot(n, viewI), -1), 0, 1);
 		const grazing = __tsover_sub(1, cosView);
-		const R = std.reflect(viewI, n);
-		const rough = std.clamp(roughness, 0, 1);
-		const t0 = d.vec3f(fiberX, fiberY, 0);
-		const T3 = std.normalize(t0.sub(n.mul(std.dot(n, t0))));
-		const B3 = d.vec3f(__tsover_sub(__tsover_mul(n.y, T3.z), __tsover_mul(n.z, T3.y)), __tsover_sub(__tsover_mul(n.z, T3.x), __tsover_mul(n.x, T3.z)), __tsover_sub(__tsover_mul(n.x, T3.y), __tsover_mul(n.y, T3.x)));
-		const L = std.normalize(d.vec3f(lx, ly, -.7));
-		const Hh = std.normalize(L.sub(viewI));
-		const hT = std.dot(Hh, T3);
-		const hB = std.dot(Hh, B3);
-		const hN = std.clamp(std.abs(std.dot(Hh, n)), 1e-4, 1);
-		const baseA = std.mix(.06, .5, rough);
+		const R = reflect(viewI, n);
+		const rough = clamp(roughness, 0, 1);
+		const t0 = vec3f(fiberX, fiberY, 0);
+		const T3 = normalize(t0.sub(n.mul(dot(n, t0))));
+		const B3 = vec3f(__tsover_sub(__tsover_mul(n.y, T3.z), __tsover_mul(n.z, T3.y)), __tsover_sub(__tsover_mul(n.z, T3.x), __tsover_mul(n.x, T3.z)), __tsover_sub(__tsover_mul(n.x, T3.y), __tsover_mul(n.y, T3.x)));
+		const L = normalize(vec3f(lx, ly, -.7));
+		const Hh = normalize(L.sub(viewI));
+		const hT = dot(Hh, T3);
+		const hB = dot(Hh, B3);
+		const hN = clamp(abs(dot(Hh, n)), 1e-4, 1);
+		const baseA = mix(.06, .5, rough);
 		const aAlong = __tsover_mul(baseA, 6);
 		const aAcross = baseA;
 		const expo = __tsover_div(__tsover_add(__tsover_mul(__tsover_div(hT, aAlong), __tsover_div(hT, aAlong)), __tsover_mul(__tsover_div(hB, aAcross), __tsover_div(hB, aAcross))), __tsover_mul(__tsover_add(hN, 1), .5));
-		const sheen = __tsover_mul(std.exp(__tsover_mul(expo, -1)), fiberSheen);
-		const ndl = std.clamp(__tsover_add(__tsover_mul(std.dot(n, L), .5), .5), 0, 1);
-		const bodyLum = std.clamp(__tsover_add(__tsover_add(.035, __tsover_mul(ndl, .1)), sheen), 0, 1.3);
-		const body = std.mix(darkColor, lightColor, d.vec3f(bodyLum)).mul(ao);
+		const sheen = __tsover_mul(exp(__tsover_mul(expo, -1)), fiberSheen);
+		const ndl = clamp(__tsover_add(__tsover_mul(dot(n, L), .5), .5), 0, 1);
+		const body = mix(darkColor, lightColor, vec3f(clamp(__tsover_add(__tsover_add(.035, __tsover_mul(ndl, .1)), sheen), 0, 1.3))).mul(ao);
 		const envStr = environment;
-		const keyRad = d.f32(.16);
+		const keyRad = f32(.16);
 		const ex = __tsover_sub(__tsover_mul(R.x, envC), __tsover_mul(R.y, envS));
 		const ey = __tsover_add(__tsover_mul(R.x, envS), __tsover_mul(R.y, envC));
-		const p = d.vec2f(ex, ey);
-		const sky = std.smoothstep(-.7, .85, ey);
+		const p = vec2f(ex, ey);
+		const sky = smoothstep(-.7, .85, ey);
 		let coatLum = __tsover_mul(__tsover_mul(sky, sky), .3);
 		const r0 = __tsover_mul(keyRad, 1);
-		coatLum = __tsover_add(coatLum, __tsover_mul(__tsover_mul(std.smoothstep(r0, __tsover_mul(r0, .2), std.length(p.sub(d.vec2f(0, .55)))), 1.7), envStr));
+		coatLum = __tsover_add(coatLum, __tsover_mul(__tsover_mul(smoothstep(r0, __tsover_mul(r0, .2), length(p.sub(vec2f(0, .55)))), 1.7), envStr));
 		const r1 = __tsover_mul(keyRad, 1.15);
-		coatLum = __tsover_add(coatLum, __tsover_mul(__tsover_mul(std.smoothstep(r1, __tsover_mul(r1, .2), std.length(p.sub(d.vec2f(-.55, .18)))), 1.05), envStr));
+		coatLum = __tsover_add(coatLum, __tsover_mul(__tsover_mul(smoothstep(r1, __tsover_mul(r1, .2), length(p.sub(vec2f(-.55, .18)))), 1.05), envStr));
 		const r2 = __tsover_mul(keyRad, 1);
-		coatLum = __tsover_add(coatLum, __tsover_mul(__tsover_mul(std.smoothstep(r2, __tsover_mul(r2, .2), std.length(p.sub(d.vec2f(.55, .1)))), 1), envStr));
+		coatLum = __tsover_add(coatLum, __tsover_mul(__tsover_mul(smoothstep(r2, __tsover_mul(r2, .2), length(p.sub(vec2f(.55, .1)))), 1), envStr));
 		const r3 = __tsover_mul(keyRad, 1.3);
-		coatLum = __tsover_add(coatLum, __tsover_mul(__tsover_mul(std.smoothstep(r3, __tsover_mul(r3, .2), std.length(p.sub(d.vec2f(.2, -.5)))), .7), envStr));
+		coatLum = __tsover_add(coatLum, __tsover_mul(__tsover_mul(smoothstep(r3, __tsover_mul(r3, .2), length(p.sub(vec2f(.2, -.5)))), .7), envStr));
 		const r4 = __tsover_mul(keyRad, 1.1);
-		coatLum = __tsover_add(coatLum, __tsover_mul(__tsover_mul(std.smoothstep(r4, __tsover_mul(r4, .2), std.length(p.sub(d.vec2f(-.35, -.25)))), .85), envStr));
-		const coatF = __tsover_add(.05, __tsover_mul(std.pow(grazing, d.f32(5)), .95));
+		coatLum = __tsover_add(coatLum, __tsover_mul(__tsover_mul(smoothstep(r4, __tsover_mul(r4, .2), length(p.sub(vec2f(-.35, -.25)))), .85), envStr));
+		const coatF = __tsover_add(.05, __tsover_mul(pow(grazing, f32(5)), .95));
 		const coat = __tsover_mul(__tsover_mul(coatLum, coatF), clearcoat);
-		const rgb = body.add(d.vec3f(coat, coat, coat));
-		const transition = std.smoothstep(0, 1, std.clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharpEdge), 32), 0, 1));
-		return d.vec4f(rgb.x, rgb.y, rgb.z, transition);
+		const rgb = body.add(vec3f(coat, coat, coat));
+		const transition = smoothstep(0, 1, clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharpEdge), 32), 0, 1));
+		return vec4f(rgb.x, rgb.y, rgb.z, transition);
 	}), {
 		v: 1,
 		name: void 0,
@@ -2736,8 +2733,8 @@ function buildCarbonFiberComposite(weaveStyle) {
 			]
 		},
 		externals: () => ({
-			std,
-			d,
+			std: std_exports,
+			d: data_exports,
 			DEG_TO_RAD,
 			weaveStyle,
 			PI,