shaders 3.1.463 → 3.2.464

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-/* shaders@3.1.463 CLI — npx shaders install-mcp. https://shaders.com */
+/* shaders@3.2.464 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.1.463"),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.2.464"),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-BwCxKNcQ.js

@@ -0,0 +1,44 @@
+import { s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { c as transformPosition } from "./transformations-CoIwF5JU.js";
+import { C as motionBlur, i as blurPath } from "./blurs-O1YbZEVw.js";
+const componentDefinition = defineStd({
+	name: "AngularBlur",
+	role: "filter",
+	species: "gather",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Blurs",
+	description: "Radial motion blur rotating around a center point",
+	props: {
+		intensity: {
+			default: 20,
+			description: "Intensity of the angular blur effect",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Blur Intensity",
+				group: "Effect"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: .5
+			},
+			transform: transformPosition,
+			description: "The center point of the rotation",
+			ui: {
+				type: "position",
+				label: "Center Position",
+				group: "Position"
+			}
+		}
+	},
+	effect: motionBlur({
+		path: blurPath.orbit(p("center")),
+		amount: p("intensity")
+	})
+});
+var AngularBlur_default = componentDefinition;
+export { componentDefinition as n, AngularBlur_default as t };

package/dist/core/Arc-BdSzj8aT.js

@@ -0,0 +1,45 @@
+import { t as defineStd } from "./lower-z2vuXP8M.js";
+import { x as mul } from "./math-BF-GBlb4.js";
+import { n as arc, t as APERTURE_TO_HALF_ANGLE } from "./shape-BMO1cLTt.js";
+const componentDefinition = defineStd({
+	role: "shape",
+	name: "Arc",
+	description: "Pie sector (arc wedge) with adjustable radius and aperture angle",
+	shape: {
+		distance: ({ x, y }, u) => arc(x, y, u("radius"), mul(u("aperture"), APERTURE_TO_HALF_ANGLE)),
+		colorDescription: "Fill color of the arc",
+		centerDescription: "Center position of the arc",
+		bounds: { size: {
+			width: "radius",
+			height: "radius"
+		} },
+		shapeProps: {
+			radius: {
+				default: .38,
+				description: "Radius of the pie sector",
+				ui: {
+					type: "range",
+					min: 0,
+					max: 1,
+					step: .01,
+					label: "Size",
+					group: "Shape"
+				}
+			},
+			aperture: {
+				default: 270,
+				description: "Aperture angle of the wedge in degrees (360 = full circle)",
+				ui: {
+					type: "range",
+					min: 0,
+					max: 360,
+					step: 1,
+					label: "Aperture",
+					group: "Shape"
+				}
+			}
+		}
+	}
+});
+var Arc_default = componentDefinition;
+export { componentDefinition as n, Arc_default as t };

package/dist/core/Ascii-3XAIw2Bb.js

@@ -0,0 +1,321 @@
+import { hr as f32, s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { a as glyphFor, i as charGrid, n as cellSample, o as glyphTint } from "./stylize-DuY5wWZo.js";
+import { t as createSwappableMediaTexture } from "./mediaLifecycle-DQg13y-f.js";
+import { n as createFontDependentRaster, r as createRasterInvalidator, t as createCanvasRasterTarget } from "./canvasRaster-Clio8jcl.js";
+import { i as transformBoolean } from "./transformations-CoIwF5JU.js";
+var ATLAS_TEXTURE_SIZE = 2048;
+var GOOGLE_FONTS_MAP = {
+	"JetBrains Mono": "JetBrains+Mono",
+	"Fira Code": "Fira+Code",
+	"Source Code Pro": "Source+Code+Pro",
+	"IBM Plex Mono": "IBM+Plex+Mono",
+	"Space Mono": "Space+Mono",
+	"Roboto Mono": "Roboto+Mono",
+	"Courier Prime": "Courier+Prime",
+	"Geist Mono": "Geist+Mono",
+	"VT323": "VT323",
+	"Press Start 2P": "Press+Start+2P",
+	"Silkscreen": "Silkscreen",
+	"Major Mono Display": "Major+Mono+Display",
+	"Syne Mono": "Syne+Mono",
+	"Nova Mono": "Nova+Mono",
+	"Xanh Mono": "Xanh+Mono",
+	"Cutive Mono": "Cutive+Mono",
+	"Share Tech Mono": "Share+Tech+Mono",
+	"Martian Mono": "Martian+Mono",
+	"Azeret Mono": "Azeret+Mono"
+};
+var loadedFonts = /* @__PURE__ */ new Set();
+async function loadAsciiFont(fontFamily) {
+	if (loadedFonts.has(fontFamily) || !GOOGLE_FONTS_MAP[fontFamily]) return;
+	const googleFontName = GOOGLE_FONTS_MAP[fontFamily];
+	if (!document.querySelector(`link[href*="${googleFontName}"]`)) {
+		const link = document.createElement("link");
+		link.rel = "stylesheet";
+		link.href = `https://fonts.googleapis.com/css2?family=${googleFontName}:wght@400&display=swap`;
+		document.head.appendChild(link);
+	}
+	try {
+		if (document.fonts && document.fonts.load) {
+			for (const spec of [
+				`400 12px "${fontFamily}"`,
+				`12px "${fontFamily}"`,
+				`400 12px ${fontFamily}`,
+				`12px ${fontFamily}`
+			]) try {
+				await document.fonts.load(spec);
+				break;
+			} catch {}
+			await new Promise((r) => setTimeout(r, 500));
+		} else await new Promise((r) => setTimeout(r, 1e3));
+		loadedFonts.add(fontFamily);
+	} catch {}
+}
+var num = (v, f) => typeof v === "number" ? v : f;
+var setupGlyphAtlas = (params) => {
+	const { getCpuValue, setExtraField } = params;
+	const glyphTex = createSwappableMediaTexture(params, {
+		label: "Ascii:atlas",
+		initial: {
+			width: ATLAS_TEXTURE_SIZE,
+			height: ATLAS_TEXTURE_SIZE
+		}
+	});
+	const target = createCanvasRasterTarget(params, { contextAttributes: { willReadFrequently: true } });
+	const buildAtlas = (characters, spacing, fontFamily) => {
+		if (glyphTex.disposed || !characters || characters.length === 0) return;
+		const charCount = characters.length;
+		const atlasSize = Math.max(2, Math.ceil(Math.sqrt(charCount)));
+		const baseAtlasCellSize = 128;
+		const spacingMultiplier = Math.max(1, 2 / spacing);
+		const actualCellSize = Math.min(baseAtlasCellSize * spacingMultiplier, ATLAS_TEXTURE_SIZE / atlasSize);
+		const fontSize = actualCellSize * .75;
+		const c = target.canvas() ? target.context() : target.resize(ATLAS_TEXTURE_SIZE, ATLAS_TEXTURE_SIZE);
+		if (!c) return;
+		c.clearRect(0, 0, ATLAS_TEXTURE_SIZE, ATLAS_TEXTURE_SIZE);
+		c.fillStyle = "#ffffff";
+		c.font = `${fontSize}px "${fontFamily}", ${fontFamily}, monospace`;
+		if (!c.font.includes(fontFamily) && !c.font.includes("IBM") && !c.font.includes("Plex")) c.font = `${fontSize}px ${fontFamily}, monospace`;
+		c.textAlign = "center";
+		c.textBaseline = "middle";
+		for (let i = 0; i < charCount; i++) {
+			const row = Math.floor(i / atlasSize);
+			const col = i % atlasSize;
+			c.fillText(characters[i], col * actualCellSize + actualCellSize / 2, row * actualCellSize + actualCellSize / 2);
+		}
+		glyphTex.write(target.canvas());
+		const uvScale = atlasSize * actualCellSize / ATLAS_TEXTURE_SIZE;
+		setExtraField("_charCount", charCount);
+		setExtraField("_atlasScale", uvScale);
+		setExtraField("_atlasSize", atlasSize);
+	};
+	const readProps = () => ({
+		characters: String(getCpuValue("characters") ?? componentDefinition.props.characters.default),
+		fontFamily: String(getCpuValue("fontFamily") ?? componentDefinition.props.fontFamily.default),
+		spacing: num(getCpuValue("spacing"), 1.5)
+	});
+	const rebuild = () => {
+		const p$1 = readProps();
+		buildAtlas(p$1.characters, p$1.spacing, p$1.fontFamily);
+	};
+	const font = createFontDependentRaster({
+		key: () => readProps().fontFamily,
+		load: () => loadAsciiFont(readProps().fontFamily),
+		onLoaded: rebuild
+	});
+	setTimeout(() => {
+		rebuild();
+		font.ensure();
+	}, 0);
+	createRasterInvalidator(params, {
+		key: () => {
+			const p$1 = readProps();
+			return `${p$1.characters}|${p$1.fontFamily}|${p$1.spacing}`;
+		},
+		run: () => {
+			rebuild();
+			font.ensure();
+		}
+	});
+	return glyphTex.kit;
+};
+var grid = charGrid({
+	cellSize: p("cellSize"),
+	spacing: p("spacing")
+});
+var cell = cellSample({ grid });
+const componentDefinition = defineStd({
+	name: "Ascii",
+	role: "filter",
+	species: "custom",
+	boundingBoxDeclaration: { aspectRatio: null },
+	category: "Stylize",
+	description: "Convert imagery to ASCII character art",
+	requiresRTT: true,
+	requiresChild: true,
+	extraFields: {
+		_charCount: {
+			schema: f32,
+			initial: 9
+		},
+		_atlasScale: {
+			schema: f32,
+			initial: 1
+		},
+		_atlasSize: {
+			schema: f32,
+			initial: 3
+		}
+	},
+	props: {
+		characters: {
+			default: "@%#*+=-:.",
+			description: "Characters ordered from dense to sparse. First character is used for bright areas, last for dark areas.",
+			ui: {
+				type: "text",
+				label: "Characters",
+				group: "Effect"
+			}
+		},
+		cellSize: {
+			default: 30,
+			description: "Size of each ASCII character cell (normalized to 1080p reference, scales proportionally at other resolutions)",
+			ui: {
+				type: "range",
+				min: 8,
+				max: 100,
+				step: 1,
+				label: "Cell Size",
+				group: "Effect"
+			}
+		},
+		fontFamily: {
+			default: "JetBrains Mono",
+			description: "Font family for characters",
+			ui: {
+				type: "select",
+				options: [
+					{
+						label: "Azeret Mono",
+						value: "Azeret Mono"
+					},
+					{
+						label: "Courier Prime",
+						value: "Courier Prime"
+					},
+					{
+						label: "Cutive Mono",
+						value: "Cutive Mono"
+					},
+					{
+						label: "Fira Code",
+						value: "Fira Code"
+					},
+					{
+						label: "Geist Mono",
+						value: "Geist Mono"
+					},
+					{
+						label: "IBM Plex Mono",
+						value: "IBM Plex Mono"
+					},
+					{
+						label: "JetBrains Mono",
+						value: "JetBrains Mono"
+					},
+					{
+						label: "Major Mono Display",
+						value: "Major Mono Display"
+					},
+					{
+						label: "Martian Mono",
+						value: "Martian Mono"
+					},
+					{
+						label: "Nova Mono",
+						value: "Nova Mono"
+					},
+					{
+						label: "Press Start 2P",
+						value: "Press Start 2P"
+					},
+					{
+						label: "Roboto Mono",
+						value: "Roboto Mono"
+					},
+					{
+						label: "Share Tech Mono",
+						value: "Share Tech Mono"
+					},
+					{
+						label: "Silkscreen",
+						value: "Silkscreen"
+					},
+					{
+						label: "Source Code Pro",
+						value: "Source Code Pro"
+					},
+					{
+						label: "Space Mono",
+						value: "Space Mono"
+					},
+					{
+						label: "Syne Mono",
+						value: "Syne Mono"
+					},
+					{
+						label: "VT323",
+						value: "VT323"
+					},
+					{
+						label: "Xanh Mono",
+						value: "Xanh Mono"
+					}
+				],
+				label: "Font Family",
+				group: "Font"
+			}
+		},
+		spacing: {
+			default: 1,
+			description: "Character size within each cell (1.0 = optimal size, 0.0 = smallest)",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Character Size",
+				group: "Effect"
+			},
+			transform: (value) => .1 + value * 1.4
+		},
+		gamma: {
+			default: 1,
+			description: "Brightness curve adjustment. <1 brightens darks (more light characters), >1 darkens midtones (more dark characters). Use to better fit characters to image brightness range.",
+			ui: {
+				type: ["range", "map"],
+				min: .25,
+				max: 3,
+				step: .01,
+				label: "Gamma",
+				group: "Effect"
+			}
+		},
+		alphaThreshold: {
+			default: 0,
+			description: "Pixels with alpha below this threshold become fully transparent.",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Alpha Threshold",
+				group: "Effect"
+			}
+		},
+		preserveAlpha: {
+			default: true,
+			description: "When enabled, output alpha matches input alpha. When disabled, pixels above the alpha threshold become fully opaque.",
+			ui: {
+				type: "checkbox",
+				label: "Preserve Alpha",
+				group: "Effect"
+			},
+			transform: transformBoolean
+		}
+	},
+	gpu: { fragment: glyphTint({
+		grid,
+		cell,
+		glyph: glyphFor({
+			grid,
+			cell,
+			gamma: p("gamma"),
+			atlas: setupGlyphAtlas
+		}),
+		alphaThreshold: p("alphaThreshold"),
+		preserveAlpha: p("preserveAlpha")
+	}) }
+});
+var Ascii_default = componentDefinition;
+export { componentDefinition as n, Ascii_default as t };

