shaders 3.0.448 → 3.0.450

package/dist/core/{FlowField-D4iGiDic.js → FlowField-tHrXhd1b.js}

@@ -1,34 +1,35 @@
-import { Bt as ZERO, Ht as call, J as std, Lt as sampleRemappedExpr, Tn as d, cn as unpremultiplyAlpha, dt as mxNoiseFloat3, jt as composeEdgeRemapExpr, n as tgpu, pt as noise_exports } from "./coords-BkIjixe_.js";
-import { s as transformEdges } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { Dt as length, N as unpremultiplyAlpha, Ot as max, Rt as sin, Ut as data_exports, bt as cos, c as sampleRemappedExpr, d as ZERO, et as src_default, in as vec3f, n as composeEdgeRemapExpr, nt as std_exports, p as call, sn as f32, tn as vec2f } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { d as mxNoiseFloat3, p as noise_exports } from "./noise-Cq0KUOSC.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var TWO_PI = Math.PI * 2;
-const flowFieldUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, scale, strength, time, evolutionTime) => {
+const flowFieldUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, scale, strength, time, evolutionTime) => {
 	"use gpu";
-	const aspectCorrectedUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const aspectCorrectedUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const drift1 = __tsover_mul(time, .7);
 	const evolve1 = __tsover_mul(evolutionTime, .2);
-	const angle1 = __tsover_mul(mxNoiseFloat3(d.vec3f(__tsover_add(__tsover_mul(aspectCorrectedUV.x, scale), __tsover_mul(drift1, .3)), __tsover_add(__tsover_mul(aspectCorrectedUV.y, scale), __tsover_mul(drift1, .5)), evolve1)), TWO_PI);
-	const flow1 = d.vec2f(std.cos(angle1), std.sin(angle1));
+	const angle1 = __tsover_mul(mxNoiseFloat3(vec3f(__tsover_add(__tsover_mul(aspectCorrectedUV.x, scale), __tsover_mul(drift1, .3)), __tsover_add(__tsover_mul(aspectCorrectedUV.y, scale), __tsover_mul(drift1, .5)), evolve1)), TWO_PI);
+	const flow1 = vec2f(cos(angle1), sin(angle1));
 	const drift2 = __tsover_mul(time, .5);
 	const evolve2 = __tsover_mul(evolutionTime, .15);
-	const angle2 = __tsover_mul(mxNoiseFloat3(d.vec3f(__tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.x, __tsover_mul(scale, 2.3)), __tsover_mul(drift2, -.4)), 173.5), __tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.y, __tsover_mul(scale, 2.3)), __tsover_mul(drift2, .3)), 291.7), __tsover_add(evolve2, 50))), TWO_PI);
-	const flow2 = d.vec2f(std.cos(angle2), std.sin(angle2));
+	const angle2 = __tsover_mul(mxNoiseFloat3(vec3f(__tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.x, __tsover_mul(scale, 2.3)), __tsover_mul(drift2, -.4)), 173.5), __tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.y, __tsover_mul(scale, 2.3)), __tsover_mul(drift2, .3)), 291.7), __tsover_add(evolve2, 50))), TWO_PI);
+	const flow2 = vec2f(cos(angle2), sin(angle2));
 	const drift3 = __tsover_mul(time, .3);
 	const evolve3 = __tsover_mul(evolutionTime, .1);
-	const angle3 = __tsover_mul(mxNoiseFloat3(d.vec3f(__tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.x, __tsover_mul(scale, 4.7)), __tsover_mul(drift3, .2)), 527.3), __tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.y, __tsover_mul(scale, 4.7)), __tsover_mul(drift3, -.6)), 839.1), __tsover_add(evolve3, 100))), TWO_PI);
-	const flow3 = d.vec2f(std.cos(angle3), std.sin(angle3));
+	const angle3 = __tsover_mul(mxNoiseFloat3(vec3f(__tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.x, __tsover_mul(scale, 4.7)), __tsover_mul(drift3, .2)), 527.3), __tsover_add(__tsover_add(__tsover_mul(aspectCorrectedUV.y, __tsover_mul(scale, 4.7)), __tsover_mul(drift3, -.6)), 839.1), __tsover_add(evolve3, 100))), TWO_PI);
+	const flow3 = vec2f(cos(angle3), sin(angle3));
 	const combinedFlow = flow1.add(flow2.mul(.5)).add(flow3.mul(.25));
