shaders 3.0.447 → 3.0.449

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-/* shaders@3.0.447 CLI — npx shaders install-mcp. https://shaders.com */
+/* shaders@3.0.449 CLI — npx shaders install-mcp. https://shaders.com */
 import { createRequire as __cliCreateRequire } from "module";
 const require = __cliCreateRequire(import.meta.url);
 var Vi=Object.create;var sr=Object.defineProperty;var Yi=Object.getOwnPropertyDescriptor;var Gi=Object.getOwnPropertyNames;var Ki=Object.getPrototypeOf,qi=Object.prototype.hasOwnProperty;var Ji=(e=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(e,{get:(t,i)=>(typeof require<"u"?require:t)[i]}):e)(function(e){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+e+'" is not supported')});var $=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports);var zi=(e,t,i,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let u of Gi(t))!qi.call(e,u)&&u!==i&&sr(e,u,{get:()=>t[u],enumerable:!(r=Yi(t,u))||r.enumerable});return e};var Se=(e,t,i)=>(i=e!=null?Vi(Ki(e)):{},zi(t||!e||!e.__esModule?sr(i,"default",{value:e,enumerable:!0}):i,e));var Dt=$((ka,or)=>{"use strict";var ht={to(e,t){return t?`\x1B[${t+1};${e+1}H`:`\x1B[${e+1}G`},move(e,t){let i="";return e<0?i+=`\x1B[${-e}D`:e>0&&(i+=`\x1B[${e}C`),t<0?i+=`\x1B[${-t}A`:t>0&&(i+=`\x1B[${t}B`),i},up:(e=1)=>`\x1B[${e}A`,down:(e=1)=>`\x1B[${e}B`,forward:(e=1)=>`\x1B[${e}C`,backward:(e=1)=>`\x1B[${e}D`,nextLine:(e=1)=>"\x1B[E".repeat(e),prevLine:(e=1)=>"\x1B[F".repeat(e),left:"\x1B[G",hide:"\x1B[?25l",show:"\x1B[?25h",save:"\x1B7",restore:"\x1B8"},Qi={up:(e=1)=>"\x1B[S".repeat(e),down:(e=1)=>"\x1B[T".repeat(e)},Zi={screen:"\x1B[2J",up:(e=1)=>"\x1B[1J".repeat(e),down:(e=1)=>"\x1B[J".repeat(e),line:"\x1B[2K",lineEnd:"\x1B[K",lineStart:"\x1B[1K",lines(e){let t="";for(let i=0;i<e;i++)t+=this.line+(i<e-1?ht.up():"");return e&&(t+=ht.left),t}};or.exports={cursor:ht,scroll:Qi,erase:Zi,beep:"\x07"}});var cr=$(($a,ft)=>{var Oe=process||{},lr=Oe.argv||[],Be=Oe.env||{},Xi=!(Be.NO_COLOR||lr.includes("--no-color"))&&(!!Be.FORCE_COLOR||lr.includes("--color")||Oe.platform==="win32"||(Oe.stdout||{}).isTTY&&Be.TERM!=="dumb"||!!Be.CI),eu=(e,t,i=e)=>r=>{let u=""+r,s=u.indexOf(t,e.length);return~s?e+tu(u,t,i,s)+t:e+u+t},tu=(e,t,i,r)=>{let u="",s=0;do u+=e.substring(s,r)+i,s=r+t.length,r=e.indexOf(t,s);while(~r);return u+e.substring(s)},ar=(e=Xi)=>{let t=e?eu:()=>String;return{isColorSupported:e,reset:t("\x1B[0m","\x1B[0m"),bold:t("\x1B[1m","\x1B[22m","\x1B[22m\x1B[1m"),dim:t("\x1B[2m","\x1B[22m","\x1B[22m\x1B[2m"),italic:t("\x1B[3m","\x1B[23m"),underline:t("\x1B[4m","\x1B[24m"),inverse:t("\x1B[7m","\x1B[27m"),hidden:t("\x1B[8m","\x1B[28m"),strikethrough:t("\x1B[9m","\x1B[29m"),black:t("\x1B[30m","\x1B[39m"),red:t("\x1B[31m","\x1B[39m"),green:t("\x1B[32m","\x1B[39m"),yellow:t("\x1B[33m","\x1B[39m"),blue:t("\x1B[34m","\x1B[39m"),magenta:t("\x1B[35m","\x1B[39m"),cyan:t("\x1B[36m","\x1B[39m"),white:t("\x1B[37m","\x1B[39m"),gray:t("\x1B[90m","\x1B[39m"),bgBlack:t("\x1B[40m","\x1B[49m"),bgRed:t("\x1B[41m","\x1B[49m"),bgGreen:t("\x1B[42m","\x1B[49m"),bgYellow:t("\x1B[43m","\x1B[49m"),bgBlue:t("\x1B[44m","\x1B[49m"),bgMagenta:t("\x1B[45m","\x1B[49m"),bgCyan:t("\x1B[46m","\x1B[49m"),bgWhite:t("\x1B[47m","\x1B[49m"),blackBright:t("\x1B[90m","\x1B[39m"),redBright:t("\x1B[91m","\x1B[39m"),greenBright:t("\x1B[92m","\x1B[39m"),yellowBright:t("\x1B[93m","\x1B[39m"),blueBright:t("\x1B[94m","\x1B[39m"),magentaBright:t("\x1B[95m","\x1B[39m"),cyanBright:t("\x1B[96m","\x1B[39m"),whiteBright:t("\x1B[97m","\x1B[39m"),bgBlackBright:t("\x1B[100m","\x1B[49m"),bgRedBright:t("\x1B[101m","\x1B[49m"),bgGreenBright:t("\x1B[102m","\x1B[49m"),bgYellowBright:t("\x1B[103m","\x1B[49m"),bgBlueBright:t("\x1B[104m","\x1B[49m"),bgMagentaBright:t("\x1B[105m","\x1B[49m"),bgCyanBright:t("\x1B[106m","\x1B[49m"),bgWhiteBright:t("\x1B[107m","\x1B[49m")}};ft.exports=ar();ft.exports.createColors=ar});var Wn=$((vc,Un)=>{"use strict";var re=class e extends Error{constructor(t,i,r){super("[ParserError] "+t,i,r),this.name="ParserError",this.code="ParserError",Error.captureStackTrace&&Error.captureStackTrace(this,e)}},Ge=class{constructor(t){this.parser=t,this.buf="",this.returned=null,this.result=null,this.resultTable=null,this.resultArr=null}},ve=class{constructor(){this.pos=0,this.col=0,this.line=0,this.obj={},this.ctx=this.obj,this.stack=[],this._buf="",this.char=null,this.ii=0,this.state=new Ge(this.parseStart)}parse(t){if(t.length===0||t.length==null)return;this._buf=String(t),this.ii=-1,this.char=-1;let i;for(;i===!1||this.nextChar();)i=this.runOne();this._buf=null}nextChar(){return this.char===10&&(++this.line,this.col=-1),++this.ii,this.char=this._buf.codePointAt(this.ii),++this.pos,++this.col,this.haveBuffer()}haveBuffer(){return this.ii<this._buf.length}runOne(){return this.state.parser.call(this,this.state.returned)}finish(){this.char=1114112;let t;do t=this.state.parser,this.runOne();while(this.state.parser!==t);return this.ctx=null,this.state=null,this._buf=null,this.obj}next(t){if(typeof t!="function")throw new re("Tried to set state to non-existent state: "+JSON.stringify(t));this.state.parser=t}goto(t){return this.next(t),this.runOne()}call(t,i){i&&this.next(i),this.stack.push(this.state),this.state=new Ge(t)}callNow(t,i){return this.call(t,i),this.runOne()}return(t){if(this.stack.length===0)throw this.error(new re("Stack underflow"));t===void 0&&(t=this.state.buf),this.state=this.stack.pop(),this.state.returned=t}returnNow(t){return this.return(t),this.runOne()}consume(){if(this.char===1114112)throw this.error(new re("Unexpected end-of-buffer"));this.state.buf+=this._buf[this.ii]}error(t){return t.line=this.line,t.col=this.col,t.pos=this.pos,t}parseStart(){throw new re("Must declare a parseStart method")}};ve.END=1114112;ve.Error=re;Un.exports=ve});var Yn=$((wc,Vn)=>{"use strict";Vn.exports=e=>{let t=new Date(e);if(isNaN(t))throw new TypeError("Invalid Datetime");return t}});var Ke=$((_c,Gn)=>{"use strict";Gn.exports=(e,t)=>{for(t=String(t);t.length<e;)t="0"+t;return t}});var qn=$((Tc,Kn)=>{"use strict";var De=Ke(),jt=class extends Date{constructor(t){super(t+"Z"),this.isFloating=!0}toISOString(){let t=`${this.getUTCFullYear()}-${De(2,this.getUTCMonth()+1)}-${De(2,this.getUTCDate())}`,i=`${De(2,this.getUTCHours())}:${De(2,this.getUTCMinutes())}:${De(2,this.getUTCSeconds())}.${De(3,this.getUTCMilliseconds())}`;return`${t}T${i}`}};Kn.exports=e=>{let t=new jt(e);if(isNaN(t))throw new TypeError("Invalid Datetime");return t}});var Qn=$((Sc,zn)=>{"use strict";var Jn=Ke(),cl=global.Date,Ut=class extends cl{constructor(t){super(t),this.isDate=!0}toISOString(){return`${this.getUTCFullYear()}-${Jn(2,this.getUTCMonth()+1)}-${Jn(2,this.getUTCDate())}`}};zn.exports=e=>{let t=new Ut(e);if(isNaN(t))throw new TypeError("Invalid Datetime");return t}});var Xn=$((Bc,Zn)=>{"use strict";var qe=Ke(),Wt=class extends Date{constructor(t){super(`0000-01-01T${t}Z`),this.isTime=!0}toISOString(){return`${qe(2,this.getUTCHours())}:${qe(2,this.getUTCMinutes())}:${qe(2,this.getUTCSeconds())}.${qe(3,this.getUTCMilliseconds())}`}};Zn.exports=e=>{let t=new Wt(e);if(isNaN(t))throw new TypeError("Invalid Datetime");return t}});var Je=$((exports,module)=>{"use strict";module.exports=makeParserClass(Wn());module.exports.makeParserClass=makeParserClass;var TomlError=class e extends Error{constructor(t){super(t),this.name="TomlError",Error.captureStackTrace&&Error.captureStackTrace(this,e),this.fromTOML=!0,this.wrapped=null}};TomlError.wrap=e=>{let t=new TomlError(e.message);return t.code=e.code,t.wrapped=e,t};module.exports.TomlError=TomlError;var createDateTime=Yn(),createDateTimeFloat=qn(),createDate=Qn(),createTime=Xn(),CTRL_I=9,CTRL_J=10,CTRL_M=13,CTRL_CHAR_BOUNDARY=31,CHAR_SP=32,CHAR_QUOT=34,CHAR_NUM=35,CHAR_APOS=39,CHAR_PLUS=43,CHAR_COMMA=44,CHAR_HYPHEN=45,CHAR_PERIOD=46,CHAR_0=48,CHAR_1=49,CHAR_7=55,CHAR_9=57,CHAR_COLON=58,CHAR_EQUALS=61,CHAR_A=65,CHAR_E=69,CHAR_F=70,CHAR_T=84,CHAR_U=85,CHAR_Z=90,CHAR_LOWBAR=95,CHAR_a=97,CHAR_b=98,CHAR_e=101,CHAR_f=102,CHAR_i=105,CHAR_l=108,CHAR_n=110,CHAR_o=111,CHAR_r=114,CHAR_s=115,CHAR_t=116,CHAR_u=117,CHAR_x=120,CHAR_z=122,CHAR_LCUB=123,CHAR_RCUB=125,CHAR_LSQB=91,CHAR_BSOL=92,CHAR_RSQB=93,CHAR_DEL=127,SURROGATE_FIRST=55296,SURROGATE_LAST=57343,escapes={[CHAR_b]:"\b",[CHAR_t]:"	",[CHAR_n]:`
@@ -106,7 +106,7 @@ Options:
 Supported agents:
   ${e}
 
-Docs: ${Pi}`)}function Ba(e){let t={global:!1,yes:!1,agents:[]},i;for(let r=0;r<e.length;r++){let u=e[r];switch(u){case"-g":case"--global":t.global=!0;break;case"-y":case"--yes":t.yes=!0;break;case"-a":case"--agent":{let s=e[++r];s||ie(`Missing value for ${u}`),t.agents.push(...s.split(",").map(n=>n.trim()).filter(Boolean));break}case"-h":case"--help":Mi(),process.exit(0);break;case"-v":case"--version":console.log("3.0.447"),process.exit(0);break;default:u.startsWith("-")&&ie(`Unknown option: ${u} (see npx shaders --help)`),i&&ie(`Unexpected argument: ${u}`),i=u}}return{command:i,flags:t}}function ie(e){console.error(`\u2717 ${e}`),process.exit(1)}function ji(e){let t=new Set(Z());for(let i of e)t.has(i)||ie(`Unknown agent "${i}". Supported agents: ${Z().join(", ")}`);return e}async function Oa(e,t){if(e.agents.length>0)return{targets:ji(e.agents),scope:e.global?"global":"project"};let i=e.global?[]:Qt(t),r=e.global||i.length===0?"global":"project",u=r==="project"?i:await Zt();if(!(!e.yes&&process.stdout.isTTY&&process.stdin.isTTY))return u.length===0&&ie(`No coding agents detected. Pass one explicitly, e.g. npx shaders install-mcp -a cursor
+Docs: ${Pi}`)}function Ba(e){let t={global:!1,yes:!1,agents:[]},i;for(let r=0;r<e.length;r++){let u=e[r];switch(u){case"-g":case"--global":t.global=!0;break;case"-y":case"--yes":t.yes=!0;break;case"-a":case"--agent":{let s=e[++r];s||ie(`Missing value for ${u}`),t.agents.push(...s.split(",").map(n=>n.trim()).filter(Boolean));break}case"-h":case"--help":Mi(),process.exit(0);break;case"-v":case"--version":console.log("3.0.449"),process.exit(0);break;default:u.startsWith("-")&&ie(`Unknown option: ${u} (see npx shaders --help)`),i&&ie(`Unexpected argument: ${u}`),i=u}}return{command:i,flags:t}}function ie(e){console.error(`\u2717 ${e}`),process.exit(1)}function ji(e){let t=new Set(Z());for(let i of e)t.has(i)||ie(`Unknown agent "${i}". Supported agents: ${Z().join(", ")}`);return e}async function Oa(e,t){if(e.agents.length>0)return{targets:ji(e.agents),scope:e.global?"global":"project"};let i=e.global?[]:Qt(t),r=e.global||i.length===0?"global":"project",u=r==="project"?i:await Zt();if(!(!e.yes&&process.stdout.isTTY&&process.stdin.isTTY))return u.length===0&&ie(`No coding agents detected. Pass one explicitly, e.g. npx shaders install-mcp -a cursor
 Supported agents: ${Z().join(", ")}`),{targets:u,scope:r};let n=await Et({message:`Install the Shaders MCP server to which agents? (${r} config)`,options:Z().map(o=>({value:o,label:R[o].displayName,hint:r==="project"&&R[o].localConfigPath?R[o].localConfigPath:R[o].configPath.replace(/^\/Users\/[^/]+|^\/home\/[^/]+|^C:\\Users\\[^\\]+/,"~")})),initialValues:u,required:!0});return de(n)&&(console.log("Cancelled \u2014 nothing was changed."),process.exit(0)),{targets:n,scope:r}}async function Ra(e){let t=process.cwd(),{targets:i,scope:r}=await Oa(e,t),u=0;for(let s of i){let n=r==="project"&&!!R[s].localConfigPath,o=$i(s,ir,{type:"http",url:Sa},{local:n,cwd:t});o.success?console.log(`\u2713 ${R[s].displayName} \u2014 ${o.path}`):(u++,console.error(`\u2717 ${R[s].displayName} \u2014 ${o.error}`))}u===i.length&&process.exit(1),console.log(`
 Done! Open your agent and connect to the "${ir}" MCP server \u2014 you'll be
 prompted to sign in to your Shaders account (Pro) the first time it connects.

package/dist/core/{AngularBlur-xU811GPM.js → AngularBlur-DU1WmNHt.js}

@@ -1,5 +1,5 @@
-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";
-import { c as transformPosition } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, It as sin, N as unpremultiplyAlpha, Vt as data_exports, _ as floatE, an as f32, d as ZERO, et as src_default, nt as std_exports, p as call, vt as cos } from "./edges-BXNBKxSN.js";
+import { c as transformPosition } from "./transformations-CsPUHppB.js";
 var rawWeights = Array.from({ length: 32 }, (_, i) => {
 	const t = (i / 31 - .5) * 2;
 	return Math.exp(-.5 * t * t / .64);
@@ -7,26 +7,26 @@ var rawWeights = Array.from({ length: 32 }, (_, i) => {
 var wSum = rawWeights.reduce((a, b) => a + b);
 const BLUR_WEIGHTS = rawWeights.map((w) => w / wSum);
 const TAP_COUNT = 32;
-const angularBlurTapCoord = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, intensity, uv, aspect, tapIndex) => {
+const angularBlurTapCoord = src_default.fn([
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, intensity, uv, aspect, tapIndex) => {
 	"use gpu";
-	const centerPos = d.vec2f(center.x, __tsover_sub(1, center.y));
+	const centerPos = vec2f(center.x, __tsover_sub(1, center.y));
 	const angleStep = __tsover_div(__tsover_mul(intensity, .005), 31);
 	const angle = __tsover_mul(tapIndex, angleStep);
-	const cosA = std.cos(angle);
-	const sinA = std.sin(angle);
+	const cosA = cos(angle);
+	const sinA = sin(angle);
 	const initX = __tsover_sub(uv.x, centerPos.x);
 	const initY = __tsover_sub(uv.y, centerPos.y);
 	const acX = __tsover_mul(initX, aspect);
 	const acY = initY;
 	const rotX = __tsover_sub(__tsover_mul(acX, cosA), __tsover_mul(acY, sinA));
 	const rotY = __tsover_add(__tsover_mul(acX, sinA), __tsover_mul(acY, cosA));
-	return d.vec2f(__tsover_add(__tsover_div(rotX, aspect), centerPos.x), __tsover_add(rotY, centerPos.y));
+	return vec2f(__tsover_add(__tsover_div(rotX, aspect), centerPos.x), __tsover_add(rotY, centerPos.y));
 }), {
 	v: 1,
 	name: void 0,
@@ -258,8 +258,8 @@ const angularBlurTapCoord = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Arc-DYvFxtGy.js → Arc-C8QmYsiZ.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, n as tgpu, w as arcSdf } 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";
+import { $t as vec2f, H as mixColorsLinear, U as mixColorsVariants, an as f32, et as src_default, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { g as shapeLocalCoords, h as sdf_exports, n as ShapeMask, r as arcSdf, v as strokeMaskFromSdf } from "./sdf-R0EN3EvS.js";
+import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var APERTURE_TO_HALF_ANGLE = .008726646259971648;
-const arcShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
+const arcShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, aperture, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);

package/dist/core/{Ascii-ChE4BP7J.js → Ascii-BaQ6MZTc.js}

@@ -1,5 +1,5 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { i as transformBoolean } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, At as pow, Ct as floor, N as unpremultiplyAlpha, Vt as data_exports, Xt as struct, _t as clamp, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, mt as abs, nn as vec3f, nt as std_exports, p as call, pt as select, wt as fract } from "./edges-BXNBKxSN.js";
+import { i as transformBoolean } from "./transformations-CsPUHppB.js";
 var ATLAS_TEXTURE_SIZE = 2048;
 var REFERENCE_HEIGHT = 1080;
 var GOOGLE_FONTS_MAP = {
@@ -50,31 +50,31 @@ async function loadAsciiFont(fontFamily) {
 	} catch {}
 }
 var num = (v, f) => typeof v === "number" ? v : f;
-var AsciiGrid = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	cellCenter: d.vec2f,
-	cellUV: d.vec2f,
-	isOutside: d.f32
+var AsciiGrid = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	cellCenter: vec2f,
+	cellUV: vec2f,
+	isOutside: f32
 }), "AsciiGrid");
-const asciiGrid = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32
+const asciiGrid = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
 ], AsciiGrid)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cellSize, spacing) => {
 	"use gpu";
 	const scaleFactor = __tsover_div(viewport.y, REFERENCE_HEIGHT);
 	const effectiveCellSize = __tsover_mul(cellSize, scaleFactor);
-	const mainGridSize = d.vec2f(__tsover_div(viewport.x, effectiveCellSize), __tsover_div(viewport.y, effectiveCellSize));
-	const gridCoords = d.vec2f(__tsover_mul(uv.x, mainGridSize.x), __tsover_mul(uv.y, mainGridSize.y));
-	const cellCoords = std.floor(gridCoords);
-	const rawCellUV = std.fract(gridCoords);
+	const mainGridSize = vec2f(__tsover_div(viewport.x, effectiveCellSize), __tsover_div(viewport.y, effectiveCellSize));
+	const gridCoords = vec2f(__tsover_mul(uv.x, mainGridSize.x), __tsover_mul(uv.y, mainGridSize.y));
+	const cellCoords = floor(gridCoords);
+	const rawCellUV = fract(gridCoords);
 	const centeredU = __tsover_sub(rawCellUV.x, .5);
 	const centeredV = __tsover_sub(rawCellUV.y, .5);
-	const cellUV = d.vec2f(__tsover_add(__tsover_div(centeredU, spacing), .5), __tsover_add(__tsover_div(centeredV, spacing), .5));
+	const cellUV = vec2f(__tsover_add(__tsover_div(centeredU, spacing), .5), __tsover_add(__tsover_div(centeredV, spacing), .5));
 	const half = __tsover_mul(spacing, .5);
-	const isOutside = std.select(d.f32(0), d.f32(1), std.abs(centeredU) > half || std.abs(centeredV) > half);
+	const isOutside = select(f32(0), f32(1), abs(centeredU) > half || abs(centeredV) > half);
 	return AsciiGrid({
-		cellCenter: d.vec2f(__tsover_div(__tsover_add(cellCoords.x, .5), mainGridSize.x), __tsover_div(__tsover_add(cellCoords.y, .5), mainGridSize.y)),
+		cellCenter: vec2f(__tsover_div(__tsover_add(cellCoords.x, .5), mainGridSize.x), __tsover_div(__tsover_add(cellCoords.y, .5), mainGridSize.y)),
 		cellUV,
 		isOutside
 	});
@@ -424,31 +424,29 @@ const asciiGrid = tgpu.fn([
 	},
 	externals: () => ({
 		REFERENCE_HEIGHT,
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		AsciiGrid
 	})
 }) && $.f)({})).$name("asciiGrid");
-const asciiAtlasUV = tgpu.fn([
-	d.vec3f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cellRgb, gamma, charCount, atlasSize, atlasScale, cellUV) => {
+const asciiAtlasUV = src_default.fn([
+	vec3f,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cellRgb, gamma, charCount, atlasSize, atlasScale, cellUV) => {
 	"use gpu";
-	const rawBrightness = std.dot(cellRgb, d.vec3f(.299, .587, .114));
-	const adjustedBrightness = std.pow(rawBrightness, gamma);
+	const adjustedBrightness = pow(dot(cellRgb, vec3f(.299, .587, .114)), gamma);
 	const invertedBrightness = __tsover_sub(1, adjustedBrightness);
-	const scaledBrightness = __tsover_mul(invertedBrightness, charCount);
-	const charIndex = std.clamp(std.floor(scaledBrightness), 0, __tsover_sub(charCount, 1));
-	const atlasCol = __tsover_sub(charIndex, __tsover_mul(atlasSize, std.floor(__tsover_div(charIndex, atlasSize))));
-	const atlasRow = std.floor(__tsover_div(charIndex, atlasSize));
+	const charIndex = clamp(floor(__tsover_mul(invertedBrightness, charCount)), 0, __tsover_sub(charCount, 1));
+	const atlasCol = __tsover_sub(charIndex, __tsover_mul(atlasSize, floor(__tsover_div(charIndex, atlasSize))));
+	const atlasRow = floor(__tsover_div(charIndex, atlasSize));
 	const atlasCellSize = __tsover_mul(__tsover_div(1, atlasSize), atlasScale);
 	const baseU = __tsover_mul(atlasCol, atlasCellSize);
 	const baseV = __tsover_mul(atlasRow, atlasCellSize);
-	return d.vec2f(__tsover_add(baseU, __tsover_mul(cellUV.x, atlasCellSize)), __tsover_add(baseV, __tsover_mul(cellUV.y, atlasCellSize)));
+	return vec2f(__tsover_add(baseU, __tsover_mul(cellUV.x, atlasCellSize)), __tsover_add(baseV, __tsover_mul(cellUV.y, atlasCellSize)));
 }), {
 	v: 1,
 	name: void 0,
@@ -690,25 +688,25 @@ const asciiAtlasUV = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({})).$name("asciiAtlasUV");
-const asciiCompose = tgpu.fn([
-	d.vec3f,
-	d.vec4f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((asciiRgb, cellColor, isOutside, alphaThreshold, preserveAlpha) => {
+const asciiCompose = src_default.fn([
+	vec3f,
+	vec4f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((asciiRgb, cellColor, isOutside, alphaThreshold, preserveAlpha) => {
 	"use gpu";
-	const isBackground = std.dot(asciiRgb, d.vec3f(.299, .587, .114)) < .1;
+	const isBackground = dot(asciiRgb, vec3f(.299, .587, .114)) < .1;
 	const sourceAlpha = cellColor.w;
 	const isBelowThreshold = sourceAlpha < alphaThreshold;
-	const outputAlpha = std.select(d.f32(1), sourceAlpha, preserveAlpha > .5);
+	const outputAlpha = select(f32(1), sourceAlpha, preserveAlpha > .5);
 	const hide = isBackground || isOutside > .5 || isBelowThreshold;
-	const finalAlpha = std.select(outputAlpha, d.f32(0), hide);
-	return d.vec4f(__tsover_mul(asciiRgb.x, cellColor.x), __tsover_mul(asciiRgb.y, cellColor.y), __tsover_mul(asciiRgb.z, cellColor.z), finalAlpha);
+	const finalAlpha = select(outputAlpha, f32(0), hide);
+	return vec4f(__tsover_mul(asciiRgb.x, cellColor.x), __tsover_mul(asciiRgb.y, cellColor.y), __tsover_mul(asciiRgb.z, cellColor.z), finalAlpha);
 }), {
 	v: 1,
 	name: void 0,
@@ -922,8 +920,8 @@ const asciiCompose = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({})).$name("asciiCompose");
 const componentDefinition = {
@@ -935,15 +933,15 @@ const componentDefinition = {
 	requiresChild: true,
 	extraFields: {
 		_charCount: {
-			schema: d.f32,
+			schema: f32,
 			initial: 9
 		},
 		_atlasScale: {
-			schema: d.f32,
+			schema: f32,
 			initial: 1
 		},
 		_atlasSize: {
-			schema: d.f32,
+			schema: f32,
 			initial: 3
 		}
 	},

package/dist/core/{Aurora-BThE6pbb.js → Aurora-B6lOg6M4.js}

@@ -1,46 +1,46 @@
-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, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, At as pow, H as mixColorsLinear, It as sin, Lt as smoothstep, Ot as mix, U as mixColorsVariants, Vt as data_exports, _t as clamp, an as f32, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call, pt as select, wt as fract, xt as exp } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { d as mxNoiseFloat3, p as noise_exports } from "./noise-wTSHXgFz.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
 var TWO_PI = Math.PI * 2;
-const auroraCurtain = 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.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, layerIdx, layerTime, centerX, centerY, aspect, waviness, rayAmount, auroraHeight, seed, t) => {
+const auroraCurtain = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, layerIdx, layerTime, centerX, centerY, aspect, waviness, rayAmount, auroraHeight, seed, t) => {
 	"use gpu";
 	const tSlow = __tsover_add(__tsover_mul(t, .06), layerTime);
 	const lSeed = __tsover_add(seed, __tsover_mul(layerIdx, 31.7));
 	const wx = __tsover_mul(__tsover_mul(__tsover_sub(uv.x, centerX), aspect), 2);
-	const ph1 = __tsover_mul(std.fract(__tsover_mul(std.sin(__tsover_mul(lSeed, 12.9)), 4758.5)), TWO_PI);
-	const ph2 = __tsover_mul(std.fract(__tsover_mul(std.sin(__tsover_mul(lSeed, 78.2)), 2847.1)), TWO_PI);
-	const ph3 = __tsover_mul(std.fract(__tsover_mul(std.sin(__tsover_mul(lSeed, 41.6)), 1593.7)), TWO_PI);
-	const arc = __tsover_add(__tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_add(__tsover_mul(wx, .7), __tsover_mul(tSlow, .4)), ph1)), .15), __tsover_mul(std.sin(__tsover_add(__tsover_add(__tsover_mul(wx, 1.6), __tsover_mul(tSlow, .65)), ph2)), .08)), __tsover_mul(std.sin(__tsover_add(__tsover_add(__tsover_mul(wx, 2.9), __tsover_mul(tSlow, .3)), ph3)), .04));
-	const noiseWarp = mxNoiseFloat3(d.vec3f(__tsover_mul(wx, .5), __tsover_mul(tSlow, .25), __tsover_mul(lSeed, .1)));
+	const ph1 = __tsover_mul(fract(__tsover_mul(sin(__tsover_mul(lSeed, 12.9)), 4758.5)), TWO_PI);
+	const ph2 = __tsover_mul(fract(__tsover_mul(sin(__tsover_mul(lSeed, 78.2)), 2847.1)), TWO_PI);
+	const ph3 = __tsover_mul(fract(__tsover_mul(sin(__tsover_mul(lSeed, 41.6)), 1593.7)), TWO_PI);
+	const arc = __tsover_add(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_add(__tsover_mul(wx, .7), __tsover_mul(tSlow, .4)), ph1)), .15), __tsover_mul(sin(__tsover_add(__tsover_add(__tsover_mul(wx, 1.6), __tsover_mul(tSlow, .65)), ph2)), .08)), __tsover_mul(sin(__tsover_add(__tsover_add(__tsover_mul(wx, 2.9), __tsover_mul(tSlow, .3)), ph3)), .04));
+	const noiseWarp = mxNoiseFloat3(vec3f(__tsover_mul(wx, .5), __tsover_mul(tSlow, .25), __tsover_mul(lSeed, .1)));
 	const pathY = __tsover_add(__tsover_add(centerY, __tsover_mul(arc, waviness)), __tsover_mul(__tsover_mul(noiseWarp, .14), waviness));
 	const warpedX = __tsover_add(wx, __tsover_mul(noiseWarp, 2.5));
-	const rayFreq = std.mix(d.f32(6), d.f32(20), rayAmount);
-	const rayPhase = __tsover_mul(std.fract(__tsover_mul(std.sin(__tsover_mul(lSeed, 53.7)), 3847.2)), TWO_PI);
-	const rays = std.pow(__tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_add(__tsover_mul(warpedX, __tsover_mul(rayFreq, .15)), __tsover_mul(tSlow, .1)), rayPhase)), .5), .5), 1.5);
-	const localHeight = __tsover_mul(auroraHeight, std.mix(.4, 1, rays));
+	const rayFreq = mix(f32(6), f32(20), rayAmount);
+	const rayPhase = __tsover_mul(fract(__tsover_mul(sin(__tsover_mul(lSeed, 53.7)), 3847.2)), TWO_PI);
+	const rays = pow(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_add(__tsover_mul(warpedX, __tsover_mul(rayFreq, .15)), __tsover_mul(tSlow, .1)), rayPhase)), .5), .5), 1.5);
+	const localHeight = __tsover_mul(auroraHeight, mix(.4, 1, rays));
 	const distFromPath = __tsover_sub(uv.y, pathY);
-	const bottomFade = std.smoothstep(-.04, .015, distFromPath);
+	const bottomFade = smoothstep(-.04, .015, distFromPath);
 	const topExtent = __tsover_mul(localHeight, __tsover_add(__tsover_mul(rays, .4), .6));
-	const topFade = __tsover_sub(1, std.smoothstep(0, topExtent, distFromPath));
+	const topFade = __tsover_sub(1, smoothstep(0, topExtent, distFromPath));
 	const envelope = __tsover_mul(bottomFade, topFade);
-	const sectionBright = std.mix(.4, 1, __tsover_add(__tsover_mul(noiseWarp, .5), .5));
-	const colorT = std.clamp(__tsover_div(distFromPath, __tsover_add(topExtent, .001)), 0, 1);
+	const sectionBright = mix(.4, 1, __tsover_add(__tsover_mul(noiseWarp, .5), .5));
+	const colorT = clamp(__tsover_div(distFromPath, __tsover_add(topExtent, .001)), 0, 1);
 	const coreD = __tsover_sub(colorT, .2);
-	const coreBright = __tsover_add(__tsover_mul(std.exp(__tsover_mul(__tsover_mul(coreD, coreD), -6)), .3), 1);
-	const finalAlpha = __tsover_mul(__tsover_mul(__tsover_mul(envelope, rays), sectionBright), coreBright);
-	return d.vec2f(colorT, finalAlpha);
+	const coreBright = __tsover_add(__tsover_mul(exp(__tsover_mul(__tsover_mul(coreD, coreD), -6)), .3), 1);
+	return vec2f(colorT, __tsover_mul(__tsover_mul(__tsover_mul(envelope, rays), sectionBright), coreBright));
 }), {
 	v: 1,
 	name: void 0,
@@ -831,25 +831,25 @@ const auroraCurtain = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		TWO_PI,
-		d,
+		d: data_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));
-const auroraField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, animTime, seed, waviness, rayDensity, height, center, balance, intensity, curtainCount) => {
+const auroraField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, animTime, seed, waviness, rayDensity, height, center, balance, intensity, curtainCount) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const centerX = center.x;
@@ -858,31 +858,28 @@ const auroraField = tgpu.fn([
 	const rayAmt = __tsover_mul(rayDensity, .01);
 	const auroraHeight = __tsover_mul(height, .01);
 	const intens = __tsover_mul(intensity, .018);
-	const balanceExp = std.mix(2.5, .4, __tsover_mul(balance, .01));
+	const balanceExp = mix(2.5, .4, __tsover_mul(balance, .01));
 	const t = animTime;
-	const a0 = auroraCurtain(uv, d.f32(0), 0, centerX, centerY, aspect, wav, rayAmt, auroraHeight, seed, t);
+	const a0 = auroraCurtain(uv, f32(0), 0, centerX, centerY, aspect, wav, rayAmt, auroraHeight, seed, t);
 	let weightedT = __tsover_mul(a0.x, a0.y);
 	let totalAlpha = a0.y;
-	const g1 = std.select(d.f32(0), d.f32(1), curtainCount >= 2);
-	const a1 = auroraCurtain(uv, d.f32(1), 3.1, centerX, centerY, aspect, wav, rayAmt, auroraHeight, seed, t);
+	const g1 = select(f32(0), f32(1), curtainCount >= 2);
+	const a1 = auroraCurtain(uv, f32(1), 3.1, centerX, centerY, aspect, wav, rayAmt, auroraHeight, seed, t);
 	const w1 = __tsover_mul(__tsover_mul(a1.y, .65), g1);
 	weightedT = __tsover_add(weightedT, __tsover_mul(a1.x, w1));
 	totalAlpha = __tsover_add(totalAlpha, w1);
-	const g2 = std.select(d.f32(0), d.f32(1), curtainCount >= 3);
-	const a2 = auroraCurtain(uv, d.f32(2), 6.7, centerX, centerY, aspect, wav, rayAmt, auroraHeight, seed, t);
+	const g2 = select(f32(0), f32(1), curtainCount >= 3);
+	const a2 = auroraCurtain(uv, f32(2), 6.7, centerX, centerY, aspect, wav, rayAmt, auroraHeight, seed, t);
 	const w2 = __tsover_mul(__tsover_mul(a2.y, .45), g2);
 	weightedT = __tsover_add(weightedT, __tsover_mul(a2.x, w2));
 	totalAlpha = __tsover_add(totalAlpha, w2);
-	const g3 = std.select(d.f32(0), d.f32(1), curtainCount >= 4);
-	const a3 = auroraCurtain(uv, d.f32(3), 9.4, centerX, centerY, aspect, wav, rayAmt, auroraHeight, seed, t);
+	const g3 = select(f32(0), f32(1), curtainCount >= 4);
+	const a3 = auroraCurtain(uv, f32(3), 9.4, centerX, centerY, aspect, wav, rayAmt, auroraHeight, seed, t);
 	const w3 = __tsover_mul(__tsover_mul(a3.y, .3), g3);
 	weightedT = __tsover_add(weightedT, __tsover_mul(a3.x, w3));
 	totalAlpha = __tsover_add(totalAlpha, w3);
-	const avgT = std.pow(__tsover_div(weightedT, __tsover_add(totalAlpha, .001)), balanceExp);
-	const lowToMid = std.smoothstep(0, .2, avgT);
-	const midToHigh = std.smoothstep(.4, .85, avgT);
-	const brightness = __tsover_mul(totalAlpha, intens);
-	return d.vec3f(lowToMid, midToHigh, brightness);
+	const avgT = pow(__tsover_div(weightedT, __tsover_add(totalAlpha, .001)), balanceExp);
+	return vec3f(smoothstep(0, .2, avgT), smoothstep(.4, .85, avgT), __tsover_mul(totalAlpha, intens));
 }), {
 	v: 1,
 	name: void 0,
@@ -1537,16 +1534,14 @@ const auroraField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		std,
+		std: std_exports,
 		auroraCurtain,
-		d
+		d: data_exports
 	})
 }) && $.f)({}));
-const auroraCompose = tgpu.fn([d.vec4f, d.f32], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, brightness) => {
+const auroraCompose = src_default.fn([vec4f, f32], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, brightness) => {
 	"use gpu";
-	const col = std.clamp(color.xyz.mul(brightness), d.vec3f(0), d.vec3f(1));
-	const alpha = std.clamp(__tsover_mul(brightness, .5), 0, 1);
-	return d.vec4f(col, alpha);
+	return vec4f(clamp(color.xyz.mul(brightness), vec3f(0), vec3f(1)), clamp(__tsover_mul(brightness, .5), 0, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -1639,8 +1634,8 @@ const auroraCompose = 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/{BarShift-DdjkPSk3.js → BarShift-CFK-CzF9.js}

@@ -1,10 +1,10 @@
-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 { r as transformAngle, s as transformEdges } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, Ct as floor, Et as max, It as sin, N as unpremultiplyAlpha, 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, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { r as transformAngle, s as transformEdges } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = .0174533;
-const barHash = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x) => {
+const barHash = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((x) => {
 	"use gpu";
-	return __tsover_mul(__tsover_sub(std.fract(__tsover_mul(std.sin(__tsover_mul(x, 12.9898)), 43758.5453)), .5), 2);
+	return __tsover_mul(__tsover_sub(fract(__tsover_mul(sin(__tsover_mul(x, 12.9898)), 43758.5453)), .5), 2);
 }), {
 	v: 1,
 	name: void 0,
@@ -52,18 +52,18 @@ const barHash = tgpu.fn([d.f32], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TY
 		]]]],
 		"externalNames": ["std"]
 	},
-	externals: () => ({ std })
+	externals: () => ({ std: std_exports })
 }) && $.f)({}));
-const barSampleUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, offset) => {
+const barSampleUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angle, offset) => {
 	"use gpu";
 	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const cosA = std.cos(angleRad);
-	const sinA = std.sin(angleRad);
+	const cosA = cos(angleRad);
+	const sinA = sin(angleRad);
 	const au = __tsover_mul(uv.x, aspect);
 	const av = uv.y;
 	const cu = __tsover_sub(au, __tsover_mul(aspect, .5));
@@ -73,7 +73,7 @@ const barSampleUV = tgpu.fn([
 	const distPV = __tsover_add(projectedV, offset);
 	const dcu = __tsover_sub(__tsover_mul(projectedU, cosA), __tsover_mul(distPV, sinA));
 	const dcv = __tsover_add(__tsover_mul(projectedU, sinA), __tsover_mul(distPV, cosA));
-	return d.vec2f(__tsover_add(__tsover_div(dcu, aspect), .5), __tsover_add(dcv, .5));
+	return vec2f(__tsover_add(__tsover_div(dcu, aspect), .5), __tsover_add(dcv, .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -313,31 +313,30 @@ const barSampleUV = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
-const barShiftUV = tgpu.fn([
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((count, angle, intensity, seed, animTime, uv, aspect) => {
+const barShiftUV = src_default.fn([
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((count, angle, intensity, seed, animTime, uv, aspect) => {
 	"use gpu";
 	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const cosA = std.cos(angleRad);
-	const sinA = std.sin(angleRad);
-	const longestAxis = std.max(aspect, 1);
+	const cosA = cos(angleRad);
+	const sinA = sin(angleRad);
+	const longestAxis = max(aspect, 1);
 	const au = __tsover_mul(uv.x, aspect);
 	const av = uv.y;
 	const cu = __tsover_sub(au, __tsover_mul(aspect, .5));
 	const cv = __tsover_sub(av, .5);
 	const projectedU = __tsover_add(__tsover_mul(cu, cosA), __tsover_mul(cv, sinA));
-	const barCoord = __tsover_div(__tsover_mul(projectedU, count), longestAxis);
-	const barIndex = std.floor(barCoord);
+	const barIndex = floor(__tsover_div(__tsover_mul(projectedU, count), longestAxis));
 	const seedOffset = __tsover_mul(seed, .137);
 	const staticOffset = barHash(__tsover_add(barIndex, seedOffset));
 	const barSpeed = barHash(__tsover_add(__tsover_add(barIndex, seedOffset), 42.7));
@@ -616,7 +615,7 @@ const barShiftUV = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		barHash,
 		barSampleUV
 	})