package/dist/core/Aurora-aZQ7Sgpi.js

@@ -0,0 +1,189 @@
+import { s as p, t as defineStd } from "./lower-z2vuXP8M.js";
+import { n as auroraGlow, r as colorLadder3, t as auroraField } from "./scenic-CJSExiX2.js";
+import { a as transformColor, c as transformPosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CoIwF5JU.js";
+const componentDefinition = defineStd({
+	name: "Aurora",
+	role: "generator",
+	boundingBoxDeclaration: {
+		aspectRatio: null,
+		supportsResizeFit: true
+	},
+	category: "Textures",
+	description: "Mesmerizing aurora borealis with layered curtains, vertical rays, and flowing light.",
+	acceptsUVContext: true,
+	animatedTime: { speed: "speed" },
+	props: {
+		colorA: {
+			default: "#a533f8",
+			transform: transformColor,
+			description: "Edge color at the curtain base",
+			ui: {
+				type: "color",
+				label: "Color A",
+				group: "Colors"
+			}
+		},
+		colorB: {
+			default: "#22ee88",
+			transform: transformColor,
+			description: "Core color in the bright center",
+			ui: {
+				type: "color",
+				label: "Color B",
+				group: "Colors"
+			}
+		},
+		colorC: {
+			default: "#1694e8",
+			transform: transformColor,
+			description: "Tip color at the ray ends",
+			ui: {
+				type: "color",
+				label: "Color C",
+				group: "Colors"
+			}
+		},
+		colorSpace: {
+			default: "linear",
+			transform: transformColorSpace,
+			compileTime: true,
+			description: "Color space for color interpolation",
+			ui: {
+				type: "select",
+				options: colorSpaceOptions,
+				label: "Color Space",
+				group: "Colors"
+			}
+		},
+		balance: {
+			default: 50,
+			description: "Shifts color distribution across the curtain height",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Balance",
+				group: "Colors"
+			}
+		},
+		intensity: {
+			default: 80,
+			description: "Overall aurora brightness",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Intensity",
+				group: "Aurora"
+			}
+		},
+		curtainCount: {
+			default: 4,
+			compileTime: true,
+			description: "Number of aurora curtain layers",
+			ui: {
+				type: "range",
+				min: 1,
+				max: 4,
+				step: 1,
+				label: "Curtains",
+				group: "Aurora"
+			}
+		},
+		speed: {
+			default: 5,
+			description: "Animation speed",
+			ui: {
+				type: "range",
+				min: -10,
+				max: 10,
+				step: .1,
+				label: "Speed",
+				group: "Aurora"
+			}
+		},
+		waviness: {
+			default: 50,
+			description: "How much the curtains undulate",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 200,
+				step: 1,
+				label: "Waviness",
+				group: "Aurora"
+			}
+		},
+		rayDensity: {
+			default: 20,
+			description: "Density of vertical ray structures",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Ray Detail",
+				group: "Aurora"
+			}
+		},
+		height: {
+			default: 120,
+			description: "How tall the aurora extends",
+			ui: {
+				type: ["range", "map"],
+				min: 10,
+				max: 200,
+				step: 1,
+				label: "Height",
+				group: "Scene"
+			}
+		},
+		center: {
+			default: {
+				x: .5,
+				y: 0
+			},
+			transform: transformPosition,
+			description: "Center position of the aurora",
+			ui: {
+				type: "position",
+				label: "Center",
+				group: "Scene"
+			}
+		},
+		seed: {
+			default: 0,
+			description: "Random seed for variation",
+			ui: {
+				type: ["range", "map"],
+				min: 0,
+				max: 100,
+				step: 1,
+				label: "Seed",
+				group: "Aurora"
+			}
+		}
+	},
+	paint: (params) => {
+		const f = auroraField({
+			seed: p("seed"),
+			waviness: p("waviness"),
+			rayDensity: p("rayDensity"),
+			height: p("height"),
+			center: p("center"),
+			balance: p("balance"),
+			intensity: p("intensity"),
+			curtainCount: p("curtainCount")
+		})(params);
+		return auroraGlow(colorLadder3({
+			a: p("colorA"),
+			b: p("colorB"),
+			c: p("colorC"),
+			space: p("colorSpace")
+		})(f.member("x"), f.member("y"), params), f.member("z"));
+	}
+});
+var Aurora_default = componentDefinition;
+export { componentDefinition as n, Aurora_default as t };