-	const flowLength = std.max(std.length(combinedFlow), .001);
+	const flowLength = max(length(combinedFlow), .001);
 	const normalizedFlow = combinedFlow.div(flowLength);
-	const finalFlow = d.vec2f(__tsover_div(__tsover_mul(normalizedFlow.x, strength), aspect), __tsover_mul(normalizedFlow.y, strength));
-	return d.vec2f(__tsover_add(uv.x, finalFlow.x), __tsover_add(uv.y, finalFlow.y));
+	const finalFlow = vec2f(__tsover_div(__tsover_mul(normalizedFlow.x, strength), aspect), __tsover_mul(normalizedFlow.y, strength));
+	return vec2f(__tsover_add(uv.x, finalFlow.x), __tsover_add(uv.y, finalFlow.y));
 }), {
 	v: 1,
 	name: void 0,
@@ -646,10 +647,10 @@ const flowFieldUV = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		noise: noise_exports,
 		TWO_PI,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Flower-D0MqoayS.js → Flower-BfehbmmG.js}

@@ -1,16 +1,17 @@
-import { C as ShapeMask, F as sdf_exports, Ht as call, I as shapeLocalCoords, Jt as vec4, R as strokeMaskFromSdf, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, k as flowerSdf, 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 flowerShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	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, l as flowerSdf, n as ShapeMask, 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 flowerShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, sides, innerRatio, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{FlowingGradient-9Zu0Pu4a.js → FlowingGradient-BTKjkx5F.js}

@@ -1,50 +1,50 @@
-import { Ht as call, J as std, Tn as d, dt as mxNoiseFloat3, gn as mixColorsVariants, hn as mixColorsLinear, n as tgpu, pt as noise_exports } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { At as mix, 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, nt as std_exports, on as vec4f, p as call, sn as f32, tn as vec2f, yt as clamp, zt as smoothstep } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { d as mxNoiseFloat3, p as noise_exports } from "./noise-Cq0KUOSC.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var FOUR_PI = 4 * Math.PI;
-const flowingFactors = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseUV, viewport, distortion, seed, animTime) => {
+const flowingFactors = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((baseUV, viewport, distortion, seed, animTime) => {
 	"use gpu";
 	const t = __tsover_mul(animTime, .075);
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const uv0 = baseUV.sub(.5);
 	const seedOff = __tsover_mul(seed, .17);
-	const noiseVal = mxNoiseFloat3(d.vec3f(__tsover_add(__tsover_mul(uv0.x, .8), __tsover_mul(t, .4)), __tsover_sub(__tsover_mul(uv0.y, .8), __tsover_mul(t, .25)), seedOff));
+	const noiseVal = mxNoiseFloat3(vec3f(__tsover_add(__tsover_mul(uv0.x, .8), __tsover_mul(t, .4)), __tsover_sub(__tsover_mul(uv0.y, .8), __tsover_mul(t, .25)), seedOff));
 	const angle = __tsover_mul(__tsover_mul(noiseVal, FOUR_PI), distortion);
-	const uvCorr = d.vec2f(uv0.x, __tsover_div(uv0.y, aspect));
-	const ca = std.cos(angle);
-	const sa = std.sin(angle);
+	const uvCorr = vec2f(uv0.x, __tsover_div(uv0.y, aspect));
+	const ca = cos(angle);
+	const sa = sin(angle);
 	const rotX = __tsover_sub(__tsover_mul(uvCorr.x, ca), __tsover_mul(uvCorr.y, sa));
 	const rotY = __tsover_mul(__tsover_add(__tsover_mul(uvCorr.x, sa), __tsover_mul(uvCorr.y, ca)), aspect);
 	const ws = __tsover_mul(t, 2);
-	const warpX = __tsover_add(rotX, __tsover_mul(__tsover_div(std.sin(__tsover_add(__tsover_mul(rotY, 5), ws)), 50), distortion));
-	const warpY = __tsover_add(rotY, __tsover_mul(__tsover_div(std.sin(__tsover_add(__tsover_mul(warpX, 7.5), ws)), 25), distortion));
-	const wp1 = d.vec3f(__tsover_mul(warpX, 2), __tsover_mul(warpY, 2), __tsover_add(__tsover_mul(t, .5), seedOff));
-	const wx1 = mxNoiseFloat3(wp1.add(d.vec3f(5.2, 1.3, 0)));
-	const wy1 = mxNoiseFloat3(wp1.add(d.vec3f(1.7, 9.2, 0)));
+	const warpX = __tsover_add(rotX, __tsover_mul(__tsover_div(sin(__tsover_add(__tsover_mul(rotY, 5), ws)), 50), distortion));
+	const warpY = __tsover_add(rotY, __tsover_mul(__tsover_div(sin(__tsover_add(__tsover_mul(warpX, 7.5), ws)), 25), distortion));
+	const wp1 = vec3f(__tsover_mul(warpX, 2), __tsover_mul(warpY, 2), __tsover_add(__tsover_mul(t, .5), seedOff));
+	const wx1 = mxNoiseFloat3(wp1.add(vec3f(5.2, 1.3, 0)));
+	const wy1 = mxNoiseFloat3(wp1.add(vec3f(1.7, 9.2, 0)));
 	const dw1X = __tsover_add(warpX, __tsover_mul(__tsover_mul(wx1, .25), distortion));
 	const dw1Y = __tsover_add(warpY, __tsover_mul(__tsover_mul(wy1, .25), distortion));
-	const wp2 = d.vec3f(__tsover_mul(dw1X, 1.5), __tsover_mul(dw1Y, 1.5), __tsover_add(__tsover_mul(t, .3), seedOff));
-	const wx2 = mxNoiseFloat3(wp2.add(d.vec3f(8.3, 2.8, 0)));
-	const wy2 = mxNoiseFloat3(wp2.add(d.vec3f(3.1, 7.4, 0)));
+	const wp2 = vec3f(__tsover_mul(dw1X, 1.5), __tsover_mul(dw1Y, 1.5), __tsover_add(__tsover_mul(t, .3), seedOff));
+	const wx2 = mxNoiseFloat3(wp2.add(vec3f(8.3, 2.8, 0)));
+	const wy2 = mxNoiseFloat3(wp2.add(vec3f(3.1, 7.4, 0)));
 	const dw2X = __tsover_add(dw1X, __tsover_mul(__tsover_mul(wx2, .2), distortion));
 	const dw2Y = __tsover_add(dw1Y, __tsover_mul(__tsover_mul(wy2, .2), distortion));
-	const zoneNoise = mxNoiseFloat3(d.vec3f(__tsover_mul(dw2X, 1.8), __tsover_mul(dw2Y, 1.8), __tsover_add(__tsover_mul(t, .3), seedOff)));
-	const edgeHardness = std.pow(__tsover_add(__tsover_mul(wx1, .5), .5), 1.5);
-	const edgeWidth = std.mix(.5, .008, edgeHardness);
-	const t1 = std.smoothstep(__tsover_mul(edgeWidth, -1), edgeWidth, zoneNoise);
-	const t2 = std.smoothstep(__tsover_mul(edgeWidth, -1), edgeWidth, wy1);
-	const foldMask1 = __tsover_sub(1, std.abs(__tsover_sub(__tsover_mul(t1, 2), 1)));
-	const foldMask2 = __tsover_sub(1, std.abs(__tsover_sub(__tsover_mul(t2, 2), 1)));
-	const foldHighlight = __tsover_mul(std.max(foldMask1, foldMask2), edgeHardness);
+	const zoneNoise = mxNoiseFloat3(vec3f(__tsover_mul(dw2X, 1.8), __tsover_mul(dw2Y, 1.8), __tsover_add(__tsover_mul(t, .3), seedOff)));
+	const edgeHardness = pow(__tsover_add(__tsover_mul(wx1, .5), .5), 1.5);
+	const edgeWidth = mix(.5, .008, edgeHardness);
+	const t1 = smoothstep(__tsover_mul(edgeWidth, -1), edgeWidth, zoneNoise);
+	const t2 = smoothstep(__tsover_mul(edgeWidth, -1), edgeWidth, wy1);
+	const foldMask1 = __tsover_sub(1, abs(__tsover_sub(__tsover_mul(t1, 2), 1)));
+	const foldMask2 = __tsover_sub(1, abs(__tsover_sub(__tsover_mul(t2, 2), 1)));
+	const foldHighlight = __tsover_mul(max(foldMask1, foldMask2), edgeHardness);
 	const surfaceLight = __tsover_add(__tsover_mul(__tsover_add(__tsover_mul(wx2, .5), .5), .12), .94);
-	const litScale = __tsover_mul(surfaceLight, __tsover_add(1, __tsover_mul(foldHighlight, .35)));
-	return d.vec3f(t1, t2, litScale);
+	return vec3f(t1, t2, __tsover_mul(surfaceLight, __tsover_add(1, __tsover_mul(foldHighlight, .35))));
 }), {
 	v: 1,
 	name: void 0,
@@ -965,15 +965,14 @@ const flowingFactors = tgpu.fn([
 	},
 	externals: () => ({
 		noise: noise_exports,
-		d,
+		d: data_exports,
 		FOUR_PI,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
-const flowingCompose = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, litScale) => {
+const flowingCompose = src_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((base, litScale) => {
 	"use gpu";
-	const lit = std.clamp(base.xyz.mul(litScale), d.vec3f(0), d.vec3f(1));
-	return d.vec4f(lit, base.w);
+	return vec4f(clamp(base.xyz.mul(litScale), vec3f(0), vec3f(1)), base.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -1045,8 +1044,8 @@ const flowingCompose = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) =
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{FlutedGlass-C_clmShu.js → FlutedGlass-uFT7iy_9.js}

@@ -1,63 +1,63 @@
-import { Bt as ZERO, Ft as edgeWrapUV, Gt as expr, Ht as call, J as std, Jt as vec4, Mt as edgeClampUV, Nt as edgeMirrorUV, Pt as edgeTransparentMask, Tn as d, Xt as formatFloat, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, s as transformEdges } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { At as mix, Bt as sqrt, Et as fract, Lt as sign, Mt as pow, N as unpremultiplyAlpha, Ot as max, Qt as struct, Rt as sin, Ut as data_exports, a as edgeTransparentMask, bt as cos, d as ZERO, et as src_default, g as expr, ht as abs, i as edgeMirrorUV, in as vec3f, kt as min, nt as std_exports, o as edgeWrapUV, p as call, r as edgeClampUV, sn as f32, tn as vec2f, wt as exp2, x as formatFloat, y as vec4 } from "./edges-BZUKQxSE.js";
+import { t as animatedTime } from "./porters-DogLzpKT.js";
+import { a as transformColor, s as transformEdges } from "./transformations-CsPUHppB.js";
 var PI = Math.PI;
-const FlutedGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	refractedUV: d.vec2f,
-	chrOff: d.vec2f,
-	spec: d.f32
+const FlutedGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	refractedUV: vec2f,
+	chrOff: vec2f,
+	spec: f32
 }), "FlutedGeom");
-const flutedGlassGeom = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec3f
+const flutedGlassGeom = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec3f
 ], FlutedGeom)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, t, angleDeg, frequency, softness, waveAmp, waveFreq, refraction, aberration, lightAngleDeg, highlight, highlightSoftness, shapeParams) => {
 	"use gpu";
 	const expHi = shapeParams.x;
 	const expLo = shapeParams.y;
 	const wavesFlag = shapeParams.z;
 	const r = __tsover_div(__tsover_mul(angleDeg, PI), 180);
-	const cosA = std.cos(r);
-	const sinA = std.sin(r);
-	const aspCorr = d.vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5));
+	const cosA = cos(r);
+	const sinA = sin(r);
+	const aspCorr = vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5));
 	const u = __tsover_add(__tsover_mul(aspCorr.x, cosA), __tsover_mul(aspCorr.y, sinA));
 	const v = __tsover_add(__tsover_mul(-aspCorr.x, sinA), __tsover_mul(aspCorr.y, cosA));
-	const waveTerm = __tsover_mul(std.sin(__tsover_add(__tsover_mul(__tsover_mul(v, waveFreq), __tsover_mul(PI, 2)), __tsover_mul(t, 2))), waveAmp);
+	const waveTerm = __tsover_mul(sin(__tsover_add(__tsover_mul(__tsover_mul(v, waveFreq), __tsover_mul(PI, 2)), __tsover_mul(t, 2))), waveAmp);
 	const fluteU = __tsover_add(u, __tsover_mul(wavesFlag, waveTerm));
 	const flutePos = __tsover_add(__tsover_mul(fluteU, frequency), t);
-	const cellPos = __tsover_mul(__tsover_sub(std.fract(flutePos), .5), 2);
-	const absCell = std.max(std.abs(cellPos), 1e-4);
-	const exponent = std.mix(expHi, expLo, softness);
-	const slope = __tsover_mul(std.sign(cellPos), std.pow(absCell, exponent));
-	const halfCell = __tsover_div(.5, std.max(frequency, .001));
+	const cellPos = __tsover_mul(__tsover_sub(fract(flutePos), .5), 2);
+	const absCell = max(abs(cellPos), 1e-4);
+	const exponent = mix(expHi, expLo, softness);
+	const slope = __tsover_mul(sign(cellPos), pow(absCell, exponent));
+	const halfCell = __tsover_div(.5, max(frequency, .001));
 	const refrU = -__tsover_mul(__tsover_mul(slope, refraction), halfCell);
-	const refractedUV = d.vec2f(__tsover_add(uv.x, __tsover_div(__tsover_mul(refrU, cosA), aspect)), __tsover_add(uv.y, __tsover_mul(refrU, sinA)));
+	const refractedUV = vec2f(__tsover_add(uv.x, __tsover_div(__tsover_mul(refrU, cosA), aspect)), __tsover_add(uv.y, __tsover_mul(refrU, sinA)));
 	const chrU = __tsover_mul(__tsover_mul(refrU, aberration), .5);
-	const chrOff = d.vec2f(__tsover_div(__tsover_mul(chrU, cosA), aspect), __tsover_mul(chrU, sinA));
-	const slopeSq = std.min(__tsover_mul(slope, slope), 1);
-	const nz = std.sqrt(__tsover_sub(1, slopeSq));
+	const chrOff = vec2f(__tsover_div(__tsover_mul(chrU, cosA), aspect), __tsover_mul(chrU, sinA));
+	const slopeSq = min(__tsover_mul(slope, slope), 1);
+	const nz = sqrt(__tsover_sub(1, slopeSq));
 	const half = __tsover_div(__tsover_mul(lightAngleDeg, PI), 360);
-	const hx = std.sin(half);
-	const hy = std.cos(half);
-	const nDotH = std.max(__tsover_add(__tsover_mul(slope, hx), __tsover_mul(nz, hy)), 0);
-	const shininess = std.exp2(__tsover_sub(8, __tsover_mul(highlightSoftness, 7)));
-	const fresnel = std.pow(__tsover_sub(1, nz), 5);
+	const hx = sin(half);
+	const hy = cos(half);
+	const nDotH = max(__tsover_add(__tsover_mul(slope, hx), __tsover_mul(nz, hy)), 0);
+	const shininess = exp2(__tsover_sub(8, __tsover_mul(highlightSoftness, 7)));
+	const fresnel = pow(__tsover_sub(1, nz), 5);
 	const fresnelMix = __tsover_add(.04, __tsover_mul(.96, fresnel));
 	return FlutedGeom({
 		refractedUV,
 		chrOff,
-		spec: __tsover_mul(__tsover_mul(std.pow(nDotH, shininess), fresnelMix), highlight)
+		spec: __tsover_mul(__tsover_mul(pow(nDotH, shininess), fresnelMix), highlight)
 	});
 }), {
 	v: 1,
@@ -775,8 +775,8 @@ const flutedGlassGeom = tgpu.fn([
 	},
 	externals: () => ({
 		PI,
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		FlutedGeom
 	})
 }) && $.f)({}));