shaders 2.2.24 → 2.2.25

package/dist/core/index.js

@@ -1,1650 +1,2301 @@
-import { B as Nn, C as Vn, E as R, F as He, I as qn, L as Pn, M as S, N as ye, O as le, P as ln, R as Xn, T as Se, V as Yn, _ as l, b as W, c as In, d as j, g as Me, h as We, i as Hn, j as N, k as G, l as bn, m as je, n as y, o as Wn, s as jn, t as Qn, w as vn, x as de, z as Jn } from "./three.tsl-Btj1hLsf.js";
-import { n as re, t as he } from "./edges-CDzKsauJ.js";
-import { t as Jr } from "./time-DbRMw6Jm.js";
-import "./transformations-CsrIJXh-.js";
-import { n as Zn } from "./AngularBlur-ClvtyURQ.js";
-import { n as Kn } from "./Ascii-BT0-K_vw.js";
-import "./colorMixing--dhzx0ch.js";
-import { n as et } from "./Beam-BAKql1AP.js";
-import { n as nt } from "./Blob-CVSxhHJG.js";
-import { n as tt } from "./Blur-C1TTBHCX.js";
-import { n as rt } from "./Bulge-DV8tX-cw.js";
-import { n as ot } from "./ChannelBlur-BLZ9kBNA.js";
-import { n as it } from "./Checkerboard-DQ4Df3vm.js";
-import { n as at } from "./ChromaFlow-BggN1_Av.js";
-import { n as st } from "./ChromaticAberration-DlTaHNcp.js";
-import { n as lt } from "./Circle-B9ObWlq5.js";
-import { n as ct } from "./CRTScreen-VTJQoOeq.js";
-import { n as ft } from "./CursorTrail-C7QdUj8O.js";
-import { n as ut } from "./DiffuseBlur-Mx6LBsqz.js";
-import { n as mt } from "./Dither-CeIdV_9C.js";
-import { n as dt } from "./DotGrid-D6xUvYrt.js";
-import { n as ht } from "./Duotone-C2Pqt2gR.js";
-import { n as pt } from "./FilmGrain-CJ9n_fgk.js";
-import { n as gt } from "./FloatingParticles-iGtMs44K.js";
-import { n as bt } from "./GlassTiles-D_lVyag2.js";
-import { n as vt } from "./Glow-B0jj-6OC.js";
-import { n as Ct } from "./Godrays-DjLVuZa4.js";
-import "./TSLBase-Bt7Z4hv_.js";
-import "./ColorAdjustment-FeXXpypd.js";
-import { n as Rt } from "./Grayscale-BbsdDa_X.js";
-import { n as kt } from "./Grid-ByjU-_ua.js";
-import { n as Tt } from "./GridDistortion-C_eIlhkW.js";
-import { n as yt } from "./Group-CyaDLGpI.js";
-import { n as wt } from "./Halftone-BvuAe_k-.js";
-import { n as Ut } from "./HueShift-B_qE9c08.js";
-import { n as St } from "./ImageTexture-h00TFC1l.js";
-import { n as Mt } from "./Invert-BEDDB0sm.js";
-import { n as xt } from "./LinearBlur-CLKxuyeT.js";
-import { n as At } from "./LinearGradient-BPo8TX_M.js";
-import { n as Dt } from "./Liquify-DGkfeixZ.js";
-import { n as zt } from "./Pixelate-Bzy_7LnJ.js";
-import { n as Et } from "./PolarCoordinates-BUumPeTv.js";
-import { n as Ft } from "./Posterize-ggKIJlmm.js";
-import { n as $t } from "./ProgressiveBlur-D6_6T7SS.js";
-import { n as Ot } from "./RadialGradient-DEY9fRqa.js";
-import { n as Bt } from "./RectangularCoordinates-CZ-cFrCh.js";
-import { n as _t } from "./Ripples-BwNlcsnV.js";
-import { n as Lt } from "./Saturation-Dl3gCWuZ.js";
-import { n as Gt } from "./SimplexNoise-BhE_WyGt.js";
-import { n as Nt } from "./SineWave-Db_Y0Mcv.js";
-import { n as Vt } from "./SolidColor-CerOp4EQ.js";
-import { n as qt } from "./Spherize-Dh8E5XwG.js";
-import { n as Pt } from "./Spiral-BvygQEfP.js";
-import { n as Xt } from "./Strands-maaPn4On.js";
-import { n as Yt } from "./Stretch-CnA0-nSz.js";
-import { n as It } from "./Swirl-CQBUahTB.js";
-import { n as Ht } from "./TiltShift-qFj0oFzN.js";
-import { n as Wt } from "./Tritone-AiixmTg8.js";
-import { n as jt } from "./Twirl-ooHQcV89.js";
-import { n as Qt } from "./Vibrance-C2FRlLkK.js";
-import { n as Jt } from "./WaveDistortion-CN8MjKlm.js";
-import { n as Zt } from "./ZoomBlur-CxWGx8PH.js";
-import { WebGLRenderer as Kt } from "three";
-function er(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(n.rgb, t), l(e.rgb, l(e.a, R(1, t)))), u);
+import { n as applyEdgeToUV, t as applyEdgeHandling } from "./edges-Bn_OIa_h.js";
+import { t as createAnimatedTime } from "./time-CTJvRUZ4.js";
+import "./transformations-DxfQXZWi.js";
+import { n as componentDefinition } from "./AngularBlur-Dl2gwk68.js";
+import { n as componentDefinition$1 } from "./Ascii-Dha_QpT3.js";
+import "./colorMixing-BXiTAqJU.js";
+import { n as componentDefinition$2 } from "./Beam-CTN9Ni43.js";
+import { n as componentDefinition$3 } from "./Blob-CxFDZovO.js";
+import { n as componentDefinition$4 } from "./Blur-Y2FsmFk_.js";
+import { n as componentDefinition$5 } from "./Bulge-Cb-t0xqI.js";
+import { n as componentDefinition$6 } from "./ChannelBlur-CvM6GJgZ.js";
+import { n as componentDefinition$7 } from "./Checkerboard-CgB-egNY.js";
+import { n as componentDefinition$8 } from "./ChromaFlow-vRCwhQpN.js";
+import { n as componentDefinition$9 } from "./ChromaticAberration-FTquTQIL.js";
+import { n as componentDefinition$10 } from "./Circle-Daziv5d7.js";
+import { n as componentDefinition$11 } from "./CRTScreen-CtERsenz.js";
+import { n as componentDefinition$12 } from "./CursorTrail-Bsz9e6Fn.js";
+import { n as componentDefinition$13 } from "./DiffuseBlur-Cj2PtRNd.js";
+import { n as componentDefinition$14 } from "./Dither-D2Nf4p3w.js";
+import { n as componentDefinition$15 } from "./DotGrid-CzOwquo4.js";
+import { n as componentDefinition$16 } from "./Duotone-XuTN9tI7.js";
+import { n as componentDefinition$17 } from "./FilmGrain-D3-nbi12.js";
+import { n as componentDefinition$18 } from "./FloatingParticles-D9Nnu1qg.js";
+import { n as componentDefinition$19 } from "./GlassTiles-CnjCvajI.js";
+import { n as componentDefinition$20 } from "./Glow-BluFc9be.js";
+import { n as componentDefinition$21 } from "./Godrays-ChLh_vGl.js";
+import { n as componentDefinition$22 } from "./Grayscale-DRny75A9.js";
+import { n as componentDefinition$23 } from "./Grid-DgyDa4H1.js";
+import { n as componentDefinition$24 } from "./GridDistortion-BAspCYvp.js";
+import { n as componentDefinition$25 } from "./Group-Dul7PUBl.js";
+import { n as componentDefinition$26 } from "./Halftone-Ifv5F_FT.js";
+import { n as componentDefinition$27 } from "./HueShift-De8ukMWs.js";
+import { n as componentDefinition$28 } from "./ImageTexture-DvYcQgJB.js";
+import { n as componentDefinition$29 } from "./Invert-Fz0NtIJc.js";
+import { n as componentDefinition$30 } from "./LinearBlur-LmhnQoA4.js";
+import { n as componentDefinition$31 } from "./LinearGradient-xbloQjzt.js";
+import { n as componentDefinition$32 } from "./Liquify-DMe1V5-O.js";
+import { n as componentDefinition$33 } from "./Pixelate-Cv8537Pj.js";
+import { n as componentDefinition$34 } from "./PolarCoordinates-DDvDhBE-.js";
+import { n as componentDefinition$35 } from "./Posterize-3m3xkWOz.js";
+import { n as componentDefinition$36 } from "./ProgressiveBlur-EGkevObV.js";
+import { n as componentDefinition$37 } from "./RadialGradient-B7ZZB_VJ.js";
+import { n as componentDefinition$38 } from "./RectangularCoordinates-muWR8mZS.js";
+import { n as componentDefinition$39 } from "./Ripples-8XaZaXQF.js";
+import { n as componentDefinition$40 } from "./Saturation-CYFI1jzN.js";
+import { n as componentDefinition$41 } from "./SimplexNoise-DJUe0wz_.js";
+import { n as componentDefinition$42 } from "./SineWave-Dl3nFO1W.js";
+import { n as componentDefinition$43 } from "./SolidColor-CWGq_Bjq.js";
+import { n as componentDefinition$44 } from "./Spherize-C-jZEUsN.js";
+import { n as componentDefinition$45 } from "./Spiral-BSB_R39p.js";
+import { n as componentDefinition$46 } from "./Strands-0stO5BMy.js";
+import { n as componentDefinition$47 } from "./Stretch-B645paha.js";
+import { n as componentDefinition$48 } from "./Swirl-CVnbawit.js";
+import { n as componentDefinition$49 } from "./TiltShift-0CxNRI6L.js";
+import { n as componentDefinition$50 } from "./Tritone-Daa-I5UD.js";
+import { n as componentDefinition$51 } from "./Twirl-2CJVZEtk.js";
+import { n as componentDefinition$52 } from "./Vibrance-DRtecEvb.js";
+import { n as componentDefinition$53 } from "./WaveDistortion-BscXN2rs.js";
+import { n as componentDefinition$54 } from "./ZoomBlur-CAqK0Kju.js";
+import { Material, Mesh, MeshBasicNodeMaterial, OrthographicCamera, PlaneGeometry, SRGBColorSpace, Scene, WebGPURenderer } from "three/webgpu";
+import { WebGLRenderer } from "three";
+import * as TSL from "three/tsl";
+import { abs, add, atan, convertToTexture, cos, div, dot, float, max, min, mix, mul, pow, screenUV, sin, sqrt, step, sub, uniform, vec3, vec4, viewportSize } from "three/tsl";
+function normal_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(overlay.rgb, overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-var cn = (e) => N(e.x.mul(1.2249401).sub(e.y.mul(0.2249404)).sub(e.z.mul(0)), e.x.mul(-0.0420569).add(e.y.mul(1.0420571)).add(e.z.mul(0)), e.x.mul(-0.0196376).sub(e.y.mul(0.0786361)).add(e.z.mul(1.0982735))), nr = (e) => N(e.x.mul(0.8224621).add(e.y.mul(0.177538)).add(e.z.mul(0)), e.x.mul(0.0331941).add(e.y.mul(0.9668058)).add(e.z.mul(0)), e.x.mul(0.0170826).add(e.y.mul(0.0723974)).add(e.z.mul(0.9105199))), fn = (e) => {
-  const n = e.x, s = e.y, t = e.z, u = n.mul(0.4122214708).add(s.mul(0.5363325363)).add(t.mul(0.0514459929)), p = n.mul(0.2119034982).add(s.mul(0.6806995451).add(t.mul(0.1073969566))), h = n.mul(0.0883024619).add(s.mul(0.2817188376)).add(t.mul(0.6299787005)), d = W(u, j(1 / 3)), k = W(p, j(1 / 3)), U = W(h, j(1 / 3));
-  return N(d.mul(0.2104542553).add(k.mul(0.793617785)).sub(U.mul(0.0040720468)), d.mul(1.9779984951).sub(k.mul(2.428592205)).add(U.mul(0.4505937099)), d.mul(0.0259040371).add(k.mul(0.7827717662)).sub(U.mul(0.808675766)));
-}, tr = (e) => {
-  const n = e.x, s = e.y, t = e.z, u = n.add(s.mul(0.3963377774)).add(t.mul(0.2158037573)), p = n.sub(s.mul(0.1055613458)).sub(t.mul(0.0638541728)), h = n.sub(s.mul(0.0894841775)).sub(t.mul(1.291485548)), d = W(u, j(3)), k = W(p, j(3)), U = W(h, j(3));
-  return N(d.mul(4.0767416621).sub(k.mul(3.3077115913)).add(U.mul(0.2309699292)), d.mul(-1.2684380046).add(k.mul(2.6097574011)).sub(U.mul(0.3413193965)), d.mul(-0.0041960863).sub(k.mul(0.7034186147)).add(U.mul(1.707614701)));
-}, un = (e) => {
-  const n = e.x, s = e.y, t = e.z;
-  return N(n, vn(s.mul(s).add(t.mul(t))), Hn(t, s));
-}, rr = (e) => {
-  const n = e.x, s = e.y, t = e.z;
-  return N(n, s.mul(jn(t)), s.mul(Vn(t)));
+var p3ToSRGB$1 = (p3) => {
+	return vec3(p3.x.mul(1.2249401).sub(p3.y.mul(.2249404)).sub(p3.z.mul(0)), p3.x.mul(-.0420569).add(p3.y.mul(1.0420571)).add(p3.z.mul(0)), p3.x.mul(-.0196376).sub(p3.y.mul(.0786361)).add(p3.z.mul(1.0982735)));
 };
-function or(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t))), p = cn(N(e.r, e.g, e.b)), h = cn(N(n.r, n.g, n.b)), d = fn(p), k = fn(h), U = un(d);
-  return S(nr(tr(rr(y(l(un(k), t), l(U, l(e.a, R(1, t))))))), u);
+var sRGBToP3$1 = (srgb) => {
+	return vec3(srgb.x.mul(.8224621).add(srgb.y.mul(.177538)).add(srgb.z.mul(0)), srgb.x.mul(.0331941).add(srgb.y.mul(.9668058)).add(srgb.z.mul(0)), srgb.x.mul(.0170826).add(srgb.y.mul(.0723974)).add(srgb.z.mul(.9105199)));
+};
+var rgbToOklab$1 = (rgb) => {
+	const r = rgb.x;
+	const g = rgb.y;
+	const b = rgb.z;
+	const l = r.mul(.4122214708).add(g.mul(.5363325363)).add(b.mul(.0514459929));
+	const m = r.mul(.2119034982).add(g.mul(.6806995451).add(b.mul(.1073969566)));
+	const s = r.mul(.0883024619).add(g.mul(.2817188376)).add(b.mul(.6299787005));
+	const l_ = pow(l, float(1 / 3));
+	const m_ = pow(m, float(1 / 3));
+	const s_ = pow(s, float(1 / 3));
+	return vec3(l_.mul(.2104542553).add(m_.mul(.793617785)).sub(s_.mul(.0040720468)), l_.mul(1.9779984951).sub(m_.mul(2.428592205)).add(s_.mul(.4505937099)), l_.mul(.0259040371).add(m_.mul(.7827717662)).sub(s_.mul(.808675766)));
+};
+var oklabToRgb$1 = (lab) => {
+	const L = lab.x;
+	const a = lab.y;
+	const b = lab.z;
+	const l_ = L.add(a.mul(.3963377774)).add(b.mul(.2158037573));
+	const m_ = L.sub(a.mul(.1055613458)).sub(b.mul(.0638541728));
+	const s_ = L.sub(a.mul(.0894841775)).sub(b.mul(1.291485548));
+	const l = pow(l_, float(3));
+	const m = pow(m_, float(3));
+	const s = pow(s_, float(3));
+	return vec3(l.mul(4.0767416621).sub(m.mul(3.3077115913)).add(s.mul(.2309699292)), l.mul(-1.2684380046).add(m.mul(2.6097574011)).sub(s.mul(.3413193965)), l.mul(-.0041960863).sub(m.mul(.7034186147)).add(s.mul(1.707614701)));
+};
+var oklabToOklch = (lab) => {
+	const L = lab.x;
+	const a = lab.y;
+	const b = lab.z;
+	return vec3(L, sqrt(a.mul(a).add(b.mul(b))), atan(b, a));
+};
+var oklchToOklab = (lch) => {
+	const L = lch.x;
+	const C = lch.y;
+	const h = lch.z;
+	return vec3(L, C.mul(cos(h)), C.mul(sin(h)));
+};
+function normal_oklch_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	const baseSRGB = p3ToSRGB$1(vec3(base.r, base.g, base.b));
+	const overlaySRGB = p3ToSRGB$1(vec3(overlay.r, overlay.g, overlay.b));
+	const baseOklab = rgbToOklab$1(baseSRGB);
+	const overlayOklab = rgbToOklab$1(overlaySRGB);
+	const baseOklch = oklabToOklch(baseOklab);
+	return vec4(sRGBToP3$1(oklabToRgb$1(oklchToOklab(add(mul(oklabToOklch(overlayOklab), overlayAlpha), mul(baseOklch, mul(base.a, sub(1, overlayAlpha))))))), finalAlpha);
 }
-var mn = (e) => N(e.x.mul(1.2249401).sub(e.y.mul(0.2249404)).sub(e.z.mul(0)), e.x.mul(-0.0420569).add(e.y.mul(1.0420571)).add(e.z.mul(0)), e.x.mul(-0.0196376).sub(e.y.mul(0.0786361)).add(e.z.mul(1.0982735))), ir = (e) => N(e.x.mul(0.8224621).add(e.y.mul(0.177538)).add(e.z.mul(0)), e.x.mul(0.0331941).add(e.y.mul(0.9668058)).add(e.z.mul(0)), e.x.mul(0.0170826).add(e.y.mul(0.0723974)).add(e.z.mul(0.9105199))), dn = (e) => {
-  const n = e.x, s = e.y, t = e.z, u = n.mul(0.4122214708).add(s.mul(0.5363325363)).add(t.mul(0.0514459929)), p = n.mul(0.2119034982).add(s.mul(0.6806995451).add(t.mul(0.1073969566))), h = n.mul(0.0883024619).add(s.mul(0.2817188376)).add(t.mul(0.6299787005)), d = W(u, j(1 / 3)), k = W(p, j(1 / 3)), U = W(h, j(1 / 3));
-  return N(d.mul(0.2104542553).add(k.mul(0.793617785)).sub(U.mul(0.0040720468)), d.mul(1.9779984951).sub(k.mul(2.428592205)).add(U.mul(0.4505937099)), d.mul(0.0259040371).add(k.mul(0.7827717662)).sub(U.mul(0.808675766)));
-}, ar = (e) => {
-  const n = e.x, s = e.y, t = e.z, u = n.add(s.mul(0.3963377774)).add(t.mul(0.2158037573)), p = n.sub(s.mul(0.1055613458)).sub(t.mul(0.0638541728)), h = n.sub(s.mul(0.0894841775)).sub(t.mul(1.291485548)), d = W(u, j(3)), k = W(p, j(3)), U = W(h, j(3));
-  return N(d.mul(4.0767416621).sub(k.mul(3.3077115913)).add(U.mul(0.2309699292)), d.mul(-1.2684380046).add(k.mul(2.6097574011)).sub(U.mul(0.3413193965)), d.mul(-0.0041960863).sub(k.mul(0.7034186147)).add(U.mul(1.707614701)));
+var p3ToSRGB = (p3) => {
+	return vec3(p3.x.mul(1.2249401).sub(p3.y.mul(.2249404)).sub(p3.z.mul(0)), p3.x.mul(-.0420569).add(p3.y.mul(1.0420571)).add(p3.z.mul(0)), p3.x.mul(-.0196376).sub(p3.y.mul(.0786361)).add(p3.z.mul(1.0982735)));
+};
+var sRGBToP3 = (srgb) => {
+	return vec3(srgb.x.mul(.8224621).add(srgb.y.mul(.177538)).add(srgb.z.mul(0)), srgb.x.mul(.0331941).add(srgb.y.mul(.9668058)).add(srgb.z.mul(0)), srgb.x.mul(.0170826).add(srgb.y.mul(.0723974)).add(srgb.z.mul(.9105199)));
+};
+var rgbToOklab = (rgb) => {
+	const r = rgb.x;
+	const g = rgb.y;
+	const b = rgb.z;
+	const l = r.mul(.4122214708).add(g.mul(.5363325363)).add(b.mul(.0514459929));
+	const m = r.mul(.2119034982).add(g.mul(.6806995451).add(b.mul(.1073969566)));
+	const s = r.mul(.0883024619).add(g.mul(.2817188376)).add(b.mul(.6299787005));
+	const l_ = pow(l, float(1 / 3));
+	const m_ = pow(m, float(1 / 3));
+	const s_ = pow(s, float(1 / 3));
+	return vec3(l_.mul(.2104542553).add(m_.mul(.793617785)).sub(s_.mul(.0040720468)), l_.mul(1.9779984951).sub(m_.mul(2.428592205)).add(s_.mul(.4505937099)), l_.mul(.0259040371).add(m_.mul(.7827717662)).sub(s_.mul(.808675766)));
 };
-function sr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t))), p = mn(N(e.r, e.g, e.b)), h = mn(N(n.r, n.g, n.b)), d = dn(p);
-  return S(ir(ar(y(l(dn(h), t), l(d, l(e.a, R(1, t)))))), u);
+var oklabToRgb = (lab) => {
+	const L = lab.x;
+	const a = lab.y;
+	const b = lab.z;
+	const l_ = L.add(a.mul(.3963377774)).add(b.mul(.2158037573));
+	const m_ = L.sub(a.mul(.1055613458)).sub(b.mul(.0638541728));
+	const s_ = L.sub(a.mul(.0894841775)).sub(b.mul(1.291485548));
+	const l = pow(l_, float(3));
+	const m = pow(m_, float(3));
+	const s = pow(s_, float(3));
+	return vec3(l.mul(4.0767416621).sub(m.mul(3.3077115913)).add(s.mul(.2309699292)), l.mul(-1.2684380046).add(m.mul(2.6097574011)).sub(s.mul(.3413193965)), l.mul(-.0041960863).sub(m.mul(.7034186147)).add(s.mul(1.707614701)));
+};
+function normal_oklab_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	const baseSRGB = p3ToSRGB(vec3(base.r, base.g, base.b));
+	const overlaySRGB = p3ToSRGB(vec3(overlay.r, overlay.g, overlay.b));
+	const baseOklab = rgbToOklab(baseSRGB);
+	return vec4(sRGBToP3(oklabToRgb(add(mul(rgbToOklab(overlaySRGB), overlayAlpha), mul(baseOklab, mul(base.a, sub(1, overlayAlpha)))))), finalAlpha);
 }
-function lr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(l(e.rgb, n.rgb), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function multiply_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(mul(base.rgb, overlay.rgb), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function cr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(R(1, l(R(1, e.rgb), R(1, n.rgb))), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function screen_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(sub(1, mul(sub(1, base.rgb), sub(1, overlay.rgb))), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function fr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(We(y(e.rgb, n.rgb), 1), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function linearDodge_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(min(add(base.rgb, overlay.rgb), 1), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function ur(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(Me(l(2, l(e.rgb, n.rgb)), R(1, l(2, l(R(1, e.rgb), R(1, n.rgb)))), Se(0.5, e.rgb)), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function overlay_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(mix(mul(2, mul(base.rgb, overlay.rgb)), sub(1, mul(2, mul(sub(1, base.rgb), sub(1, overlay.rgb)))), step(.5, base.rgb)), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function mr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(Qn(R(e.rgb, n.rgb)), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function difference_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(abs(sub(base.rgb, overlay.rgb)), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function dr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(Me(e.rgb, We(In(e.rgb, R(1, n.rgb)), 1), Se(1e-3, R(1, n.rgb))), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function colorDodge_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(mix(base.rgb, min(div(base.rgb, sub(1, overlay.rgb)), 1), step(.001, sub(1, overlay.rgb))), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function hr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(R(y(e.rgb, n.rgb), l(2, l(e.rgb, n.rgb))), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function exclusion_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(sub(add(base.rgb, overlay.rgb), mul(2, mul(base.rgb, overlay.rgb))), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function oe(e) {
-  return y(y(l(e.r, 0.2126), l(e.g, 0.7152)), l(e.b, 0.0722));
+function getLuminance(rgb) {
+	return add(add(mul(rgb.r, .2126), mul(rgb.g, .7152)), mul(rgb.b, .0722));
 }
-function pr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t))), p = R(oe(e.rgb), oe(n.rgb));
-  return S(y(l(y(n.rgb, p), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function color_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	const lumDiff = sub(getLuminance(base.rgb), getLuminance(overlay.rgb));
+	return vec4(add(mul(add(overlay.rgb, lumDiff), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function gr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t))), p = oe(e.rgb), h = oe(n.rgb).div(y(p, 1e-4));
-  return S(y(l(l(e.rgb, h), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function luminosity_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	const baseLum = getLuminance(base.rgb);
+	const lumRatio = getLuminance(overlay.rgb).div(add(baseLum, 1e-4));
+	return vec4(add(mul(mul(base.rgb, lumRatio), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function br(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(We(e.rgb, n.rgb), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function darken_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(min(base.rgb, overlay.rgb), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function vr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(je(e.rgb, n.rgb), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function lighten_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(max(base.rgb, overlay.rgb), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function Cr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(Me(S(0, 0, 0, 1).rgb, je(R(1, R(1, e.rgb).div(y(n.rgb, 1e-4))), 0), Se(1e-4, n.rgb)), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function colorBurn_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(mix(vec4(0, 0, 0, 1).rgb, max(sub(1, sub(1, base.rgb).div(add(overlay.rgb, 1e-4))), 0), step(1e-4, overlay.rgb)), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function Rr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(je(y(y(e.rgb, n.rgb), -1), 0), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function linearBurn_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(max(add(add(base.rgb, overlay.rgb), -1), 0), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function kr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t))), p = y(l(2, l(e.rgb, n.rgb)), l(l(e.rgb, e.rgb), R(1, l(2, n.rgb)))), h = vn(e.rgb);
-  return S(y(l(Me(p, y(l(2, l(e.rgb, R(1, n.rgb))), l(h, R(l(2, n.rgb), 1))), Se(0.5, n.rgb)), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function softLight_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	const softLightDark = add(mul(2, mul(base.rgb, overlay.rgb)), mul(mul(base.rgb, base.rgb), sub(1, mul(2, overlay.rgb))));
+	const baseSqrt = sqrt(base.rgb);
+	return vec4(add(mul(mix(softLightDark, add(mul(2, mul(base.rgb, sub(1, overlay.rgb))), mul(baseSqrt, sub(mul(2, overlay.rgb), 1))), step(.5, overlay.rgb)), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function Tr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t)));
-  return S(y(l(Me(l(2, l(e.rgb, n.rgb)), R(1, l(2, l(R(1, e.rgb), R(1, n.rgb)))), Se(0.5, n.rgb)), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function hardLight_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	return vec4(add(mul(mix(mul(2, mul(base.rgb, overlay.rgb)), sub(1, mul(2, mul(sub(1, base.rgb), sub(1, overlay.rgb)))), step(.5, overlay.rgb)), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function yr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t))), p = oe(e.rgb), h = oe(n.rgb), d = e.rgb.sub(p), k = n.rgb.sub(h), U = d.length();
-  return S(y(l(y(l(k.normalize(), U), p), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function hue_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	const baseLum = getLuminance(base.rgb);
+	const overlayLum = getLuminance(overlay.rgb);
+	const baseChromaticity = base.rgb.sub(baseLum);
+	const overlayChromaticity = overlay.rgb.sub(overlayLum);
+	const baseChromaLength = baseChromaticity.length();
+	return vec4(add(mul(add(mul(overlayChromaticity.normalize(), baseChromaLength), baseLum), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-function wr(e, n, s = 1) {
-  const t = l(n.a, s), u = y(t, l(e.a, R(1, t))), p = oe(e.rgb), h = oe(n.rgb), d = e.rgb.sub(p), k = n.rgb.sub(h);
-  return S(y(l(y(l(d.normalize(), k.length()), p), t), l(e.rgb, l(e.a, R(1, t)))), u);
+function saturation_default(base, overlay, opacity = 1) {
+	const overlayAlpha = mul(overlay.a, opacity);
+	const finalAlpha = add(overlayAlpha, mul(base.a, sub(1, overlayAlpha)));
+	const baseLum = getLuminance(base.rgb);
+	const overlayLum = getLuminance(overlay.rgb);
+	const baseChromaticity = base.rgb.sub(baseLum);
+	const overlayChromaticity = overlay.rgb.sub(overlayLum);
+	return vec4(add(mul(add(mul(baseChromaticity.normalize(), overlayChromaticity.length()), baseLum), overlayAlpha), mul(base.rgb, mul(base.a, sub(1, overlayAlpha)))), finalAlpha);
 }
-var hn = {
-  normal: er,
-  "normal-oklch": or,
-  "normal-oklab": sr,
-  multiply: lr,
-  screen: cr,
-  linearDodge: fr,
-  overlay: ur,
-  difference: mr,
-  colorDodge: dr,
-  exclusion: hr,
-  color: pr,
-  luminosity: gr,
-  darken: br,
-  lighten: vr,
-  colorBurn: Cr,
-  linearBurn: Rr,
-  softLight: kr,
-  hardLight: Tr,
-  hue: yr,
-  saturation: wr
+var blendModes = {
+	normal: normal_default,
+	"normal-oklch": normal_oklch_default,
+	"normal-oklab": normal_oklab_default,
+	multiply: multiply_default,
+	screen: screen_default,
+	linearDodge: linearDodge_default,
+	overlay: overlay_default,
+	difference: difference_default,
+	colorDodge: colorDodge_default,
+	exclusion: exclusion_default,
+	color: color_default,
+	luminosity: luminosity_default,
+	darken: darken_default,
+	lighten: lighten_default,
+	colorBurn: colorBurn_default,
+	linearBurn: linearBurn_default,
+	softLight: softLight_default,
+	hardLight: hardLight_default,
+	hue: hue_default,
+	saturation: saturation_default
 };
-function H(e, n, s = "normal", t = 1) {
-  return (hn[s] || hn.normal)(e, n, t);
+function applyBlendMode(baseNode, overlayNode, blendMode = "normal", opacity = 1) {
+	return (blendModes[blendMode] || blendModes.normal)(baseNode, overlayNode, opacity);
 }
-function Ur(e, n) {
-  const s = l(e.a, n.a);
-  return S(e.rgb, s);
+function alpha_default(target, mask) {
+	const maskedAlpha = mul(target.a, mask.a);
+	return vec4(target.rgb, maskedAlpha);
 }
-function Sr(e, n) {
-  const s = R(1, n.a), t = l(e.a, s);
-  return S(e.rgb, t);
+function alphaInverted_default(target, mask) {
+	const invertedMaskAlpha = sub(1, mask.a);
+	const maskedAlpha = mul(target.a, invertedMaskAlpha);
+	return vec4(target.rgb, maskedAlpha);
 }
-function Mr(e, n) {
-  const s = N(0.2126, 0.7152, 0.0722), t = bn(n.rgb, s), u = l(e.a, t);
-  return S(e.rgb, u);
+function luminance_default(target, mask) {
+	const luminanceWeights = vec3(.2126, .7152, .0722);
+	const luminance = dot(mask.rgb, luminanceWeights);
+	const maskedAlpha = mul(target.a, luminance);
+	return vec4(target.rgb, maskedAlpha);
 }
-function xr(e, n) {
-  const s = N(0.2126, 0.7152, 0.0722), t = R(1, bn(n.rgb, s)), u = l(e.a, t);
-  return S(e.rgb, u);
+function luminanceInverted_default(target, mask) {
+	const luminanceWeights = vec3(.2126, .7152, .0722);
+	const invertedLuminance = sub(1, dot(mask.rgb, luminanceWeights));
+	const maskedAlpha = mul(target.a, invertedLuminance);
+	return vec4(target.rgb, maskedAlpha);
 }
-var pn = {
-  alpha: Ur,
-  alphaInverted: Sr,
-  luminance: Mr,
-  luminanceInverted: xr
+var maskFunctions = {
+	"alpha": alpha_default,
+	"alphaInverted": alphaInverted_default,
+	"luminance": luminance_default,
+	"luminanceInverted": luminanceInverted_default
 };
-function Ar(e, n, s = "alpha") {
-  return (pn[s] || pn.alpha)(e, n);
+function applyMask(target, mask, maskType = "alpha") {
+	return (maskFunctions[maskType] || maskFunctions["alpha"])(target, mask);
 }
-var Dr = class {
-  frameTimesMs = [];
-  maxSamples = 60;
-  targetFrameTime = 16.67;
-  jankFrameCount = 0;
-  totalFrameCount = 0;
-  memorySnapshots = [];
-  memoryWindowMs = 5e3;
-  nodeCount = 0;
-  rttNodeCount = 0;
-  lastCpuTime = null;
-  lastGpuTime = null;
-  isRendering = !1;
-  lastFrameTimestamp = 0;
-  frameIntervals = [];
-  /**
-  * Records a frame's render time
-  */
-  recordFrame(e) {
-    this.frameTimesMs.push(e), this.frameTimesMs.length > this.maxSamples && this.frameTimesMs.shift(), this.totalFrameCount++, e > this.targetFrameTime && this.jankFrameCount++;
-    const n = performance.now();
-    if (this.lastFrameTimestamp > 0) {
-      const s = n - this.lastFrameTimestamp;
-      this.frameIntervals.push(s), this.frameIntervals.length > this.maxSamples && this.frameIntervals.shift();
-    }
-    this.lastFrameTimestamp = n, this.recordMemorySnapshot();
-  }
-  /**
-  * Records CPU time for the last frame
-  */
-  recordCpuTime(e) {
-    this.lastCpuTime = e;
-  }
-  /**
-  * Records GPU time for the last frame
-  */
-  recordGpuTime(e) {
-    this.lastGpuTime = e;
-  }
-  /**
-  * Updates node counts for complexity calculation
-  */
-  updateNodeCounts(e, n) {
-    this.nodeCount = e, this.rttNodeCount = n;
-  }
-  /**
-  * Sets rendering state
-  */
-  setRendering(e) {
-    this.isRendering = e;
-  }
-  /**
-  * Records a memory snapshot for growth rate calculation
-  */
-  recordMemorySnapshot() {
-    if (!performance.memory) return;
-    const e = performance.now(), n = performance.memory.usedJSHeapSize;
-    this.memorySnapshots.push({
-      time: e,
-      bytes: n
-    });
-    const s = e - this.memoryWindowMs;
-    this.memorySnapshots = this.memorySnapshots.filter((t) => t.time > s);
-  }
-  /**
-  * Calculates memory growth rate in MB/sec
-  */
-  calculateMemoryGrowthRate() {
-    if (this.memorySnapshots.length < 2) return null;
-    const e = this.memorySnapshots[0], n = this.memorySnapshots[this.memorySnapshots.length - 1], s = (n.time - e.time) / 1e3;
-    return (n.bytes - e.bytes) / (1024 * 1024) / s;
-  }
-  /**
-  * Calculates standard deviation of frame times
-  */
-  calculateStdDev(e) {
-    if (e.length === 0) return 0;
-    const n = e.reduce((t, u) => t + u, 0) / e.length, s = e.map((t) => Math.pow(t - n, 2)).reduce((t, u) => t + u, 0) / e.length;
-    return Math.sqrt(s);
-  }
-  /**
-  * Calculates 99th percentile frame time
-  */
-  calculateP99(e) {
-    if (e.length === 0) return 0;
-    const n = [...e].sort((t, u) => t - u), s = Math.floor(n.length * 0.99);
-    return n[Math.min(s, n.length - 1)];
-  }
-  /**
-  * Calculates complexity score based on node structure
-  * RTT nodes are 10x more expensive than regular nodes
-  */
-  calculateComplexityScore() {
-    return this.nodeCount + this.rttNodeCount * 10;
-  }
-  /**
-  * Calculates normalized intensity score (0-100) for "average machine" estimation
-  * Combines frame time, complexity, and GPU time into single metric
-  *
-  * Scoring:
-  * - 0-20: Very Light (simple effects, <5ms)
-  * - 21-40: Light (basic effects, 5-8ms)
-  * - 41-60: Medium (moderate effects, 8-12ms)
-  * - 61-80: Heavy (complex effects, 12-15ms)
-  * - 81-100: Very Heavy (intensive effects, >15ms)
-  */
-  calculateIntensityScore() {
-    const e = this.frameTimesMs.length;
-    if (e === 0) return {
-      score: 0,
-      label: "N/A"
-    };
-    const n = this.frameTimesMs.reduce((U, B) => U + B, 0) / e, s = Math.min(n / 16.67 * 100, 100), t = this.calculateComplexityScore(), u = Math.min(t / 100 * 100, 100);
-    let p = 0;
-    this.lastGpuTime !== null && (p = Math.min(this.lastGpuTime / 16.67 * 100, 100));
-    const h = this.lastGpuTime !== null ? {
-      frame: 0.4,
-      gpu: 0.4,
-      complexity: 0.2
-    } : {
-      frame: 0.7,
-      gpu: 0,
-      complexity: 0.3
-    }, d = Math.round(s * h.frame + p * h.gpu + u * h.complexity);
-    let k;
-    return d <= 20 ? k = "Very Light" : d <= 40 ? k = "Light" : d <= 60 ? k = "Medium" : d <= 80 ? k = "Heavy" : k = "Very Heavy", {
-      score: Math.min(d, 100),
-      label: k
-    };
-  }
-  /**
-  * Gets current performance statistics
-  */
-  getStats(e) {
-    const n = this.frameTimesMs.length, s = this.frameIntervals.length > 0 ? 1e3 / (this.frameIntervals.reduce((z, E) => z + E, 0) / this.frameIntervals.length) : 0, t = n > 0 ? this.frameTimesMs.reduce((z, E) => z + E, 0) / n : 0, u = n > 0 ? Math.min(...this.frameTimesMs) : 0, p = n > 0 ? Math.max(...this.frameTimesMs) : 0, h = this.calculateP99(this.frameTimesMs), d = this.calculateStdDev(this.frameTimesMs), k = this.totalFrameCount > 0 ? this.jankFrameCount / this.totalFrameCount * 100 : 0, U = performance.memory, B = U ? U.usedJSHeapSize / (1024 * 1024) : null, O = this.calculateMemoryGrowthRate(), Q = t > 0 ? t / this.targetFrameTime * 100 : 0, V = e?.render?.calls ?? null, q = e?.programs?.length ?? null, ce = e?.memory?.textures ?? null, ie = this.calculateIntensityScore();
-    return {
-      fps: Math.round(s),
-      avgFrameTime: Math.round(t * 100) / 100,
-      minFrameTime: Math.round(u * 100) / 100,
-      maxFrameTime: Math.round(p * 100) / 100,
-      p99FrameTime: Math.round(h * 100) / 100,
-      stdDevFrameTime: Math.round(d * 100) / 100,
-      jankCount: this.jankFrameCount,
-      jankPercent: Math.round(k * 10) / 10,
-      nodeCount: this.nodeCount,
-      rttNodeCount: this.rttNodeCount,
-      complexityScore: this.calculateComplexityScore(),
-      memoryUsedMB: B !== null ? Math.round(B * 100) / 100 : null,
-      memoryGrowthRate: O !== null ? Math.round(O * 1e3) / 1e3 : null,
-      cpuTime: this.lastCpuTime !== null ? Math.round(this.lastCpuTime * 100) / 100 : null,
-      gpuTime: this.lastGpuTime !== null ? Math.round(this.lastGpuTime * 100) / 100 : null,
-      budgetUsed: Math.round(Q * 10) / 10,
-      drawCalls: V,
-      shaderPrograms: q,
-      textureCount: ce,
-      intensityScore: ie.score,
-      intensityLabel: ie.label,
-      isRendering: this.isRendering
-    };
-  }
-  /**
-  * Resets all statistics
-  */
-  reset() {
-    this.frameTimesMs = [], this.frameIntervals = [], this.lastFrameTimestamp = 0, this.jankFrameCount = 0, this.totalFrameCount = 0, this.memorySnapshots = [], this.lastCpuTime = null, this.lastGpuTime = null;
-  }
-}, { vec2: we, cos: zr, sin: Er, float: Fr, PI: $r } = le;
-const ne = (e) => e ? e.offsetX !== 0 || e.offsetY !== 0 || e.rotation !== 0 || e.scale !== 1 || e.anchorX !== 0.5 || e.anchorY !== 0.5 : !1, Ue = (e, n, s, t, u, p, h, d) => {
-  const k = t.mul($r).div(Fr(180)), U = zr(k), B = Er(k), O = we(p, h), Q = e.sub(O).div(u), V = we(Q.x.mul(d), Q.y), q = we(V.x.mul(U).sub(V.y.mul(B)), V.x.mul(B).add(V.y.mul(U)));
-  return we(q.x.div(d), q.y).sub(we(n, s)).add(O);
+var PerformanceTracker = class {
+	frameTimesMs = [];
+	maxSamples = 60;
+	targetFrameTime = 16.67;
+	jankFrameCount = 0;
+	totalFrameCount = 0;
+	memorySnapshots = [];
+	memoryWindowMs = 5e3;
+	nodeCount = 0;
+	rttNodeCount = 0;
+	lastCpuTime = null;
+	lastGpuTime = null;
+	isRendering = false;
+	lastFrameTimestamp = 0;
+	frameIntervals = [];
+	recordFrame(frameTimeMs) {
+		this.frameTimesMs.push(frameTimeMs);
+		if (this.frameTimesMs.length > this.maxSamples) this.frameTimesMs.shift();
+		this.totalFrameCount++;
+		if (frameTimeMs > this.targetFrameTime) this.jankFrameCount++;
+		const now = performance.now();
+		if (this.lastFrameTimestamp > 0) {
+			const interval = now - this.lastFrameTimestamp;
+			this.frameIntervals.push(interval);
+			if (this.frameIntervals.length > this.maxSamples) this.frameIntervals.shift();
+		}
+		this.lastFrameTimestamp = now;
+		this.recordMemorySnapshot();
+	}
+	recordCpuTime(timeMs) {
+		this.lastCpuTime = timeMs;
+	}
+	recordGpuTime(timeMs) {
+		this.lastGpuTime = timeMs;
+	}
+	updateNodeCounts(nodeCount, rttNodeCount) {
+		this.nodeCount = nodeCount;
+		this.rttNodeCount = rttNodeCount;
+	}
+	setRendering(rendering) {
+		this.isRendering = rendering;
+	}
+	recordMemorySnapshot() {
+		if (!performance.memory) return;
+		const now = performance.now();
+		const bytes = performance.memory.usedJSHeapSize;
+		this.memorySnapshots.push({
+			time: now,
+			bytes
+		});
+		const cutoff = now - this.memoryWindowMs;
+		this.memorySnapshots = this.memorySnapshots.filter((s) => s.time > cutoff);
+	}
+	calculateMemoryGrowthRate() {
+		if (this.memorySnapshots.length < 2) return null;
+		const oldest = this.memorySnapshots[0];
+		const newest = this.memorySnapshots[this.memorySnapshots.length - 1];
+		const timeDeltaSeconds = (newest.time - oldest.time) / 1e3;
+		return (newest.bytes - oldest.bytes) / (1024 * 1024) / timeDeltaSeconds;
+	}
+	calculateStdDev(values) {
+		if (values.length === 0) return 0;
+		const mean = values.reduce((a, b) => a + b, 0) / values.length;
+		const avgSquaredDiff = values.map((v) => Math.pow(v - mean, 2)).reduce((a, b) => a + b, 0) / values.length;
+		return Math.sqrt(avgSquaredDiff);
+	}
+	calculateP99(values) {
+		if (values.length === 0) return 0;
+		const sorted = [...values].sort((a, b) => a - b);
+		const index = Math.floor(sorted.length * .99);
+		return sorted[Math.min(index, sorted.length - 1)];
+	}
+	calculateComplexityScore() {
+		return this.nodeCount + this.rttNodeCount * 10;
+	}
+	calculateIntensityScore() {
+		const frameCount = this.frameTimesMs.length;
+		if (frameCount === 0) return {
+			score: 0,
+			label: "N/A"
+		};
+		const avgFrameTime = this.frameTimesMs.reduce((a, b) => a + b, 0) / frameCount;
+		const frameTimeScore = Math.min(avgFrameTime / 16.67 * 100, 100);
+		const complexity = this.calculateComplexityScore();
+		const complexityScore = Math.min(complexity / 100 * 100, 100);
+		let gpuTimeScore = 0;
+		if (this.lastGpuTime !== null) gpuTimeScore = Math.min(this.lastGpuTime / 16.67 * 100, 100);
+		const weights = this.lastGpuTime !== null ? {
+			frame: .4,
+			gpu: .4,
+			complexity: .2
+		} : {
+			frame: .7,
+			gpu: 0,
+			complexity: .3
+		};
+		const finalScore = Math.round(frameTimeScore * weights.frame + gpuTimeScore * weights.gpu + complexityScore * weights.complexity);
+		let label;
+		if (finalScore <= 20) label = "Very Light";
+		else if (finalScore <= 40) label = "Light";
+		else if (finalScore <= 60) label = "Medium";
+		else if (finalScore <= 80) label = "Heavy";
+		else label = "Very Heavy";
+		return {
+			score: Math.min(finalScore, 100),
+			label
+		};
+	}
+	getStats(rendererInfo) {
+		const frameCount = this.frameTimesMs.length;
+		const fps = this.frameIntervals.length > 0 ? 1e3 / (this.frameIntervals.reduce((a, b) => a + b, 0) / this.frameIntervals.length) : 0;
+		const avgFrameTime = frameCount > 0 ? this.frameTimesMs.reduce((a, b) => a + b, 0) / frameCount : 0;
+		const minFrameTime = frameCount > 0 ? Math.min(...this.frameTimesMs) : 0;
+		const maxFrameTime = frameCount > 0 ? Math.max(...this.frameTimesMs) : 0;
+		const p99FrameTime = this.calculateP99(this.frameTimesMs);
+		const stdDevFrameTime = this.calculateStdDev(this.frameTimesMs);
+		const jankPercent = this.totalFrameCount > 0 ? this.jankFrameCount / this.totalFrameCount * 100 : 0;
+		const memory = performance.memory;
+		const memoryUsedMB = memory ? memory.usedJSHeapSize / (1024 * 1024) : null;
+		const memoryGrowthRate = this.calculateMemoryGrowthRate();
+		const budgetUsed = avgFrameTime > 0 ? avgFrameTime / this.targetFrameTime * 100 : 0;
+		const drawCalls = rendererInfo?.render?.calls ?? null;
+		const shaderPrograms = rendererInfo?.programs?.length ?? null;
+		const textureCount = rendererInfo?.memory?.textures ?? null;
+		const intensity = this.calculateIntensityScore();
+		return {
+			fps: Math.round(fps),
+			avgFrameTime: Math.round(avgFrameTime * 100) / 100,
+			minFrameTime: Math.round(minFrameTime * 100) / 100,
+			maxFrameTime: Math.round(maxFrameTime * 100) / 100,
+			p99FrameTime: Math.round(p99FrameTime * 100) / 100,
+			stdDevFrameTime: Math.round(stdDevFrameTime * 100) / 100,
+			jankCount: this.jankFrameCount,
+			jankPercent: Math.round(jankPercent * 10) / 10,
+			nodeCount: this.nodeCount,
+			rttNodeCount: this.rttNodeCount,
+			complexityScore: this.calculateComplexityScore(),
+			memoryUsedMB: memoryUsedMB !== null ? Math.round(memoryUsedMB * 100) / 100 : null,
+			memoryGrowthRate: memoryGrowthRate !== null ? Math.round(memoryGrowthRate * 1e3) / 1e3 : null,
+			cpuTime: this.lastCpuTime !== null ? Math.round(this.lastCpuTime * 100) / 100 : null,
+			gpuTime: this.lastGpuTime !== null ? Math.round(this.lastGpuTime * 100) / 100 : null,
+			budgetUsed: Math.round(budgetUsed * 10) / 10,
+			drawCalls,
+			shaderPrograms,
+			textureCount,
+			intensityScore: intensity.score,
+			intensityLabel: intensity.label,
+			isRendering: this.isRendering
+		};
+	}
+	reset() {
+		this.frameTimesMs = [];
+		this.frameIntervals = [];
+		this.lastFrameTimestamp = 0;
+		this.jankFrameCount = 0;
+		this.totalFrameCount = 0;
+		this.memorySnapshots = [];
+		this.lastCpuTime = null;
+		this.lastGpuTime = null;
+	}
+};
+var { vec2: vec2$3, cos: cos$1, sin: sin$2, float: float$1, PI } = TSL;
+const needsTransformation = (transform) => {
+	if (!transform) return false;
+	return transform.offsetX !== 0 || transform.offsetY !== 0 || transform.rotation !== 0 || transform.scale !== 1 || transform.anchorX !== .5 || transform.anchorY !== .5;
+};
+const applyUVTransform = (uv, offsetXUniform, offsetYUniform, rotationUniform, scaleUniform, anchorXUniform, anchorYUniform, aspectRatioUniform) => {
+	const rotationRad = rotationUniform.mul(PI).div(float$1(180));
+	const cosAngle = cos$1(rotationRad);
+	const sinAngle = sin$2(rotationRad);
+	const anchor = vec2$3(anchorXUniform, anchorYUniform);
+	const scaledUV = uv.sub(anchor).div(scaleUniform);
+	const squareUV = vec2$3(scaledUV.x.mul(aspectRatioUniform), scaledUV.y);
+	const rotatedSquareUV = vec2$3(squareUV.x.mul(cosAngle).sub(squareUV.y.mul(sinAngle)), squareUV.x.mul(sinAngle).add(squareUV.y.mul(cosAngle)));
+	return vec2$3(rotatedSquareUV.x.div(aspectRatioUniform), rotatedSquareUV.y).sub(vec2$3(offsetXUniform, offsetYUniform)).add(anchor);
 };
-var { uniform: Or } = le;
-function ii(e, n, s) {
-  const t = {};
-  return Object.entries(e.props).forEach(([u, p]) => {
-    const h = n[u];
-    let d = h;
-    if (p.transform) {
-      const U = p.transform(h);
-      d = U?.node ?? U;
-    }
-    if (d == null && (d = p.default, p.transform && d !== null && d !== void 0)) {
-      const U = p.transform(d);
-      d = U?.node ?? U;
-    }
-    d == null && (console.error(`[Shaders] Uniform "${u}" is null/undefined after fallback. PropConfig:`, {
-      propName: u,
-      initialValue: h,
-      default: p.default,
-      hasTransform: !!p.transform
-    }), d = 0);
-    const k = Or(d).setName(`${u}_${s}`);
-    typeof d == "string" && k.value === null && (k.value = d), t[u] = {
-      uniform: k,
-      transform: p.transform || void 0
-    };
-  }), t;
+var { uniform: uniform$1 } = TSL;
+function createUniformsMap(component, reactiveProps, instanceId) {
+	const uniformsMap = {};
+	Object.entries(component.props).forEach(([propName, propConfig]) => {
+		const initialValue = reactiveProps[propName];
+		let uniformValue = initialValue;
+		if (propConfig.transform) {
+			const transformed = propConfig.transform(initialValue);
+			uniformValue = transformed?.node ?? transformed;
+		}
+		if (uniformValue === null || uniformValue === void 0) {
+			uniformValue = propConfig.default;
+			if (propConfig.transform && uniformValue !== null && uniformValue !== void 0) {
+				const transformed = propConfig.transform(uniformValue);
+				uniformValue = transformed?.node ?? transformed;
+			}
+		}
+		if (uniformValue === null || uniformValue === void 0) {
+			console.error(`[Shaders] Uniform "${propName}" is null/undefined after fallback. PropConfig:`, {
+				propName,
+				initialValue,
+				default: propConfig.default,
+				hasTransform: !!propConfig.transform
+			});
+			uniformValue = 0;
+		}
+		const uniformNode = uniform$1(uniformValue).setName(`${propName}_${instanceId}`);
+		if (typeof uniformValue === "string" && uniformNode.value === null) uniformNode.value = uniformValue;
+		uniformsMap[propName] = {
+			uniform: uniformNode,
+			transform: propConfig.transform || void 0
+		};
+	});
+	return uniformsMap;
 }
-function Br(e, n) {
-  if (e?.transform) {
-    const s = e.transform(n), t = s?.data ?? s;
-    e.uniform.value = t;
-  } else e.uniform.value = n;
+function updateUniformValue(uniform$2, newValue) {
+	if (uniform$2?.transform) {
+		const transformed = uniform$2.transform(newValue);
+		const dataValue = transformed?.data ?? transformed;
+		uniform$2.uniform.value = dataValue;
+	} else uniform$2.uniform.value = newValue;
 }
-var gn = !1, _r = /* @__PURE__ */ (() => {
-  let e = 0;
-  const n = /* @__PURE__ */ new Set(), s = (h) => {
-    n.forEach((d) => {
-      try {
-        d.onMouseMove(h);
-      } catch (k) {
-        console.error("[Shaders] Error in mouse move handler:", k);
-      }
-    });
-  }, t = (h) => {
-    n.forEach((d) => {
-      try {
-        d.onTouchMove(h);
-      } catch (k) {
-        console.error("[Shaders] Error in touch move handler:", k);
-      }
-    });
-  }, u = () => {
-    n.forEach((h) => {
-      try {
-        h.onMouseUp();
-      } catch (d) {
-        console.error("[Shaders] Error in mouse up handler:", d);
-      }
-    });
-  }, p = () => {
-    n.forEach((h) => {
-      try {
-        h.onTouchEnd();
-      } catch (d) {
-        console.error("[Shaders] Error in touch end handler:", d);
-      }
-    });
-  };
-  return { register(h) {
-    return n.add(h), e++, e === 1 && (window.addEventListener("mousemove", s), window.addEventListener("touchmove", t), window.addEventListener("mouseup", u), window.addEventListener("touchend", p)), () => {
-      n.delete(h), e--, e === 0 && (window.removeEventListener("mousemove", s), window.removeEventListener("touchmove", t), window.removeEventListener("mouseup", u), window.removeEventListener("touchend", p));
-    };
-  } };
-})(), Lr = () => {
-  try {
-    {
-      const { MODE: e, DEV: n } = {
-        DEV: !1,
-        MODE: "production"
-      };
-      return n || e === "development";
-    }
-    if (typeof window < "u" && window.location) {
-      const e = window.location.hostname;
-      return e === "localhost" || e === "127.0.0.1" || e.endsWith(".local") || e.includes("dev.") || e.startsWith("dev-");
-    }
-    return !1;
-  } catch {
-    return !1;
-  }
+var hasLoggedLicenseInfo = false;
+var globalEventManager = (() => {
+	let instanceCount = 0;
+	const callbacks = /* @__PURE__ */ new Set();
+	const globalMouseMoveHandler = (e) => {
+		callbacks.forEach((cb) => {
+			try {
+				cb.onMouseMove(e);
+			} catch (error) {
+				console.error("[Shaders] Error in mouse move handler:", error);
+			}
+		});
+	};
+	const globalTouchMoveHandler = (e) => {
+		callbacks.forEach((cb) => {
+			try {
+				cb.onTouchMove(e);
+			} catch (error) {
+				console.error("[Shaders] Error in touch move handler:", error);
+			}
+		});
+	};
+	const globalMouseUpHandler = () => {
+		callbacks.forEach((cb) => {
+			try {
+				cb.onMouseUp();
+			} catch (error) {
+				console.error("[Shaders] Error in mouse up handler:", error);
+			}
+		});
+	};
+	const globalTouchEndHandler = () => {
+		callbacks.forEach((cb) => {
+			try {
+				cb.onTouchEnd();
+			} catch (error) {
+				console.error("[Shaders] Error in touch end handler:", error);
+			}
+		});
+	};
+	return { register(handlers) {
+		callbacks.add(handlers);
+		instanceCount++;
+		if (instanceCount === 1) {
+			window.addEventListener("mousemove", globalMouseMoveHandler);
+			window.addEventListener("touchmove", globalTouchMoveHandler);
+			window.addEventListener("mouseup", globalMouseUpHandler);
+			window.addEventListener("touchend", globalTouchEndHandler);
+		}
+		return () => {
+			callbacks.delete(handlers);
+			instanceCount--;
+			if (instanceCount === 0) {
+				window.removeEventListener("mousemove", globalMouseMoveHandler);
+				window.removeEventListener("touchmove", globalTouchMoveHandler);
+				window.removeEventListener("mouseup", globalMouseUpHandler);
+				window.removeEventListener("touchend", globalTouchEndHandler);
+			}
+		};
+	} };
+})();
+var isDevelopment = () => {
+	try {
+		{
+			const { MODE, DEV } = {
+				"DEV": false,
+				"MODE": "production"
+			};
+			return DEV || MODE === "development";
+		}
+		if (typeof window !== "undefined" && window.location) {
+			const hostname = window.location.hostname;
+			return hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".local") || hostname.includes("dev.") || hostname.startsWith("dev-");
+		}
+		return false;
+	} catch (error) {
+		return false;
+	}
 };
-function ai() {
-  let e = null, n, s, t, u, p;
-  const h = {
-    nodes: /* @__PURE__ */ new Map(),
-    rootId: null,
-    idToNodeId: /* @__PURE__ */ new Map()
-  }, d = /* @__PURE__ */ new Map();
-  let k = null, U = null, B = null, O = !1, Q = !1, V = !1, q = null, ce = !1, ie = !0, z = 0, E = 0, pe = 0, Qe = !1, xe = 0.5, Ae = 0.5, ae = !1, De = !1, ze = null, ge = null, se = !1;
-  const te = new Dr();
-  let K = [], Ge = !1, Ee = [], fe = null, Fe = [], ue = null, Je = /* @__PURE__ */ new Set(), Ze = /* @__PURE__ */ new Set(), Ne = 0, be = /* @__PURE__ */ new Set(), Ve = /* @__PURE__ */ new Set(), ve = null, $e = !1;
-  const Cn = (i, r) => {
-    i <= 0 || r <= 0 || i === z && r === E || (ve = {
-      width: i,
-      height: r
-    }, $e || ($e = !0, requestAnimationFrame(() => {
-      if ($e = !1, !ve) return;
-      const { width: o, height: f } = ve;
-      ve = null, z = o, E = f, V || (V = !0), n.setSize(o, f, !1);
-      const c = o / f, b = 2, v = b * c;
-      s.left = -v / 2, s.right = v / 2, s.top = b / 2, s.bottom = -b / 2, s.updateProjectionMatrix(), u.scale.set(v, b, 1), h.nodes.forEach((m) => {
-        m.transformUniforms?.aspectRatio && (m.transformUniforms.aspectRatio.value = c), m.resizeCallbacks.forEach((M) => {
-          try {
-            M({
-              width: o,
-              height: f
-            });
-          } catch (D) {
-            console.error("Error in resize callback:", D);
-          }
-        });
-      }), Z().catch(console.warn);
-    })));
-  }, Rn = () => O && !!n && !!t && !!s && !!p && z > 0 && E > 0, kn = (i) => {
-    if (!n || !s || !u) return;
-    const r = i[0];
-    if (!r) return;
-    let o, f;
-    if (r.contentBoxSize) {
-      const c = Array.isArray(r.contentBoxSize) ? r.contentBoxSize[0] : r.contentBoxSize;
-      c ? (o = Math.round(c.inlineSize), f = Math.round(c.blockSize)) : (o = Math.round(r.contentRect.width), f = Math.round(r.contentRect.height));
-    } else
-      o = Math.round(r.contentRect.width), f = Math.round(r.contentRect.height);
-    o === 0 || f === 0 || Cn(o, f);
-  }, Tn = (i) => {
-    const r = i[0];
-    r && (ce = r.isIntersecting);
-  }, yn = (i, r) => {
-    if (i.size !== r.size) return !1;
-    for (const o of i) if (!r.has(o)) return !1;
-    return !0;
-  }, Ce = (i) => {
-    Ne++;
-    const r = Wn(i);
-    return be.add(r), r;
-  }, Ke = () => {
-    Ve.forEach((i) => {
-      try {
-        i?.renderTarget?.dispose && i.renderTarget.dispose();
-      } catch {
-      }
-    }), Ve.clear();
-  };
-  let me = !1;
-  const Re = () => {
-    if (!(!h.rootId || !p || De) && h.nodes.get(h.rootId)) {
-      if (z === 0 || E === 0) {
-        me || (me = !0, requestAnimationFrame(() => {
-          me = !1, z > 0 && E > 0 && Re();
-        }));
-        return;
-      }
-      De = !0;
-      try {
-        Ve = new Set(be), be.clear();
-        const i = /* @__PURE__ */ new Set();
-        Ze.clear(), h.nodes.forEach((o, f) => {
-          (o.requiresRTT || o.transformRTTActive) && Ze.add(f);
-        }), Ne = 0;
-        const r = I(h.rootId, /* @__PURE__ */ new Set(), i);
-        if (r && p) {
-          const o = !yn(Je, i), f = p.fragmentNode !== r;
-          if (o || Qe || f) {
-            Ke();
-            try {
-              p.dispose(), n.renderTarget && n.renderTarget.dispose();
-            } catch {
-            }
-            const c = new ln({ transparent: !0 });
-            c.fragmentNode = r, c.needsUpdate = !0, u.material = c, p = c, Qe = !1, Je = i;
-          }
-        }
-      } catch (i) {
-        console.error("Error composing shader tree:", i);
-      } finally {
-        De = !1;
-      }
-      Z().catch(console.warn);
-    }
-  }, P = (i) => {
-    const r = d.get(i);
-    if (!r) return [];
-    const o = [];
-    for (const f of r) {
-      const c = h.nodes.get(f);
-      c && o.push(c);
-    }
-    return o;
-  }, wn = (i) => {
-    for (const [r, o] of h.nodes.entries()) if (o.metadata.id === i) return r;
-    return null;
-  }, J = (i, r, o, f, c) => {
-    if (!r.metadata.mask?.source) return i;
-    const b = r.metadata.mask.source, v = wn(b);
-    if (!v) return i;
-    if (f.has(v))
-      return console.error("Uh oh, looks like you've got a circular dependency in your shader masks."), i;
-    const m = new Set(f);
-    m.add(o);
-    const M = I(v, m);
-    let D = M;
-    c && (D = Ce(M).sample(c));
-    const T = r.metadata.mask.type || "alpha";
-    return Ar(i, D, T);
-  }, ee = (i, r) => {
-    if (!r.metadata.transform || !r.transformUniforms || !ne(r.metadata.transform) && !r.transformRTTActive) return i;
-    const o = Ce(i), f = Ue(de, r.transformUniforms.offsetX, r.transformUniforms.offsetY, r.transformUniforms.rotation, r.transformUniforms.scale, r.transformUniforms.anchorX, r.transformUniforms.anchorY, r.transformUniforms.aspectRatio);
-    return he(f, o.sample(f), o, r.transformUniforms.edges);
-  }, X = (i) => !!i.uvTransformFunc && i.requiresChild && i.metadata.blendMode === "normal" && (i.metadata.opacity === void 0 || i.metadata.opacity === 1) && i.metadata.visible !== !1 && !i.metadata.mask?.source && !(i.transformUniforms && i.metadata.transform && ne(i.metadata.transform)), Oe = (i) => {
-    const r = [];
-    let o = i;
-    for (; o; ) {
-      const f = h.nodes.get(o);
-      if (!f || !X(f)) break;
-      r.push(f);
-      const c = P(f.id);
-      if (c.length !== 1) break;
-      const b = c[0];
-      if (X(b)) o = b.id;
-      else break;
-    }
-    return r;
-  }, Un = (i) => {
-    if (i.length === 0) return null;
-    const r = i[i.length - 1], o = P(r.id);
-    return o.length === 0 ? null : o.length === 1 ? o[0] : null;
-  }, ke = (i) => {
-    if (!i.uvTransformFunc || !X(i)) return !1;
-    const r = P(i.id);
-    if (r.length !== 1) return !1;
-    const o = r[0];
-    return o.acceptsUVContext && !o.requiresChild ? !0 : o.uvTransformFunc && X(o) ? ke(o) : !1;
-  }, Be = (i, r, o) => {
-    const f = [];
-    let c = i;
-    for (; c; ) {
-      const g = h.nodes.get(c);
-      if (!g) break;
-      if (f.length >= 2) return I(i, r, o, !0);
-      if (f.push(g), o && o.add(g.id), g.acceptsUVContext && !g.requiresChild) break;
-      const a = P(c);
-      if (a.length !== 1) break;
-      c = a[0].id;
-    }
-    if (f.length === 0) return S(0, 0, 0, 0);
-    const b = f[f.length - 1];
-    let v = de;
-    for (let g = 0; g < f.length; g++) {
-      const a = f[g];
-      a.uvTransformFunc && (v = a.uvTransformFunc({
-        uv: v,
-        uniforms: a.uniforms,
-        viewportSize: ye
-      })), a.transformUniforms && a.metadata.transform && ne(a.metadata.transform) && (v = Ue(v, a.transformUniforms.offsetX, a.transformUniforms.offsetY, a.transformUniforms.rotation, a.transformUniforms.scale, a.transformUniforms.anchorX, a.transformUniforms.anchorY, a.transformUniforms.aspectRatio), a.transformUniforms.edges && (v = re(v, a.transformUniforms.edges)), a.transformRTTActive = !0);
-    }
-    for (let g = 0; g < f.length - 1; g++) {
-      const a = f[g];
-      if (!a.requiresChild) continue;
-      const A = (_) => {
-        a.cleanupCallbacks.push(_);
-      }, Y = (_) => {
-        a.beforeRenderCallbacks.push(_);
-      }, x = (_) => {
-        a.afterRenderCallbacks.push(_);
-      }, w = (_) => {
-        a.resizeCallbacks.push(_);
-      };
-      a.cleanupCallbacks.forEach((_) => {
-        try {
-          _();
-        } catch (F) {
-          console.error("Error in cleanup callback:", F);
-        }
-      }), a.cleanupCallbacks = [], a.beforeRenderCallbacks = [], a.afterRenderCallbacks = [], a.resizeCallbacks = [], a.fragmentNodeFunc({
-        uniforms: a.uniforms ?? {},
-        childNode: void 0,
-        uvContext: void 0,
-        onCleanup: A,
-        onBeforeRender: Y,
-        onAfterRender: x,
-        onResize: w,
-        canvas: e,
-        dimensions: {
-          width: z,
-          height: E
-        },
-        renderer: n
-      });
-    }
-    const m = (g) => {
-      b.cleanupCallbacks.push(g);
-    }, M = (g) => {
-      b.beforeRenderCallbacks.push(g);
-    }, D = (g) => {
-      b.afterRenderCallbacks.push(g);
-    }, T = (g) => {
-      b.resizeCallbacks.push(g);
-    };
-    b.cleanupCallbacks.forEach((g) => {
-      try {
-        g();
-      } catch (a) {
-        console.error("Error in cleanup callback:", a);
-      }
-    }), b.cleanupCallbacks = [], b.beforeRenderCallbacks = [], b.afterRenderCallbacks = [], b.resizeCallbacks = [];
-    const C = b.fragmentNodeFunc({
-      uniforms: b.uniforms ?? {},
-      childNode: void 0,
-      uvContext: v,
-      onCleanup: m,
-      onBeforeRender: M,
-      onAfterRender: D,
-      onResize: T,
-      canvas: e,
-      dimensions: {
-        width: z,
-        height: E
-      },
-      renderer: n
-    });
-    for (const g of f) if (g.uniforms.edges?.uniform) return he(v, C, null, g.uniforms.edges.uniform);
-    return C;
-  }, _e = (i, r, o) => {
-    if (i.length === 0) return S(0, 0, 0, 0);
-    const f = Un(i);
-    let c;
-    if (f) c = I(f.id, r, o);
-    else {
-      const D = i[i.length - 1];
-      if (P(D.id).length === 0) return S(0, 0, 0, 0);
-      c = I(D.id, r, o);
-    }
-    const b = Ce(c);
-    let v = de;
-    for (let D = i.length - 1; D >= 0; D--) {
-      const T = i[D];
-      T.uvTransformFunc && (v = T.uvTransformFunc({
-        uv: v,
-        uniforms: T.uniforms,
-        viewportSize: ye
-      }), T.uniforms.edges?.uniform && (v = re(v, T.uniforms.edges.uniform))), o && o.add(T.id);
-    }
-    const m = b.sample(v), M = i[0];
-    return M.uniforms.edges?.uniform ? he(v, m, b, M.uniforms.edges.uniform) : m;
-  }, qe = (i, r) => {
-    const o = [];
-    for (let f = r; f < i.length; f++) {
-      const c = i[f];
-      if (!X(c) || P(c.id).length > 0) break;
-      o.push(c);
-    }
-    return o;
-  }, Pe = (i, r, o) => {
-    if (i.length === 0) return r;
-    const f = Ce(r);
-    let c = de;
-    for (let m = i.length - 1; m >= 0; m--) {
-      const M = i[m];
-      M.uvTransformFunc && (c = M.uvTransformFunc({
-        uv: c,
-        uniforms: M.uniforms,
-        viewportSize: ye
-      }), M.uniforms.edges?.uniform && (c = re(c, M.uniforms.edges.uniform))), o && o.add(M.id);
-    }
-    const b = f.sample(c), v = i[i.length - 1];
-    return v.uniforms.edges?.uniform ? he(c, b, f, v.uniforms.edges.uniform) : b;
-  }, Xe = (i) => {
-    const r = [], o = [];
-    let f = !1;
-    for (let v = 0; v < i.length; v++) {
-      const m = i[v], M = P(m.id).length > 0;
-      m.acceptsUVContext && !m.requiresChild && r.push(v), X(m) && !M && (o.push(v), r.length > 0 && (f = !0));
-    }
-    if (r.length === 0 || o.length === 0 || !f) return !1;
-    const c = Math.min(...r), b = Math.max(...o);
-    for (let v = c + 1; v < b; v++) {
-      const m = i[v];
-      if (m.requiresRTT && !X(m) && !(m.acceptsUVContext && !m.requiresChild)) return !1;
-    }
-    return !(o.length > 2);
-  }, Ye = (i, r, o) => {
-    const f = [], c = [];
-    i.forEach((v, m) => {
-      const M = P(v.id).length > 0;
-      X(v) && !M ? c.push({
-        node: v,
-        index: m
-      }) : v.acceptsUVContext && !v.requiresChild && !M && f.push({
-        node: v,
-        index: m
-      });
-    });
-    for (const v of c) {
-      const m = v.node;
-      m.cleanupCallbacks.forEach((g) => {
-        try {
-          g();
-        } catch (a) {
-          console.error("Cleanup error:", a);
-        }
-      }), m.cleanupCallbacks = [], m.beforeRenderCallbacks = [], m.afterRenderCallbacks = [], m.resizeCallbacks = [];
-      const M = (g) => m.cleanupCallbacks.push(g), D = (g) => m.beforeRenderCallbacks.push(g), T = (g) => m.afterRenderCallbacks.push(g), C = (g) => m.resizeCallbacks.push(g);
-      m.fragmentNodeFunc({
-        uniforms: m.uniforms ?? {},
-        childNode: void 0,
-        uvContext: void 0,
-        onCleanup: M,
-        onBeforeRender: D,
-        onAfterRender: T,
-        onResize: C,
-        canvas: e,
-        dimensions: {
-          width: z,
-          height: E
-        },
-        renderer: n
-      }), o && o.add(m.id);
-    }
-    let b;
-    for (let v = 0; v < i.length; v++) {
-      const m = i[v];
-      if (m.metadata.visible === !1) continue;
-      const M = m.metadata.opacity ?? 1;
-      m.opacityUniform.value = M, o && o.add(m.id);
-      const D = P(m.id).length > 0;
-      let T;
-      const C = f.find((g) => g.index === v);
-      if (C) {
-        const g = c.filter((F) => F.index > C.index).sort((F, $) => F.index - $.index).map((F) => F.node);
-        let a = de;
-        for (let F = g.length - 1; F >= 0; F--) {
-          const $ = g[F];
-          $.uvTransformFunc && (a = $.uvTransformFunc({
-            uv: a,
-            uniforms: $.uniforms,
-            viewportSize: ye
-          })), $.transformUniforms && $.metadata.transform && ne($.metadata.transform) && (a = Ue(a, $.transformUniforms.offsetX, $.transformUniforms.offsetY, $.transformUniforms.rotation, $.transformUniforms.scale, $.transformUniforms.anchorX, $.transformUniforms.anchorY, $.transformUniforms.aspectRatio), $.transformUniforms.edges && (a = re(a, $.transformUniforms.edges)), $.transformRTTActive = !0), $.uniforms.edges?.uniform && (a = re(a, $.uniforms.edges.uniform));
-        }
-        C.node.transformUniforms && C.node.metadata.transform && ne(C.node.metadata.transform) && (a = Ue(a, C.node.transformUniforms.offsetX, C.node.transformUniforms.offsetY, C.node.transformUniforms.rotation, C.node.transformUniforms.scale, C.node.transformUniforms.anchorX, C.node.transformUniforms.anchorY, C.node.transformUniforms.aspectRatio), C.node.transformUniforms.edges && (a = re(a, C.node.transformUniforms.edges)), C.node.transformRTTActive = !0), m.cleanupCallbacks.forEach((F) => {
-          try {
-            F();
-          } catch ($) {
-            console.error("Cleanup error:", $);
-          }
-        }), m.cleanupCallbacks = [], m.beforeRenderCallbacks = [], m.afterRenderCallbacks = [], m.resizeCallbacks = [];
-        const A = (F) => m.cleanupCallbacks.push(F), Y = (F) => m.beforeRenderCallbacks.push(F), x = (F) => m.afterRenderCallbacks.push(F), w = (F) => m.resizeCallbacks.push(F);
-        let _ = m.fragmentNodeFunc({
-          uniforms: m.uniforms ?? {},
-          childNode: void 0,
-          uvContext: a,
-          onCleanup: A,
-          onBeforeRender: Y,
-          onAfterRender: x,
-          onResize: w,
-          canvas: e,
-          dimensions: {
-            width: z,
-            height: E
-          },
-          renderer: n
-        });
-        if (g.length > 0) {
-          const F = g[0];
-          F.uniforms.edges?.uniform && (_ = he(a, _, null, F.uniforms.edges.uniform));
-        }
-        T = J(_, m, m.id, r, a);
-      } else {
-        if (c.find((g) => g.index === v)) continue;
-        if (D) {
-          if (ke(m)) T = Be(m.id, r, o);
-          else if (X(m)) {
-            const a = Oe(m.id);
-            a.length > 1 ? T = _e(a, r, o) : T = I(m.id, r, o);
-          } else T = I(m.id, r, o);
-          const g = c.filter((a) => a.index > v).sort((a, A) => a.index - A.index).map((a) => a.node);
-          if (g.length > 0) {
-            const a = Ce(T);
-            let A = de;
-            for (let x = g.length - 1; x >= 0; x--) {
-              const w = g[x];
-              w.uvTransformFunc && (A = w.uvTransformFunc({
-                uv: A,
-                uniforms: w.uniforms,
-                viewportSize: ye
-              })), w.transformUniforms && w.metadata.transform && ne(w.metadata.transform) && (A = Ue(A, w.transformUniforms.offsetX, w.transformUniforms.offsetY, w.transformUniforms.rotation, w.transformUniforms.scale, w.transformUniforms.anchorX, w.transformUniforms.anchorY, w.transformUniforms.aspectRatio), w.transformUniforms.edges && (A = re(A, w.transformUniforms.edges)), w.transformRTTActive = !0), w.uniforms.edges?.uniform && (A = re(A, w.uniforms.edges.uniform));
-            }
-            T = a.sample(A);
-            const Y = g[g.length - 1];
-            Y.transformUniforms?.edges && (T = he(A, T, a, Y.transformUniforms.edges));
-          }
-        } else {
-          m.cleanupCallbacks.forEach((w) => {
-            try {
-              w();
-            } catch (_) {
-              console.error("Cleanup error:", _);
-            }
-          }), m.cleanupCallbacks = [], m.beforeRenderCallbacks = [], m.afterRenderCallbacks = [], m.resizeCallbacks = [];
-          const g = (w) => m.cleanupCallbacks.push(w), a = (w) => m.beforeRenderCallbacks.push(w), A = (w) => m.afterRenderCallbacks.push(w), Y = (w) => m.resizeCallbacks.push(w);
-          let x = b;
-          m.requiresRTT && b !== void 0 && (x = H(S(0, 0, 0, 0), b, "normal", 1)), T = J(ee(m.fragmentNodeFunc({
-            uniforms: m.uniforms ?? {},
-            childNode: x,
-            onCleanup: g,
-            onBeforeRender: a,
-            onAfterRender: A,
-            onResize: Y,
-            canvas: e,
-            dimensions: {
-              width: z,
-              height: E
-            },
-            renderer: n
-          }), m), m, m.id, r);
-        }
-      }
-      m.requiresChild && m.metadata.blendMode === "normal" && !D ? b = H(S(0, 0, 0, 0), T, "normal", m.opacityUniform) : b === void 0 ? b = H(S(1, 1, 1, 0), T, m.metadata.blendMode, m.opacityUniform) : b = H(b, T, m.metadata.blendMode, m.opacityUniform);
-    }
-    return b ?? S(0, 0, 0, 0);
-  }, I = (i, r = /* @__PURE__ */ new Set(), o, f = !1) => {
-    if (z === 0 || E === 0) return S(0, 0, 0, 0);
-    const c = h.nodes.get(i);
-    if (!c) return S(0, 0, 0, 0);
-    const b = (T) => {
-      c.cleanupCallbacks.push(T);
-    }, v = (T) => {
-      c.beforeRenderCallbacks.push(T);
-    }, m = (T) => {
-      c.afterRenderCallbacks.push(T);
-    }, M = (T) => {
-      c.resizeCallbacks.push(T);
-    }, D = P(i);
-    if (D.length === 0)
-      return c.cleanupCallbacks.forEach((T) => {
-        try {
-          T();
-        } catch (C) {
-          console.error("Error in cleanup callback:", C);
-        }
-      }), c.cleanupCallbacks = [], c.beforeRenderCallbacks = [], c.afterRenderCallbacks = [], c.resizeCallbacks = [], J(ee(c.fragmentNodeFunc({
-        uniforms: c.uniforms ?? {},
-        childNode: void 0,
-        onCleanup: b,
-        onBeforeRender: v,
-        onAfterRender: m,
-        onResize: M,
-        canvas: e,
-        dimensions: {
-          width: z,
-          height: E
-        },
-        renderer: n
-      }), c), c, i, r);
-    {
-      const T = [...D].sort((C, g) => C.metadata.renderOrder - g.metadata.renderOrder);
-      if (c.parentId === null) {
-        if (!f && Xe(T)) return J(ee(Ye(T, r, o), c), c, i, r);
-        let C;
-        for (let g = 0; g < T.length; g++) {
-          const a = T[g];
-          let A;
-          if (a.metadata.opacity === void 0 ? (A = 1, a.opacityUniform.value = A) : (A = a.metadata.opacity, a.opacityUniform.value = A), a.metadata.visible === !1) continue;
-          o && o.add(a.id);
-          const Y = P(a.id).length > 0;
-          let x;
-          if (Y) if (f) x = I(a.id, r, o, !0);
-          else if (ke(a)) x = Be(a.id, r, o);
-          else if (X(a)) {
-            const w = Oe(a.id);
-            w.length > 1 ? x = _e(w, r, o) : x = I(a.id, r, o);
-          } else x = I(a.id, r, o);
-          else {
-            if (X(a) && a.requiresChild && C !== void 0) {
-              const w = qe(T, g);
-              if (w.length > 1) {
-                x = Pe(w, C, o), g += w.length - 1, C = x;
-                continue;
-              }
-            }
-            {
-              const w = (L) => {
-                a.cleanupCallbacks.push(L);
-              }, _ = (L) => {
-                a.beforeRenderCallbacks.push(L);
-              }, F = (L) => {
-                a.afterRenderCallbacks.push(L);
-              }, $ = (L) => {
-                a.resizeCallbacks.push(L);
-              };
-              let Te = C;
-              a.requiresRTT && C !== void 0 && (Te = H(S(0, 0, 0, 0), C, "normal", 1)), a.cleanupCallbacks.forEach((L) => {
-                try {
-                  L();
-                } catch (Gn) {
-                  console.error("Error in cleanup callback:", Gn);
-                }
-              }), a.cleanupCallbacks = [], a.beforeRenderCallbacks = [], a.afterRenderCallbacks = [], a.resizeCallbacks = [], x = J(ee(a.fragmentNodeFunc({
-                uniforms: a.uniforms ?? {},
-                childNode: Te,
-                onCleanup: w,
-                onBeforeRender: _,
-                onAfterRender: F,
-                onResize: $,
-                canvas: e,
-                dimensions: {
-                  width: z,
-                  height: E
-                },
-                renderer: n
-              }), a), a, a.id, r);
-            }
-          }
-          a.requiresChild && a.metadata.blendMode === "normal" && !Y ? C = H(S(0, 0, 0, 0), x, "normal", a.opacityUniform) : C === void 0 ? c.requiresRTT || A !== 1 ? C = H(S(1, 1, 1, 0), x, a.metadata.blendMode, a.opacityUniform) : C = x : C = H(C, x, a.metadata.blendMode, a.opacityUniform);
-        }
-        return c.cleanupCallbacks.forEach((g) => {
-          try {
-            g();
-          } catch (a) {
-            console.error("Error in cleanup callback:", a);
-          }
-        }), c.cleanupCallbacks = [], c.beforeRenderCallbacks = [], c.afterRenderCallbacks = [], c.resizeCallbacks = [], J(ee(c.fragmentNodeFunc({
-          uniforms: c.uniforms ?? {},
-          childNode: C,
-          onCleanup: b,
-          onBeforeRender: v,
-          onAfterRender: m,
-          onResize: M,
-          canvas: e,
-          dimensions: {
-            width: z,
-            height: E
-          },
-          renderer: n
-        }), c), c, i, r);
-      } else {
-        if (!f && Xe(T)) {
-          const g = Ye(T, r, o);
-          return J(ee(c.fragmentNodeFunc({
-            uniforms: c.uniforms ?? {},
-            childNode: g,
-            onCleanup: b,
-            onBeforeRender: v,
-            onAfterRender: m,
-            onResize: M,
-            canvas: e,
-            dimensions: {
-              width: z,
-              height: E
-            },
-            renderer: n
-          }), c), c, i, r);
-        }
-        let C;
-        for (let g = 0; g < T.length; g++) {
-          const a = T[g];
-          let A;
-          if (a.metadata.opacity === void 0 ? (A = 1, a.opacityUniform.value = A) : (A = a.metadata.opacity, a.opacityUniform.value = A), a.metadata.visible === !1) continue;
-          o && o.add(a.id);
-          const Y = P(a.id).length > 0;
-          let x;
-          if (Y) if (f) x = I(a.id, r, o, !0);
-          else if (ke(a)) x = Be(a.id, r, o);
-          else if (X(a)) {
-            const w = Oe(a.id);
-            w.length > 1 ? x = _e(w, r, o) : x = I(a.id, r, o);
-          } else x = I(a.id, r, o);
-          else {
-            if (X(a) && a.requiresChild && C !== void 0) {
-              const w = qe(T, g);
-              if (w.length > 1) {
-                x = Pe(w, C, o), g += w.length - 1, C = x;
-                continue;
-              }
-            }
-            {
-              const w = (L) => {
-                a.cleanupCallbacks.push(L);
-              }, _ = (L) => {
-                a.beforeRenderCallbacks.push(L);
-              }, F = (L) => {
-                a.afterRenderCallbacks.push(L);
-              }, $ = (L) => {
-                a.resizeCallbacks.push(L);
-              };
-              let Te = C;
-              a.requiresRTT && C !== void 0 && (Te = H(S(0, 0, 0, 0), C, "normal", 1)), a.cleanupCallbacks = [], a.beforeRenderCallbacks = [], a.afterRenderCallbacks = [], a.resizeCallbacks = [], x = J(ee(a.fragmentNodeFunc({
-                uniforms: a.uniforms ?? {},
-                childNode: Te,
-                onCleanup: w,
-                onBeforeRender: _,
-                onAfterRender: F,
-                onResize: $,
-                canvas: e,
-                dimensions: {
-                  width: z,
-                  height: E
-                },
-                renderer: n
-              }), a), a, a.id, r);
-            }
-          }
-          a.requiresChild && a.metadata.blendMode === "normal" && !Y ? C = H(S(0, 0, 0, 0), x, "normal", a.opacityUniform) : C === void 0 ? c.requiresRTT || A !== 1 ? C = H(S(1, 1, 1, 0), x, a.metadata.blendMode, a.opacityUniform) : C = x : C = H(C, x, a.metadata.blendMode, a.opacityUniform);
-        }
-        return c.cleanupCallbacks.forEach((g) => {
-          try {
-            g();
-          } catch (a) {
-            console.error("Error in cleanup callback:", a);
-          }
-        }), c.cleanupCallbacks = [], c.beforeRenderCallbacks = [], c.afterRenderCallbacks = [], c.resizeCallbacks = [], J(ee(c.fragmentNodeFunc({
-          uniforms: c.uniforms ?? {},
-          childNode: C,
-          onCleanup: b,
-          onBeforeRender: v,
-          onAfterRender: m,
-          onResize: M,
-          canvas: e,
-          dimensions: {
-            width: z,
-            height: E
-          },
-          renderer: n
-        }), c), c, i, r);
-      }
-    }
-  }, en = (i, r, o, f, c = {}, b) => {
-    if (r === null) {
-      const C = K.findIndex((g) => g.id === i);
-      if (C !== -1) {
-        K.splice(C, 1);
-        return;
-      }
-      Ie(i);
-      return;
-    }
-    if (!Ge) {
-      const C = K.findIndex((g) => g.id === i);
-      C !== -1 ? K[C] = {
-        id: i,
-        fragmentNodeFunc: r,
-        parentId: o,
-        metadata: f,
-        uniforms: c,
-        componentDefinition: b
-      } : K.push({
-        id: i,
-        fragmentNodeFunc: r,
-        parentId: o,
-        metadata: f,
-        uniforms: c,
-        componentDefinition: b
-      });
-      return;
-    }
-    let v = 0;
-    if (o !== null) {
-      const C = d.get(o);
-      if (C && C.size > 0) {
-        let g = 0;
-        for (const a of C) {
-          const A = h.nodes.get(a);
-          A && A.metadata.renderOrder > g && (g = A.metadata.renderOrder);
-        }
-        v = g + 1;
-      }
-    }
-    const m = G(f?.opacity !== void 0 ? f.opacity : 1);
-    let M;
-    if (f?.transform) {
-      const C = z / Math.max(1, E);
-      M = {
-        offsetX: G(f.transform.offsetX),
-        offsetY: G(f.transform.offsetY),
-        rotation: G(f.transform.rotation),
-        scale: G(f.transform.scale),
-        anchorX: G(f.transform.anchorX),
-        anchorY: G(f.transform.anchorY),
-        edges: G(f.transform.edges === "stretch" ? 0 : f.transform.edges === "transparent" ? 1 : f.transform.edges === "mirror" ? 2 : 3),
-        aspectRatio: G(C)
-      };
-    }
-    const D = {
-      id: i,
-      componentName: b?.name || "Unknown",
-      fragmentNodeFunc: r,
-      parentId: o,
-      requiresRTT: b?.requiresRTT || !1,
-      requiresChild: b?.requiresChild || !1,
-      opacityUniform: m,
-      metadata: {
-        blendMode: f?.blendMode || "normal",
-        opacity: f?.opacity,
-        visible: f?.visible !== !1,
-        id: f?.id,
-        mask: f?.mask,
-        renderOrder: f?.renderOrder !== void 0 ? f?.renderOrder : v,
-        transform: f?.transform
-      },
-      uniforms: c,
-      cleanupCallbacks: [],
-      beforeRenderCallbacks: [],
-      afterRenderCallbacks: [],
-      resizeCallbacks: [],
-      transformUniforms: M,
-      transformRTTActive: !1,
-      uvTransformFunc: b?.uvTransformNode,
-      acceptsUVContext: b?.acceptsUVContext || !1
-    };
-    h.nodes.set(i, D), o === null && (h.rootId = i);
-    const T = d.get(o) || /* @__PURE__ */ new Set();
-    T.add(i), d.set(o, T), p && O && z > 0 && E > 0 ? (Ee.includes(i) || Ee.push(i), fe === null && (fe = requestAnimationFrame(() => {
-      fe = null, Ee = [], Re();
-    }))) : p && O && (me || (me = !0, requestAnimationFrame(() => {
-      me = !1, z > 0 && E > 0 && Re();
-    })));
-  }, Sn = (i, r, o) => {
-    const f = h.nodes.get(i);
-    if (!f || !f.uniforms) return;
-    const c = f.uniforms[r];
-    !c || !c.uniform || (c.transform ? Br(c, o) : c.uniform.value = o, Z());
-  }, Mn = (i, r) => {
-    const o = h.nodes.get(i);
-    if (!o) return;
-    let f = !1;
-    r.blendMode !== void 0 && o.metadata.blendMode !== r.blendMode && (o.metadata.blendMode = r.blendMode, f = !0), r.opacity !== void 0 && o.metadata.opacity !== r.opacity && (o.metadata.opacity = r.opacity, o.opacityUniform.value = r.opacity), r.renderOrder !== void 0 && o.metadata.renderOrder !== r.renderOrder && (o.metadata.renderOrder = r.renderOrder, f = !0);
-    const c = r.visible !== !1;
-    if (o.metadata.visible !== c && (o.metadata.visible = c, f = !0), r.id !== void 0 && o.metadata.id !== r.id && (o.metadata.id = r.id, f = !0), r.mask !== void 0 && (o.metadata.mask?.source !== r.mask?.source || o.metadata.mask?.type !== r.mask?.type) && (o.metadata.mask = r.mask, f = !0), r.transform !== void 0) {
-      const b = o.metadata.transform ? ne(o.metadata.transform) : !1, v = ne(r.transform);
-      if (o.metadata.transform = r.transform, !o.transformUniforms && r.transform) {
-        const m = z / Math.max(1, E);
-        o.transformUniforms = {
-          offsetX: G(r.transform.offsetX),
-          offsetY: G(r.transform.offsetY),
-          rotation: G(r.transform.rotation),
-          scale: G(r.transform.scale),
-          anchorX: G(r.transform.anchorX),
-          anchorY: G(r.transform.anchorY),
-          edges: G(r.transform.edges === "stretch" ? 0 : r.transform.edges === "transparent" ? 1 : r.transform.edges === "mirror" ? 2 : 3),
-          aspectRatio: G(m)
-        };
-      } else o.transformUniforms && (o.transformUniforms.offsetX.value = r.transform.offsetX, o.transformUniforms.offsetY.value = r.transform.offsetY, o.transformUniforms.rotation.value = r.transform.rotation, o.transformUniforms.scale.value = r.transform.scale, o.transformUniforms.anchorX.value = r.transform.anchorX, o.transformUniforms.anchorY.value = r.transform.anchorY, o.transformUniforms.edges.value = r.transform.edges === "stretch" ? 0 : r.transform.edges === "transparent" ? 1 : r.transform.edges === "mirror" ? 2 : 3);
-      v && !o.transformRTTActive && (o.transformRTTActive = !0, f = !0), !b && v && !o.transformRTTActive && (f = !0);
-    }
-    f && p && O ? (Fe.includes(i) || Fe.push(i), ue === null && (ue = requestAnimationFrame(() => {
-      ue = null, Fe = [], Re();
-    }))) : Z();
-  }, Ie = (i) => {
-    if (!h.nodes.has(i)) return;
-    const r = h.nodes.get(i);
-    if (r && r.cleanupCallbacks.length > 0) for (const f of r.cleanupCallbacks) try {
-      f();
-    } catch (c) {
-      console.error(`Error executing cleanup callback for node ${i}:`, c);
-    }
-    const o = P(i);
-    for (const f of o) Ie(f.id);
-    if (h.rootId === i && (h.rootId = null), r) {
-      const f = d.get(r.parentId);
-      f && (f.delete(i), f.size === 0 && d.delete(r.parentId));
-    }
-    h.nodes.delete(i), p && O && Re();
-  }, xn = (i) => {
-    const r = {
-      deltaTime: i,
-      pointer: {
-        x: xe,
-        y: Ae
-      },
-      pointerActive: ae,
-      dimensions: {
-        width: z,
-        height: E
-      }
-    };
-    for (const o of h.nodes.values()) if (o.beforeRenderCallbacks.length > 0) for (const f of o.beforeRenderCallbacks) try {
-      f(r);
-    } catch (c) {
-      console.error(`Error executing before render callback for node ${o.id}:`, c);
-    }
-  }, An = (i) => {
-    const r = {
-      deltaTime: i,
-      pointer: {
-        x: xe,
-        y: Ae
-      },
-      pointerActive: ae,
-      dimensions: {
-        width: z,
-        height: E
-      }
-    };
-    for (const o of h.nodes.values()) if (o.afterRenderCallbacks.length > 0) for (const f of o.afterRenderCallbacks) try {
-      f(r);
-    } catch (c) {
-      console.error(`Error executing after render callback for node ${o.id}:`, c);
-    }
-  }, Z = async () => {
-    if (!Rn()) return;
-    const i = se ? performance.now() : 0, r = i || performance.now(), o = pe > 0 ? (r - pe) / 1e3 : 0.016;
-    if (!ce && pe > 0 && r - pe < 1e3)
-      return;
-    const c = Math.min(o, 0.1);
-    pe = r, se && performance.mark("shader-cpu-start"), xn(c);
-    try {
-      if (De) return;
-      if (se && performance.mark("shader-gpu-start"), n.render(t, s), An(c), se) {
-        if (performance.mark("shader-gpu-end"), n instanceof He) try {
-          const b = n.backend;
-          if (b && b.get && b.get(n)) {
-            const v = b.get(n);
-            if (v?.timestampQuery) {
-              const m = v.timestampQuery.getResult();
-              m != null && te.recordGpuTime(m / 1e6);
-            }
-          }
-        } catch {
-        }
-        try {
-          performance.measure("shader-gpu-time", "shader-gpu-start", "shader-gpu-end");
-          const b = performance.getEntriesByName("shader-gpu-time")[0];
-          b && te.recordGpuTime(b.duration), performance.clearMarks("shader-gpu-start"), performance.clearMarks("shader-gpu-end"), performance.clearMeasures("shader-gpu-time");
-        } catch {
-        }
-      }
-      if (se) {
-        performance.mark("shader-cpu-end");
-        try {
-          performance.measure("shader-cpu-time", "shader-cpu-start", "shader-cpu-end");
-          const v = performance.getEntriesByName("shader-cpu-time")[0];
-          v && te.recordCpuTime(v.duration), performance.clearMarks("shader-cpu-start"), performance.clearMarks("shader-cpu-end"), performance.clearMeasures("shader-cpu-time");
-        } catch {
-        }
-        const b = performance.now() - i;
-        te.recordFrame(b);
-      }
-    } catch (b) {
-      console.error("Render frame error:", b);
-    }
-  }, Dn = () => {
-    const i = Math.max(0, h.nodes.size - 1), r = Ne;
-    te.updateNodeCounts(i, r);
-  }, zn = () => {
-    Dn();
-    const i = n?.info;
-    return te.getStats(i);
-  }, nn = () => {
-    if (k || !ie) return;
-    te.setRendering(!0);
-    const i = () => {
-      k = requestAnimationFrame(i), Z().catch(console.warn);
-    };
-    i();
-  }, tn = () => {
-    k && (cancelAnimationFrame(k), k = null), te.setRendering(!1);
-  }, rn = (i) => {
-    if (!e) return;
-    let r, o;
-    if ("touches" in i) {
-      if (i.touches.length === 0) return;
-      r = i.touches[0].clientX, o = i.touches[0].clientY;
-    } else
-      r = i.clientX, o = i.clientY;
-    const f = e.getBoundingClientRect(), c = (r - f.left) / f.width, b = (o - f.top) / f.height;
-    xe = c, Ae = b;
-  }, En = (i) => {
-    !O || !e || rn(i);
-  }, Fn = (i) => {
-    !O || !e || rn(i);
-  }, $n = () => {
-    O && (ae = !1, Z().catch(console.warn));
-  }, On = () => {
-    O && (ae = !1, Z().catch(console.warn));
-  }, on = () => {
-    ae = !0, Z().catch(console.warn);
-  }, an = () => {
-    ae = !0, Z().catch(console.warn);
-  }, Bn = () => {
-    if (K.length === 0) return;
-    const i = [...K];
-    K = [];
-    for (const { id: r, fragmentNodeFunc: o, parentId: f, metadata: c, uniforms: b, componentDefinition: v } of i) o && en(r, o, f, c, b, v);
-  }, _n = async ({ canvas: i, enablePerformanceTracking: r = !1 }) => {
-    if (O || Q) return;
-    se = r, Q = !0, q = new AbortController();
-    const o = q;
-    try {
-      if (e = i, t = new Yn(), t.background = null, s = new Xn(-1, 1, 1, -1, 0.1, 10), s.position.z = 1, s.lookAt(0, 0, 0), ze = _r.register({
-        onMouseMove: En,
-        onTouchMove: Fn,
-        onMouseUp: $n,
-        onTouchEnd: On
-      }), i.addEventListener("mousedown", on), i.addEventListener("touchstart", an), ge = () => {
-        sn();
-      }, window.addEventListener("beforeunload", ge), o.signal.aborted) return;
-      try {
-        const D = {
-          canvas: i,
-          antialias: !0,
-          alpha: !0,
-          depth: !1,
-          powerPreference: "high-performance"
-        };
-        if (se && (D.forceWebGL = !1, D.requiredFeatures = ["timestamp-query"]), n = new He(D), await n.init(), o.signal.aborted) return;
-      } catch (D) {
-        if (o.signal.aborted) return;
-        console.warn("[Shaders] WebGPU initialization failed, falling back to WebGL:", D);
-        try {
-          if (n = new Kt({
-            canvas: i,
-            antialias: !0,
-            alpha: !0,
-            depth: !1,
-            powerPreference: "high-performance"
-          }), o.signal.aborted) return;
-        } catch (T) {
-          if (o.signal.aborted) return;
-          console.error("[Shaders] Both WebGPU and WebGL initialization failed:", T);
-          return;
-        }
-      }
-      if (o.signal.aborted) return;
-      n.setPixelRatio(Math.min(window.devicePixelRatio, 2)), n.outputColorSpace = Nn, p = new ln({ transparent: !0 }), p.fragmentNode = S(0, 0, 0, 0), u = new Pn(new Jn(2, 2), p), t.add(u);
-      const f = i.parentElement;
-      if (!f) {
-        console.warn("[Shaders] Canvas has no parent element for resize observation");
-        return;
-      }
-      U = new ResizeObserver(kn), U.observe(f), B = new IntersectionObserver(Tn, { threshold: 0 }), B.observe(i);
-      const c = i.getBoundingClientRect();
-      ce = c.width > 0 && c.height > 0 && c.top < window.innerHeight && c.bottom > 0 && c.left < window.innerWidth && c.right > 0, ie = !0;
-      const { width: b, height: v } = i.getBoundingClientRect(), m = Math.round(b), M = Math.round(v);
-      if (m > 0 && M > 0) {
-        z = m, E = M, V = !0, n.setSize(m, M, !1);
-        const D = m / M, T = 2, C = T * D;
-        s.left = -C / 2, s.right = C / 2, s.top = T / 2, s.bottom = -T / 2, s.updateProjectionMatrix(), u.scale.set(C, T, 1), await Z();
-      } else V = !1;
-      ie && nn(), o.signal.aborted || (O = !0, Ge = !0, Bn());
-    } catch (f) {
-      console.error("[Shaders] Initialization error:", f);
-    } finally {
-      Q = !1, q === o && (q = null);
-    }
-  }, Ln = () => {
-    !Lr() || gn || (console.warn("Shaders is running in development mode. Please purchase a license at https://shaders.com to use it in production."), gn = !0);
-  }, sn = () => {
-    if (q && q.abort(), U && (U.disconnect(), U = null), B && (B.disconnect(), B = null), ze && (ze(), ze = null), e && (e.removeEventListener("mousedown", on), e.removeEventListener("touchstart", an)), ge && (window.removeEventListener("beforeunload", ge), ge = null), tn(), Ke(), be.forEach((i) => {
-      try {
-        i?.renderTarget?.dispose && i.renderTarget.dispose();
-      } catch {
-      }
-    }), be.clear(), h.nodes.clear(), h.rootId = null, h.idToNodeId.clear(), d.clear(), K = [], Ge = !1, Ee = [], fe !== null && (cancelAnimationFrame(fe), fe = null), Fe = [], ue !== null && (cancelAnimationFrame(ue), ue = null), ve = null, $e = !1, u) {
-      t && t.remove(u);
-      try {
-        u.geometry && typeof u.geometry.dispose == "function" && u.geometry.dispose();
-      } catch {
-      }
-      try {
-        u.material instanceof qn && typeof u.material.dispose == "function" && u.material.dispose();
-      } catch {
-      }
-    }
-    if (n && typeof n.dispose == "function") try {
-      n.dispose();
-    } catch {
-    }
-    e = null, n = null, s = null, t = null, u = null, p = null, O = !1, Q = !1, V = !1, q = null, z = 0, E = 0, ce = !1, ie = !0, xe = 0.5, Ae = 0.5, ae = !1;
-  };
-  return {
-    initialize: _n,
-    cleanup: sn,
-    registerNode: en,
-    removeNode: Ie,
-    updateUniformValue: Sn,
-    updateNodeMetadata: Mn,
-    showLicenseWarning: Ln,
-    isInitialized: () => O,
-    startAnimation: nn,
-    stopAnimation: tn,
-    getPerformanceStats: zn,
-    getNodeRegistry: () => ({ nodes: new Map(h.nodes) }),
-    getRendererType: () => n ? n instanceof He ? "webgpu" : "webgl" : null,
-    __testing: {
-      isUVComposable: X,
-      canSkipRTT: ke,
-      hasUVPropagationOpportunity: Xe,
-      needsTransformation: ne,
-      findUVChain: Oe,
-      findSiblingUVChain: qe,
-      findChildNodes: P,
-      composeUVContextChain: Be,
-      composeUVChain: _e,
-      composeSiblingUVChain: Pe,
-      composeSiblingsWithUVContext: Ye,
-      applyMaskIfNeeded: J,
-      applyNodeTransformation: ee,
-      getNodeRegistry: () => h,
-      getParentToChildren: () => d
-    }
-  };
+function shaderRenderer() {
+	let canvasElement = null;
+	let renderer;
+	let camera;
+	let scene;
+	let mesh;
+	let material;
+	const nodeRegistry = {
+		nodes: /* @__PURE__ */ new Map(),
+		rootId: null,
+		idToNodeId: /* @__PURE__ */ new Map()
+	};
+	const parentToChildren = /* @__PURE__ */ new Map();
+	let animationFrameId = null;
+	let resizeObserver = null;
+	let intersectionObserver = null;
+	let isInitialized = false;
+	let isInitializing = false;
+	let hasInitialDimensions = false;
+	let initializationAbortController = null;
+	let isVisible = false;
+	let shouldAnimate = true;
+	let currentWidth = 0;
+	let currentHeight = 0;
+	let lastRenderTime = 0;
+	let needsMaterialRefresh = false;
+	let pointerX = .5;
+	let pointerY = .5;
+	let pointerActive = false;
+	let isUpdatingMaterial = false;
+	let globalEventUnregister = null;
+	let unloadHandler = null;
+	let enablePerformanceTracking = false;
+	const performanceTracker = new PerformanceTracker();
+	let pendingRegistrationQueue = [];
+	let isRendererReady = false;
+	let registrationQueue = [];
+	let registrationBatchRAF = null;
+	let metadataUpdateQueue = [];
+	let metadataUpdateBatchRAF = null;
+	let lastComposedNodes = /* @__PURE__ */ new Set();
+	let activeRTTNodes = /* @__PURE__ */ new Set();
+	let actualRTTOperations = 0;
+	let currentTextures = /* @__PURE__ */ new Set();
+	let previousTextures = /* @__PURE__ */ new Set();
+	let pendingResize = null;
+	let isResizeScheduled = false;
+	const updateRendererDimensions = (width, height) => {
+		if (width <= 0 || height <= 0) return;
+		if (width === currentWidth && height === currentHeight) return;
+		pendingResize = {
+			width,
+			height
+		};
+		if (!isResizeScheduled) {
+			isResizeScheduled = true;
+			requestAnimationFrame(() => {
+				isResizeScheduled = false;
+				if (!pendingResize) return;
+				const { width: width$1, height: height$1 } = pendingResize;
+				pendingResize = null;
+				currentWidth = width$1;
+				currentHeight = height$1;
+				if (!hasInitialDimensions) hasInitialDimensions = true;
+				renderer.setSize(width$1, height$1, false);
+				const aspectRatio = width$1 / height$1;
+				const frustumHeight = 2;
+				const frustumWidth = frustumHeight * aspectRatio;
+				camera.left = -frustumWidth / 2;
+				camera.right = frustumWidth / 2;
+				camera.top = frustumHeight / 2;
+				camera.bottom = -frustumHeight / 2;
+				camera.updateProjectionMatrix();
+				mesh.scale.set(frustumWidth, frustumHeight, 1);
+				nodeRegistry.nodes.forEach((nodeInfo) => {
+					if (nodeInfo.transformUniforms?.aspectRatio) nodeInfo.transformUniforms.aspectRatio.value = aspectRatio;
+					nodeInfo.resizeCallbacks.forEach((callback) => {
+						try {
+							callback({
+								width: width$1,
+								height: height$1
+							});
+						} catch (error) {
+							console.error("Error in resize callback:", error);
+						}
+					});
+				});
+				renderFrame().catch(console.warn);
+			});
+		}
+	};
+	const canRender = () => {
+		return isInitialized && !!renderer && !!scene && !!camera && !!material && currentWidth > 0 && currentHeight > 0;
+	};
+	const handleResize = (entries) => {
+		if (!renderer || !camera || !mesh) return;
+		const entry = entries[0];
+		if (!entry) return;
+		let width, height;
+		if (entry.contentBoxSize) {
+			const boxSize = Array.isArray(entry.contentBoxSize) ? entry.contentBoxSize[0] : entry.contentBoxSize;
+			if (boxSize) {
+				width = Math.round(boxSize.inlineSize);
+				height = Math.round(boxSize.blockSize);
+			} else {
+				width = Math.round(entry.contentRect.width);
+				height = Math.round(entry.contentRect.height);
+			}
+		} else {
+			width = Math.round(entry.contentRect.width);
+			height = Math.round(entry.contentRect.height);
+		}
+		if (width === 0 || height === 0) return;
+		updateRendererDimensions(width, height);
+	};
+	const handleVisibilityChange = (entries) => {
+		const entry = entries[0];
+		if (!entry) return;
+		isVisible = entry.isIntersecting;
+	};
+	const setsAreEqual = (set1, set2) => {
+		if (set1.size !== set2.size) return false;
+		for (const item of set1) if (!set2.has(item)) return false;
+		return true;
+	};
+	const trackConvertToTexture = (node) => {
+		actualRTTOperations++;
+		const texture = convertToTexture(node);
+		currentTextures.add(texture);
+		return texture;
+	};
+	const disposePreviousTextures = () => {
+		previousTextures.forEach((texture) => {
+			try {
+				if (texture?.renderTarget?.dispose) texture.renderTarget.dispose();
+			} catch (e) {}
+		});
+		previousTextures.clear();
+	};
+	let materialUpdatePending = false;
+	const updateMaterial = () => {
+		if (!nodeRegistry.rootId || !material || isUpdatingMaterial) return;
+		if (!nodeRegistry.nodes.get(nodeRegistry.rootId)) return;
+		if (currentWidth === 0 || currentHeight === 0) {
+			if (!materialUpdatePending) {
+				materialUpdatePending = true;
+				requestAnimationFrame(() => {
+					materialUpdatePending = false;
+					if (currentWidth > 0 && currentHeight > 0) updateMaterial();
+				});
+			}
+			return;
+		}
+		isUpdatingMaterial = true;
+		try {
+			previousTextures = new Set(currentTextures);
+			currentTextures.clear();
+			const currentComposedNodes = /* @__PURE__ */ new Set();
+			activeRTTNodes.clear();
+			nodeRegistry.nodes.forEach((nodeInfo, nodeId) => {
+				if (nodeInfo.requiresRTT || nodeInfo.transformRTTActive) activeRTTNodes.add(nodeId);
+			});
+			actualRTTOperations = 0;
+			const composedNode = composeNodeTree(nodeRegistry.rootId, /* @__PURE__ */ new Set(), currentComposedNodes);
+			if (composedNode && material) {
+				const compositionChanged = !setsAreEqual(lastComposedNodes, currentComposedNodes);
+				const nodeChanged = material.fragmentNode !== composedNode;
+				if (compositionChanged || needsMaterialRefresh || nodeChanged) {
+					disposePreviousTextures();
+					try {
+						material.dispose();
+						if (renderer.renderTarget) renderer.renderTarget.dispose();
+					} catch (e) {}
+					const newMaterial = new MeshBasicNodeMaterial({ transparent: true });
+					newMaterial.fragmentNode = composedNode;
+					newMaterial.needsUpdate = true;
+					mesh.material = newMaterial;
+					material = newMaterial;
+					needsMaterialRefresh = false;
+					lastComposedNodes = currentComposedNodes;
+				}
+			}
+		} catch (error) {
+			console.error("Error composing shader tree:", error);
+		} finally {
+			isUpdatingMaterial = false;
+		}
+		renderFrame().catch(console.warn);
+	};
+	const findChildNodes = (parentId) => {
+		const childIds = parentToChildren.get(parentId);
+		if (!childIds) return [];
+		const children = [];
+		for (const childId of childIds) {
+			const nodeInfo = nodeRegistry.nodes.get(childId);
+			if (nodeInfo) children.push(nodeInfo);
+		}
+		return children;
+	};
+	const findNodeByCustomId = (customId) => {
+		for (const [nodeId, info] of nodeRegistry.nodes.entries()) if (info.metadata.id === customId) return nodeId;
+		return null;
+	};
+	const applyMaskIfNeeded = (result, nodeInfo, nodeId, processedMasks, distortedUV) => {
+		if (!nodeInfo.metadata.mask?.source) return result;
+		const maskSourceId = nodeInfo.metadata.mask.source;
+		const maskNodeId = findNodeByCustomId(maskSourceId);
+		if (!maskNodeId) return result;
+		if (processedMasks.has(maskNodeId)) {
+			console.error(`Uh oh, looks like you've got a circular dependency in your shader masks.`);
+			return result;
+		}
+		const newProcessedMasks = new Set(processedMasks);
+		newProcessedMasks.add(nodeId);
+		const maskNode = composeNodeTree(maskNodeId, newProcessedMasks);
+		let finalMaskNode = maskNode;
+		if (distortedUV) finalMaskNode = trackConvertToTexture(maskNode).sample(distortedUV);
+		const maskType = nodeInfo.metadata.mask.type || "alpha";
+		return applyMask(result, finalMaskNode, maskType);
+	};
+	const applyNodeTransformation = (result, nodeInfo) => {
+		if (!nodeInfo.metadata.transform || !nodeInfo.transformUniforms || !needsTransformation(nodeInfo.metadata.transform) && !nodeInfo.transformRTTActive) return result;
+		const texture = trackConvertToTexture(result);
+		const transformedUV = applyUVTransform(screenUV, nodeInfo.transformUniforms.offsetX, nodeInfo.transformUniforms.offsetY, nodeInfo.transformUniforms.rotation, nodeInfo.transformUniforms.scale, nodeInfo.transformUniforms.anchorX, nodeInfo.transformUniforms.anchorY, nodeInfo.transformUniforms.aspectRatio);
+		return applyEdgeHandling(transformedUV, texture.sample(transformedUV), texture, nodeInfo.transformUniforms.edges);
+	};
+	const isUVComposable = (nodeInfo) => {
+		return !!nodeInfo.uvTransformFunc && nodeInfo.requiresChild && nodeInfo.metadata.blendMode === "normal" && (nodeInfo.metadata.opacity === void 0 || nodeInfo.metadata.opacity === 1) && nodeInfo.metadata.visible !== false && !nodeInfo.metadata.mask?.source && !(nodeInfo.transformUniforms && nodeInfo.metadata.transform && needsTransformation(nodeInfo.metadata.transform));
+	};
+	const findUVChain = (startNodeId) => {
+		const chain = [];
+		let currentId = startNodeId;
+		while (currentId) {
+			const nodeInfo = nodeRegistry.nodes.get(currentId);
+			if (!nodeInfo) break;
+			if (!isUVComposable(nodeInfo)) break;
+			chain.push(nodeInfo);
+			const children = findChildNodes(nodeInfo.id);
+			if (children.length !== 1) break;
+			const child = children[0];
+			if (isUVComposable(child)) currentId = child.id;
+			else break;
+		}
+		return chain;
+	};
+	const findUVChainTerminus = (chain) => {
+		if (chain.length === 0) return null;
+		const innermostNode = chain[chain.length - 1];
+		const children = findChildNodes(innermostNode.id);
+		if (children.length === 0) return null;
+		if (children.length === 1) return children[0];
+		return null;
+	};
+	const canSkipRTT = (distortionInfo) => {
+		if (!distortionInfo.uvTransformFunc) return false;
+		if (!isUVComposable(distortionInfo)) return false;
+		const children = findChildNodes(distortionInfo.id);
+		if (children.length !== 1) return false;
+		const child = children[0];
+		if (child.acceptsUVContext && !child.requiresChild) return true;
+		if (child.uvTransformFunc && isUVComposable(child)) return canSkipRTT(child);
+		return false;
+	};
+	const composeUVContextChain = (startNodeId, _processedMasks, currentlyComposedNodes) => {
+		const chain = [];
+		let currentId = startNodeId;
+		while (currentId) {
+			const nodeInfo = nodeRegistry.nodes.get(currentId);
+			if (!nodeInfo) break;
+			if (chain.length >= 2) return composeNodeTree(startNodeId, _processedMasks, currentlyComposedNodes, true);
+			chain.push(nodeInfo);
+			if (currentlyComposedNodes) currentlyComposedNodes.add(nodeInfo.id);
+			if (nodeInfo.acceptsUVContext && !nodeInfo.requiresChild) break;
+			const children = findChildNodes(currentId);
+			if (children.length !== 1) break;
+			currentId = children[0].id;
+		}
+		if (chain.length === 0) return vec4(0, 0, 0, 0);
+		const terminus = chain[chain.length - 1];
+		let composedUV = screenUV;
+		for (let i = 0; i < chain.length; i++) {
+			const nodeInfo = chain[i];
+			if (nodeInfo.uvTransformFunc) composedUV = nodeInfo.uvTransformFunc({
+				uv: composedUV,
+				uniforms: nodeInfo.uniforms,
+				viewportSize
+			});
+			if (nodeInfo.transformUniforms && nodeInfo.metadata.transform && needsTransformation(nodeInfo.metadata.transform)) {
+				composedUV = applyUVTransform(composedUV, nodeInfo.transformUniforms.offsetX, nodeInfo.transformUniforms.offsetY, nodeInfo.transformUniforms.rotation, nodeInfo.transformUniforms.scale, nodeInfo.transformUniforms.anchorX, nodeInfo.transformUniforms.anchorY, nodeInfo.transformUniforms.aspectRatio);
+				if (nodeInfo.transformUniforms.edges) composedUV = applyEdgeToUV(composedUV, nodeInfo.transformUniforms.edges);
+				nodeInfo.transformRTTActive = true;
+			}
+		}
+		for (let i = 0; i < chain.length - 1; i++) {
+			const distortion = chain[i];
+			if (!distortion.requiresChild) continue;
+			const distortionOnCleanup = (callback) => {
+				distortion.cleanupCallbacks.push(callback);
+			};
+			const distortionOnBeforeRender = (callback) => {
+				distortion.beforeRenderCallbacks.push(callback);
+			};
+			const distortionOnAfterRender = (callback) => {
+				distortion.afterRenderCallbacks.push(callback);
+			};
+			const distortionOnResize = (callback) => {
+				distortion.resizeCallbacks.push(callback);
+			};
+			distortion.cleanupCallbacks.forEach((callback) => {
+				try {
+					callback();
+				} catch (e) {
+					console.error("Error in cleanup callback:", e);
+				}
+			});
+			distortion.cleanupCallbacks = [];
+			distortion.beforeRenderCallbacks = [];
+			distortion.afterRenderCallbacks = [];
+			distortion.resizeCallbacks = [];
+			distortion.fragmentNodeFunc({
+				uniforms: distortion.uniforms ?? {},
+				childNode: void 0,
+				uvContext: void 0,
+				onCleanup: distortionOnCleanup,
+				onBeforeRender: distortionOnBeforeRender,
+				onAfterRender: distortionOnAfterRender,
+				onResize: distortionOnResize,
+				canvas: canvasElement,
+				dimensions: {
+					width: currentWidth,
+					height: currentHeight
+				},
+				renderer
+			});
+		}
+		const terminusOnCleanup = (callback) => {
+			terminus.cleanupCallbacks.push(callback);
+		};
+		const terminusOnBeforeRender = (callback) => {
+			terminus.beforeRenderCallbacks.push(callback);
+		};
+		const terminusOnAfterRender = (callback) => {
+			terminus.afterRenderCallbacks.push(callback);
+		};
+		const terminusOnResize = (callback) => {
+			terminus.resizeCallbacks.push(callback);
+		};
+		terminus.cleanupCallbacks.forEach((callback) => {
+			try {
+				callback();
+			} catch (e) {
+				console.error("Error in cleanup callback:", e);
+			}
+		});
+		terminus.cleanupCallbacks = [];
+		terminus.beforeRenderCallbacks = [];
+		terminus.afterRenderCallbacks = [];
+		terminus.resizeCallbacks = [];
+		const result = terminus.fragmentNodeFunc({
+			uniforms: terminus.uniforms ?? {},
+			childNode: void 0,
+			uvContext: composedUV,
+			onCleanup: terminusOnCleanup,
+			onBeforeRender: terminusOnBeforeRender,
+			onAfterRender: terminusOnAfterRender,
+			onResize: terminusOnResize,
+			canvas: canvasElement,
+			dimensions: {
+				width: currentWidth,
+				height: currentHeight
+			},
+			renderer
+		});
+		for (const nodeInfo of chain) if (nodeInfo.uniforms.edges?.uniform) return applyEdgeHandling(composedUV, result, null, nodeInfo.uniforms.edges.uniform);
+		return result;
+	};
+	const composeUVChain = (chain, processedMasks, currentlyComposedNodes) => {
+		if (chain.length === 0) return vec4(0, 0, 0, 0);
+		const terminus = findUVChainTerminus(chain);
+		let terminusNode;
+		if (terminus) terminusNode = composeNodeTree(terminus.id, processedMasks, currentlyComposedNodes);
+		else {
+			const innermostNode = chain[chain.length - 1];
+			if (findChildNodes(innermostNode.id).length === 0) return vec4(0, 0, 0, 0);
+			terminusNode = composeNodeTree(innermostNode.id, processedMasks, currentlyComposedNodes);
+		}
+		const texture = trackConvertToTexture(terminusNode);
+		let composedUV = screenUV;
+		for (let i = chain.length - 1; i >= 0; i--) {
+			const nodeInfo = chain[i];
+			if (nodeInfo.uvTransformFunc) {
+				composedUV = nodeInfo.uvTransformFunc({
+					uv: composedUV,
+					uniforms: nodeInfo.uniforms,
+					viewportSize
+				});
+				if (nodeInfo.uniforms.edges?.uniform) composedUV = applyEdgeToUV(composedUV, nodeInfo.uniforms.edges.uniform);
+			}
+			if (currentlyComposedNodes) currentlyComposedNodes.add(nodeInfo.id);
+		}
+		const sampledColor = texture.sample(composedUV);
+		const outermostNode = chain[0];
+		if (outermostNode.uniforms.edges?.uniform) return applyEdgeHandling(composedUV, sampledColor, texture, outermostNode.uniforms.edges.uniform);
+		return sampledColor;
+	};
+	const findSiblingUVChain = (sortedChildren, startIndex) => {
+		const chain = [];
+		for (let i = startIndex; i < sortedChildren.length; i++) {
+			const sibling = sortedChildren[i];
+			if (!isUVComposable(sibling)) break;
+			if (findChildNodes(sibling.id).length > 0) break;
+			chain.push(sibling);
+		}
+		return chain;
+	};
+	const composeSiblingUVChain = (chain, inputContent, currentlyComposedNodes) => {
+		if (chain.length === 0) return inputContent;
+		const texture = trackConvertToTexture(inputContent);
+		let composedUV = screenUV;
+		for (let i = chain.length - 1; i >= 0; i--) {
+			const nodeInfo = chain[i];
+			if (nodeInfo.uvTransformFunc) {
+				composedUV = nodeInfo.uvTransformFunc({
+					uv: composedUV,
+					uniforms: nodeInfo.uniforms,
+					viewportSize
+				});
+				if (nodeInfo.uniforms.edges?.uniform) composedUV = applyEdgeToUV(composedUV, nodeInfo.uniforms.edges.uniform);
+			}
+			if (currentlyComposedNodes) currentlyComposedNodes.add(nodeInfo.id);
+		}
+		const sampledColor = texture.sample(composedUV);
+		const lastNode = chain[chain.length - 1];
+		if (lastNode.uniforms.edges?.uniform) return applyEdgeHandling(composedUV, sampledColor, texture, lastNode.uniforms.edges.uniform);
+		return sampledColor;
+	};
+	const hasUVPropagationOpportunity = (sortedChildren) => {
+		const generators = [];
+		const distortions = [];
+		let hasGeneratorBeforeDistortion = false;
+		for (let i = 0; i < sortedChildren.length; i++) {
+			const child = sortedChildren[i];
+			const childHasChildren = findChildNodes(child.id).length > 0;
+			if (child.acceptsUVContext && !child.requiresChild) generators.push(i);
+			if (isUVComposable(child) && !childHasChildren) {
+				distortions.push(i);
+				if (generators.length > 0) hasGeneratorBeforeDistortion = true;
+			}
+		}
+		if (generators.length === 0 || distortions.length === 0 || !hasGeneratorBeforeDistortion) return false;
+		const minGen = Math.min(...generators);
+		const maxDist = Math.max(...distortions);
+		for (let i = minGen + 1; i < maxDist; i++) {
+			const node = sortedChildren[i];
+			if (node.requiresRTT && !isUVComposable(node) && !(node.acceptsUVContext && !node.requiresChild)) return false;
+		}
+		if (distortions.length > 2) return false;
+		return true;
+	};
+	const composeSiblingsWithUVContext = (sortedChildren, processedMasks, currentlyComposedNodes) => {
+		const generators = [];
+		const distortions = [];
+		sortedChildren.forEach((child, index) => {
+			const hasChildren = findChildNodes(child.id).length > 0;
+			if (isUVComposable(child) && !hasChildren) distortions.push({
+				node: child,
+				index
+			});
+			else if (child.acceptsUVContext && !child.requiresChild && !hasChildren) generators.push({
+				node: child,
+				index
+			});
+		});
+		for (const d of distortions) {
+			const distortion = d.node;
+			distortion.cleanupCallbacks.forEach((cb) => {
+				try {
+					cb();
+				} catch (e) {
+					console.error("Cleanup error:", e);
+				}
+			});
+			distortion.cleanupCallbacks = [];
+			distortion.beforeRenderCallbacks = [];
+			distortion.afterRenderCallbacks = [];
+			distortion.resizeCallbacks = [];
+			const onCleanup = (cb) => distortion.cleanupCallbacks.push(cb);
+			const onBeforeRender = (cb) => distortion.beforeRenderCallbacks.push(cb);
+			const onAfterRender = (cb) => distortion.afterRenderCallbacks.push(cb);
+			const onResize = (cb) => distortion.resizeCallbacks.push(cb);
+			distortion.fragmentNodeFunc({
+				uniforms: distortion.uniforms ?? {},
+				childNode: void 0,
+				uvContext: void 0,
+				onCleanup,
+				onBeforeRender,
+				onAfterRender,
+				onResize,
+				canvas: canvasElement,
+				dimensions: {
+					width: currentWidth,
+					height: currentHeight
+				},
+				renderer
+			});
+			if (currentlyComposedNodes) currentlyComposedNodes.add(distortion.id);
+		}
+		let composedResult = void 0;
+		for (let i = 0; i < sortedChildren.length; i++) {
+			const childInfo = sortedChildren[i];
+			if (childInfo.metadata.visible === false) continue;
+			const effectiveOpacity = childInfo.metadata.opacity ?? 1;
+			childInfo.opacityUniform.value = effectiveOpacity;
+			if (currentlyComposedNodes) currentlyComposedNodes.add(childInfo.id);
+			const hasChildren = findChildNodes(childInfo.id).length > 0;
+			let childResult;
+			const genEntry = generators.find((g) => g.index === i);
+			if (genEntry) {
+				const applicableDistortions = distortions.filter((d) => d.index > genEntry.index).sort((a, b) => a.index - b.index).map((d) => d.node);
+				let composedUV = screenUV;
+				for (let j = applicableDistortions.length - 1; j >= 0; j--) {
+					const distortion = applicableDistortions[j];
+					if (distortion.uvTransformFunc) composedUV = distortion.uvTransformFunc({
+						uv: composedUV,
+						uniforms: distortion.uniforms,
+						viewportSize
+					});
+					if (distortion.transformUniforms && distortion.metadata.transform && needsTransformation(distortion.metadata.transform)) {
+						composedUV = applyUVTransform(composedUV, distortion.transformUniforms.offsetX, distortion.transformUniforms.offsetY, distortion.transformUniforms.rotation, distortion.transformUniforms.scale, distortion.transformUniforms.anchorX, distortion.transformUniforms.anchorY, distortion.transformUniforms.aspectRatio);
+						if (distortion.transformUniforms.edges) composedUV = applyEdgeToUV(composedUV, distortion.transformUniforms.edges);
+						distortion.transformRTTActive = true;
+					}
+					if (distortion.uniforms.edges?.uniform) composedUV = applyEdgeToUV(composedUV, distortion.uniforms.edges.uniform);
+				}
+				if (genEntry.node.transformUniforms && genEntry.node.metadata.transform && needsTransformation(genEntry.node.metadata.transform)) {
+					composedUV = applyUVTransform(composedUV, genEntry.node.transformUniforms.offsetX, genEntry.node.transformUniforms.offsetY, genEntry.node.transformUniforms.rotation, genEntry.node.transformUniforms.scale, genEntry.node.transformUniforms.anchorX, genEntry.node.transformUniforms.anchorY, genEntry.node.transformUniforms.aspectRatio);
+					if (genEntry.node.transformUniforms.edges) composedUV = applyEdgeToUV(composedUV, genEntry.node.transformUniforms.edges);
+					genEntry.node.transformRTTActive = true;
+				}
+				childInfo.cleanupCallbacks.forEach((cb) => {
+					try {
+						cb();
+					} catch (e) {
+						console.error("Cleanup error:", e);
+					}
+				});
+				childInfo.cleanupCallbacks = [];
+				childInfo.beforeRenderCallbacks = [];
+				childInfo.afterRenderCallbacks = [];
+				childInfo.resizeCallbacks = [];
+				const onCleanup = (cb) => childInfo.cleanupCallbacks.push(cb);
+				const onBeforeRender = (cb) => childInfo.beforeRenderCallbacks.push(cb);
+				const onAfterRender = (cb) => childInfo.afterRenderCallbacks.push(cb);
+				const onResize = (cb) => childInfo.resizeCallbacks.push(cb);
+				let fragmentResult = childInfo.fragmentNodeFunc({
+					uniforms: childInfo.uniforms ?? {},
+					childNode: void 0,
+					uvContext: composedUV,
+					onCleanup,
+					onBeforeRender,
+					onAfterRender,
+					onResize,
+					canvas: canvasElement,
+					dimensions: {
+						width: currentWidth,
+						height: currentHeight
+					},
+					renderer
+				});
+				if (applicableDistortions.length > 0) {
+					const outermostDistortion = applicableDistortions[0];
+					if (outermostDistortion.uniforms.edges?.uniform) fragmentResult = applyEdgeHandling(composedUV, fragmentResult, null, outermostDistortion.uniforms.edges.uniform);
+				}
+				childResult = applyMaskIfNeeded(fragmentResult, childInfo, childInfo.id, processedMasks, composedUV);
+			} else if (distortions.find((d) => d.index === i)) continue;
+			else if (hasChildren) {
+				if (canSkipRTT(childInfo)) childResult = composeUVContextChain(childInfo.id, processedMasks, currentlyComposedNodes);
+				else if (isUVComposable(childInfo)) {
+					const uvChain = findUVChain(childInfo.id);
+					if (uvChain.length > 1) childResult = composeUVChain(uvChain, processedMasks, currentlyComposedNodes);
+					else childResult = composeNodeTree(childInfo.id, processedMasks, currentlyComposedNodes);
+				} else childResult = composeNodeTree(childInfo.id, processedMasks, currentlyComposedNodes);
+				const applicableDistortions = distortions.filter((d) => d.index > i).sort((a, b) => a.index - b.index).map((d) => d.node);
+				if (applicableDistortions.length > 0) {
+					const childTexture = trackConvertToTexture(childResult);
+					let composedUV = screenUV;
+					for (let j = applicableDistortions.length - 1; j >= 0; j--) {
+						const distortion = applicableDistortions[j];
+						if (distortion.uvTransformFunc) composedUV = distortion.uvTransformFunc({
+							uv: composedUV,
+							uniforms: distortion.uniforms,
+							viewportSize
+						});
+						if (distortion.transformUniforms && distortion.metadata.transform && needsTransformation(distortion.metadata.transform)) {
+							composedUV = applyUVTransform(composedUV, distortion.transformUniforms.offsetX, distortion.transformUniforms.offsetY, distortion.transformUniforms.rotation, distortion.transformUniforms.scale, distortion.transformUniforms.anchorX, distortion.transformUniforms.anchorY, distortion.transformUniforms.aspectRatio);
+							if (distortion.transformUniforms.edges) composedUV = applyEdgeToUV(composedUV, distortion.transformUniforms.edges);
+							distortion.transformRTTActive = true;
+						}
+						if (distortion.uniforms.edges?.uniform) composedUV = applyEdgeToUV(composedUV, distortion.uniforms.edges.uniform);
+					}
+					childResult = childTexture.sample(composedUV);
+					const outermostDistortion = applicableDistortions[applicableDistortions.length - 1];
+					if (outermostDistortion.transformUniforms?.edges) childResult = applyEdgeHandling(composedUV, childResult, childTexture, outermostDistortion.transformUniforms.edges);
+				}
+			} else {
+				childInfo.cleanupCallbacks.forEach((cb) => {
+					try {
+						cb();
+					} catch (e) {
+						console.error("Cleanup error:", e);
+					}
+				});
+				childInfo.cleanupCallbacks = [];
+				childInfo.beforeRenderCallbacks = [];
+				childInfo.afterRenderCallbacks = [];
+				childInfo.resizeCallbacks = [];
+				const onCleanup = (cb) => childInfo.cleanupCallbacks.push(cb);
+				const onBeforeRender = (cb) => childInfo.beforeRenderCallbacks.push(cb);
+				const onAfterRender = (cb) => childInfo.afterRenderCallbacks.push(cb);
+				const onResize = (cb) => childInfo.resizeCallbacks.push(cb);
+				let effectiveChildNode = composedResult;
+				if (childInfo.requiresRTT && composedResult !== void 0) effectiveChildNode = applyBlendMode(vec4(0, 0, 0, 0), composedResult, "normal", 1);
+				childResult = applyMaskIfNeeded(applyNodeTransformation(childInfo.fragmentNodeFunc({
+					uniforms: childInfo.uniforms ?? {},
+					childNode: effectiveChildNode,
+					onCleanup,
+					onBeforeRender,
+					onAfterRender,
+					onResize,
+					canvas: canvasElement,
+					dimensions: {
+						width: currentWidth,
+						height: currentHeight
+					},
+					renderer
+				}), childInfo), childInfo, childInfo.id, processedMasks);
+			}
+			if (childInfo.requiresChild && childInfo.metadata.blendMode === "normal" && !hasChildren) composedResult = applyBlendMode(vec4(0, 0, 0, 0), childResult, "normal", childInfo.opacityUniform);
+			else if (composedResult === void 0) composedResult = applyBlendMode(vec4(1, 1, 1, 0), childResult, childInfo.metadata.blendMode, childInfo.opacityUniform);
+			else composedResult = applyBlendMode(composedResult, childResult, childInfo.metadata.blendMode, childInfo.opacityUniform);
+		}
+		return composedResult ?? vec4(0, 0, 0, 0);
+	};
+	const composeNodeTree = (nodeId, processedMasks = /* @__PURE__ */ new Set(), currentlyComposedNodes, forceRTT = false) => {
+		if (currentWidth === 0 || currentHeight === 0) return vec4(0, 0, 0, 0);
+		const nodeInfo = nodeRegistry.nodes.get(nodeId);
+		if (!nodeInfo) return vec4(0, 0, 0, 0);
+		const nodeSpecificOnCleanup = (callback) => {
+			nodeInfo.cleanupCallbacks.push(callback);
+		};
+		const nodeSpecificOnBeforeRender = (callback) => {
+			nodeInfo.beforeRenderCallbacks.push(callback);
+		};
+		const nodeSpecificOnAfterRender = (callback) => {
+			nodeInfo.afterRenderCallbacks.push(callback);
+		};
+		const nodeSpecificOnResize = (callback) => {
+			nodeInfo.resizeCallbacks.push(callback);
+		};
+		const childNodes = findChildNodes(nodeId);
+		if (childNodes.length === 0) {
+			nodeInfo.cleanupCallbacks.forEach((callback) => {
+				try {
+					callback();
+				} catch (e) {
+					console.error("Error in cleanup callback:", e);
+				}
+			});
+			nodeInfo.cleanupCallbacks = [];
+			nodeInfo.beforeRenderCallbacks = [];
+			nodeInfo.afterRenderCallbacks = [];
+			nodeInfo.resizeCallbacks = [];
+			return applyMaskIfNeeded(applyNodeTransformation(nodeInfo.fragmentNodeFunc({
+				uniforms: nodeInfo.uniforms ?? {},
+				childNode: void 0,
+				onCleanup: nodeSpecificOnCleanup,
+				onBeforeRender: nodeSpecificOnBeforeRender,
+				onAfterRender: nodeSpecificOnAfterRender,
+				onResize: nodeSpecificOnResize,
+				canvas: canvasElement,
+				dimensions: {
+					width: currentWidth,
+					height: currentHeight
+				},
+				renderer
+			}), nodeInfo), nodeInfo, nodeId, processedMasks);
+		} else {
+			const sortedChildren = [...childNodes].sort((a, b) => a.metadata.renderOrder - b.metadata.renderOrder);
+			if (nodeInfo.parentId === null) {
+				if (!forceRTT && hasUVPropagationOpportunity(sortedChildren)) return applyMaskIfNeeded(applyNodeTransformation(composeSiblingsWithUVContext(sortedChildren, processedMasks, currentlyComposedNodes), nodeInfo), nodeInfo, nodeId, processedMasks);
+				let composedChildren = void 0;
+				for (let i = 0; i < sortedChildren.length; i++) {
+					const childInfo = sortedChildren[i];
+					let effectiveOpacity;
+					if (childInfo.metadata.opacity === void 0) {
+						effectiveOpacity = 1;
+						childInfo.opacityUniform.value = effectiveOpacity;
+					} else {
+						effectiveOpacity = childInfo.metadata.opacity;
+						childInfo.opacityUniform.value = effectiveOpacity;
+					}
+					if (childInfo.metadata.visible === false) continue;
+					if (currentlyComposedNodes) currentlyComposedNodes.add(childInfo.id);
+					const childHasChildren = findChildNodes(childInfo.id).length > 0;
+					let childResult;
+					if (childHasChildren) if (forceRTT) childResult = composeNodeTree(childInfo.id, processedMasks, currentlyComposedNodes, true);
+					else if (canSkipRTT(childInfo)) childResult = composeUVContextChain(childInfo.id, processedMasks, currentlyComposedNodes);
+					else if (isUVComposable(childInfo)) {
+						const uvChain = findUVChain(childInfo.id);
+						if (uvChain.length > 1) childResult = composeUVChain(uvChain, processedMasks, currentlyComposedNodes);
+						else childResult = composeNodeTree(childInfo.id, processedMasks, currentlyComposedNodes);
+					} else childResult = composeNodeTree(childInfo.id, processedMasks, currentlyComposedNodes);
+					else {
+						if (isUVComposable(childInfo) && childInfo.requiresChild && composedChildren !== void 0) {
+							const siblingChain = findSiblingUVChain(sortedChildren, i);
+							if (siblingChain.length > 1) {
+								childResult = composeSiblingUVChain(siblingChain, composedChildren, currentlyComposedNodes);
+								i += siblingChain.length - 1;
+								composedChildren = childResult;
+								continue;
+							}
+						}
+						{
+							const childSpecificOnCleanup = (callback) => {
+								childInfo.cleanupCallbacks.push(callback);
+							};
+							const childSpecificOnBeforeRender = (callback) => {
+								childInfo.beforeRenderCallbacks.push(callback);
+							};
+							const childSpecificOnAfterRender = (callback) => {
+								childInfo.afterRenderCallbacks.push(callback);
+							};
+							const childSpecificOnResize = (callback) => {
+								childInfo.resizeCallbacks.push(callback);
+							};
+							let effectiveChildNode = composedChildren;
+							if (childInfo.requiresRTT && composedChildren !== void 0) effectiveChildNode = applyBlendMode(vec4(0, 0, 0, 0), composedChildren, "normal", 1);
+							childInfo.cleanupCallbacks.forEach((callback) => {
+								try {
+									callback();
+								} catch (e) {
+									console.error("Error in cleanup callback:", e);
+								}
+							});
+							childInfo.cleanupCallbacks = [];
+							childInfo.beforeRenderCallbacks = [];
+							childInfo.afterRenderCallbacks = [];
+							childInfo.resizeCallbacks = [];
+							childResult = applyMaskIfNeeded(applyNodeTransformation(childInfo.fragmentNodeFunc({
+								uniforms: childInfo.uniforms ?? {},
+								childNode: effectiveChildNode,
+								onCleanup: childSpecificOnCleanup,
+								onBeforeRender: childSpecificOnBeforeRender,
+								onAfterRender: childSpecificOnAfterRender,
+								onResize: childSpecificOnResize,
+								canvas: canvasElement,
+								dimensions: {
+									width: currentWidth,
+									height: currentHeight
+								},
+								renderer
+							}), childInfo), childInfo, childInfo.id, processedMasks);
+						}
+					}
+					if (childInfo.requiresChild && childInfo.metadata.blendMode === "normal" && !childHasChildren) composedChildren = applyBlendMode(vec4(0, 0, 0, 0), childResult, "normal", childInfo.opacityUniform);
+					else if (composedChildren === void 0) if (nodeInfo.requiresRTT || effectiveOpacity !== 1) composedChildren = applyBlendMode(vec4(1, 1, 1, 0), childResult, childInfo.metadata.blendMode, childInfo.opacityUniform);
+					else composedChildren = childResult;
+					else composedChildren = applyBlendMode(composedChildren, childResult, childInfo.metadata.blendMode, childInfo.opacityUniform);
+				}
+				nodeInfo.cleanupCallbacks.forEach((callback) => {
+					try {
+						callback();
+					} catch (e) {
+						console.error("Error in cleanup callback:", e);
+					}
+				});
+				nodeInfo.cleanupCallbacks = [];
+				nodeInfo.beforeRenderCallbacks = [];
+				nodeInfo.afterRenderCallbacks = [];
+				nodeInfo.resizeCallbacks = [];
+				return applyMaskIfNeeded(applyNodeTransformation(nodeInfo.fragmentNodeFunc({
+					uniforms: nodeInfo.uniforms ?? {},
+					childNode: composedChildren,
+					onCleanup: nodeSpecificOnCleanup,
+					onBeforeRender: nodeSpecificOnBeforeRender,
+					onAfterRender: nodeSpecificOnAfterRender,
+					onResize: nodeSpecificOnResize,
+					canvas: canvasElement,
+					dimensions: {
+						width: currentWidth,
+						height: currentHeight
+					},
+					renderer
+				}), nodeInfo), nodeInfo, nodeId, processedMasks);
+			} else {
+				if (!forceRTT && hasUVPropagationOpportunity(sortedChildren)) {
+					const composedChildrenResult$1 = composeSiblingsWithUVContext(sortedChildren, processedMasks, currentlyComposedNodes);
+					return applyMaskIfNeeded(applyNodeTransformation(nodeInfo.fragmentNodeFunc({
+						uniforms: nodeInfo.uniforms ?? {},
+						childNode: composedChildrenResult$1,
+						onCleanup: nodeSpecificOnCleanup,
+						onBeforeRender: nodeSpecificOnBeforeRender,
+						onAfterRender: nodeSpecificOnAfterRender,
+						onResize: nodeSpecificOnResize,
+						canvas: canvasElement,
+						dimensions: {
+							width: currentWidth,
+							height: currentHeight
+						},
+						renderer
+					}), nodeInfo), nodeInfo, nodeId, processedMasks);
+				}
+				let composedChildrenResult = void 0;
+				for (let i = 0; i < sortedChildren.length; i++) {
+					const childInfo = sortedChildren[i];
+					let effectiveOpacity;
+					if (childInfo.metadata.opacity === void 0) {
+						effectiveOpacity = 1;
+						childInfo.opacityUniform.value = effectiveOpacity;
+					} else {
+						effectiveOpacity = childInfo.metadata.opacity;
+						childInfo.opacityUniform.value = effectiveOpacity;
+					}
+					if (childInfo.metadata.visible === false) continue;
+					if (currentlyComposedNodes) currentlyComposedNodes.add(childInfo.id);
+					const childHasChildren = findChildNodes(childInfo.id).length > 0;
+					let childResult;
+					if (childHasChildren) if (forceRTT) childResult = composeNodeTree(childInfo.id, processedMasks, currentlyComposedNodes, true);
+					else if (canSkipRTT(childInfo)) childResult = composeUVContextChain(childInfo.id, processedMasks, currentlyComposedNodes);
+					else if (isUVComposable(childInfo)) {
+						const uvChain = findUVChain(childInfo.id);
+						if (uvChain.length > 1) childResult = composeUVChain(uvChain, processedMasks, currentlyComposedNodes);
+						else childResult = composeNodeTree(childInfo.id, processedMasks, currentlyComposedNodes);
+					} else childResult = composeNodeTree(childInfo.id, processedMasks, currentlyComposedNodes);
+					else {
+						if (isUVComposable(childInfo) && childInfo.requiresChild && composedChildrenResult !== void 0) {
+							const siblingChain = findSiblingUVChain(sortedChildren, i);
+							if (siblingChain.length > 1) {
+								childResult = composeSiblingUVChain(siblingChain, composedChildrenResult, currentlyComposedNodes);
+								i += siblingChain.length - 1;
+								composedChildrenResult = childResult;
+								continue;
+							}
+						}
+						{
+							const childSpecificOnCleanup = (callback) => {
+								childInfo.cleanupCallbacks.push(callback);
+							};
+							const childSpecificOnBeforeRender = (callback) => {
+								childInfo.beforeRenderCallbacks.push(callback);
+							};
+							const childSpecificOnAfterRender = (callback) => {
+								childInfo.afterRenderCallbacks.push(callback);
+							};
+							const childSpecificOnResize = (callback) => {
+								childInfo.resizeCallbacks.push(callback);
+							};
+							let effectiveChildNode = composedChildrenResult;
+							if (childInfo.requiresRTT && composedChildrenResult !== void 0) effectiveChildNode = applyBlendMode(vec4(0, 0, 0, 0), composedChildrenResult, "normal", 1);
+							childInfo.cleanupCallbacks = [];
+							childInfo.beforeRenderCallbacks = [];
+							childInfo.afterRenderCallbacks = [];
+							childInfo.resizeCallbacks = [];
+							childResult = applyMaskIfNeeded(applyNodeTransformation(childInfo.fragmentNodeFunc({
+								uniforms: childInfo.uniforms ?? {},
+								childNode: effectiveChildNode,
+								onCleanup: childSpecificOnCleanup,
+								onBeforeRender: childSpecificOnBeforeRender,
+								onAfterRender: childSpecificOnAfterRender,
+								onResize: childSpecificOnResize,
+								canvas: canvasElement,
+								dimensions: {
+									width: currentWidth,
+									height: currentHeight
+								},
+								renderer
+							}), childInfo), childInfo, childInfo.id, processedMasks);
+						}
+					}
+					if (childInfo.requiresChild && childInfo.metadata.blendMode === "normal" && !childHasChildren) composedChildrenResult = applyBlendMode(vec4(0, 0, 0, 0), childResult, "normal", childInfo.opacityUniform);
+					else if (composedChildrenResult === void 0) if (nodeInfo.requiresRTT || effectiveOpacity !== 1) composedChildrenResult = applyBlendMode(vec4(1, 1, 1, 0), childResult, childInfo.metadata.blendMode, childInfo.opacityUniform);
+					else composedChildrenResult = childResult;
+					else composedChildrenResult = applyBlendMode(composedChildrenResult, childResult, childInfo.metadata.blendMode, childInfo.opacityUniform);
+				}
+				nodeInfo.cleanupCallbacks.forEach((callback) => {
+					try {
+						callback();
+					} catch (e) {
+						console.error("Error in cleanup callback:", e);
+					}
+				});
+				nodeInfo.cleanupCallbacks = [];
+				nodeInfo.beforeRenderCallbacks = [];
+				nodeInfo.afterRenderCallbacks = [];
+				nodeInfo.resizeCallbacks = [];
+				return applyMaskIfNeeded(applyNodeTransformation(nodeInfo.fragmentNodeFunc({
+					uniforms: nodeInfo.uniforms ?? {},
+					childNode: composedChildrenResult,
+					onCleanup: nodeSpecificOnCleanup,
+					onBeforeRender: nodeSpecificOnBeforeRender,
+					onAfterRender: nodeSpecificOnAfterRender,
+					onResize: nodeSpecificOnResize,
+					canvas: canvasElement,
+					dimensions: {
+						width: currentWidth,
+						height: currentHeight
+					},
+					renderer
+				}), nodeInfo), nodeInfo, nodeId, processedMasks);
+			}
+		}
+	};
+	const registerNode = (id, fragmentNodeFunc, parentId, metadata, uniforms = {}, componentDefinition$55) => {
+		if (fragmentNodeFunc === null) {
+			const queueIndex = pendingRegistrationQueue.findIndex((item) => item.id === id);
+			if (queueIndex !== -1) {
+				pendingRegistrationQueue.splice(queueIndex, 1);
+				return;
+			}
+			removeNode(id);
+			return;
+		}
+		if (!isRendererReady) {
+			const existing = pendingRegistrationQueue.findIndex((item) => item.id === id);
+			if (existing !== -1) pendingRegistrationQueue[existing] = {
+				id,
+				fragmentNodeFunc,
+				parentId,
+				metadata,
+				uniforms,
+				componentDefinition: componentDefinition$55
+			};
+			else pendingRegistrationQueue.push({
+				id,
+				fragmentNodeFunc,
+				parentId,
+				metadata,
+				uniforms,
+				componentDefinition: componentDefinition$55
+			});
+			return;
+		}
+		let defaultRenderOrder = 0;
+		if (parentId !== null) {
+			const siblings = parentToChildren.get(parentId);
+			if (siblings && siblings.size > 0) {
+				let maxOrder = 0;
+				for (const siblingId of siblings) {
+					const sibling = nodeRegistry.nodes.get(siblingId);
+					if (sibling && sibling.metadata.renderOrder > maxOrder) maxOrder = sibling.metadata.renderOrder;
+				}
+				defaultRenderOrder = maxOrder + 1;
+			}
+		}
+		const opacityUniform = uniform(metadata?.opacity !== void 0 ? metadata.opacity : 1);
+		let transformUniforms = void 0;
+		if (metadata?.transform) {
+			const aspectRatio = currentWidth / Math.max(1, currentHeight);
+			transformUniforms = {
+				offsetX: uniform(metadata.transform.offsetX),
+				offsetY: uniform(metadata.transform.offsetY),
+				rotation: uniform(metadata.transform.rotation),
+				scale: uniform(metadata.transform.scale),
+				anchorX: uniform(metadata.transform.anchorX),
+				anchorY: uniform(metadata.transform.anchorY),
+				edges: uniform(metadata.transform.edges === "stretch" ? 0 : metadata.transform.edges === "transparent" ? 1 : metadata.transform.edges === "mirror" ? 2 : 3),
+				aspectRatio: uniform(aspectRatio)
+			};
+		}
+		const nodeInfo = {
+			id,
+			componentName: componentDefinition$55?.name || "Unknown",
+			fragmentNodeFunc,
+			parentId,
+			requiresRTT: componentDefinition$55?.requiresRTT || false,
+			requiresChild: componentDefinition$55?.requiresChild || false,
+			opacityUniform,
+			metadata: {
+				blendMode: metadata?.blendMode || "normal",
+				opacity: metadata?.opacity,
+				visible: metadata?.visible === false ? false : true,
+				id: metadata?.id,
+				mask: metadata?.mask,
+				renderOrder: metadata?.renderOrder !== void 0 ? metadata?.renderOrder : defaultRenderOrder,
+				transform: metadata?.transform
+			},
+			uniforms,
+			cleanupCallbacks: [],
+			beforeRenderCallbacks: [],
+			afterRenderCallbacks: [],
+			resizeCallbacks: [],
+			transformUniforms,
+			transformRTTActive: false,
+			uvTransformFunc: componentDefinition$55?.uvTransformNode,
+			acceptsUVContext: componentDefinition$55?.acceptsUVContext || false
+		};
+		nodeRegistry.nodes.set(id, nodeInfo);
+		if (parentId === null) nodeRegistry.rootId = id;
+		const childrenSet = parentToChildren.get(parentId) || /* @__PURE__ */ new Set();
+		childrenSet.add(id);
+		parentToChildren.set(parentId, childrenSet);
+		if (material && isInitialized && currentWidth > 0 && currentHeight > 0) {
+			if (!registrationQueue.includes(id)) registrationQueue.push(id);
+			if (registrationBatchRAF === null) registrationBatchRAF = requestAnimationFrame(() => {
+				registrationBatchRAF = null;
+				registrationQueue = [];
+				updateMaterial();
+			});
+		} else if (material && isInitialized) {
+			if (!materialUpdatePending) {
+				materialUpdatePending = true;
+				requestAnimationFrame(() => {
+					materialUpdatePending = false;
+					if (currentWidth > 0 && currentHeight > 0) updateMaterial();
+				});
+			}
+		}
+	};
+	const updateUniformValue$1 = (nodeId, uniformName, value) => {
+		const nodeInfo = nodeRegistry.nodes.get(nodeId);
+		if (!nodeInfo || !nodeInfo.uniforms) return;
+		const uniformDefinition = nodeInfo.uniforms[uniformName];
+		if (!uniformDefinition || !uniformDefinition.uniform) return;
+		if (uniformDefinition.transform) updateUniformValue(uniformDefinition, value);
+		else uniformDefinition.uniform.value = value;
+		renderFrame();
+	};
+	const updateNodeMetadata = (nodeId, metadata) => {
+		const existingNode = nodeRegistry.nodes.get(nodeId);
+		if (!existingNode) return;
+		let needsRecompose = false;
+		if (metadata.blendMode !== void 0 && existingNode.metadata.blendMode !== metadata.blendMode) {
+			existingNode.metadata.blendMode = metadata.blendMode;
+			needsRecompose = true;
+		}
+		if (metadata.opacity !== void 0 && existingNode.metadata.opacity !== metadata.opacity) {
+			existingNode.metadata.opacity = metadata.opacity;
+			existingNode.opacityUniform.value = metadata.opacity;
+		}
+		if (metadata.renderOrder !== void 0 && existingNode.metadata.renderOrder !== metadata.renderOrder) {
+			existingNode.metadata.renderOrder = metadata.renderOrder;
+			needsRecompose = true;
+		}
+		const newVisible = metadata.visible === false ? false : true;
+		if (existingNode.metadata.visible !== newVisible) {
+			existingNode.metadata.visible = newVisible;
+			needsRecompose = true;
+		}
+		if (metadata.id !== void 0 && existingNode.metadata.id !== metadata.id) {
+			existingNode.metadata.id = metadata.id;
+			needsRecompose = true;
+		}
+		if (metadata.mask !== void 0 && (existingNode.metadata.mask?.source !== metadata.mask?.source || existingNode.metadata.mask?.type !== metadata.mask?.type)) {
+			existingNode.metadata.mask = metadata.mask;
+			needsRecompose = true;
+		}
+		if (metadata.transform !== void 0) {
+			const oldTransformState = existingNode.metadata.transform ? needsTransformation(existingNode.metadata.transform) : false;
+			const newTransformState = needsTransformation(metadata.transform);
+			existingNode.metadata.transform = metadata.transform;
+			if (!existingNode.transformUniforms && metadata.transform) {
+				const aspectRatio = currentWidth / Math.max(1, currentHeight);
+				existingNode.transformUniforms = {
+					offsetX: uniform(metadata.transform.offsetX),
+					offsetY: uniform(metadata.transform.offsetY),
+					rotation: uniform(metadata.transform.rotation),
+					scale: uniform(metadata.transform.scale),
+					anchorX: uniform(metadata.transform.anchorX),
+					anchorY: uniform(metadata.transform.anchorY),
+					edges: uniform(metadata.transform.edges === "stretch" ? 0 : metadata.transform.edges === "transparent" ? 1 : metadata.transform.edges === "mirror" ? 2 : 3),
+					aspectRatio: uniform(aspectRatio)
+				};
+			} else if (existingNode.transformUniforms) {
+				existingNode.transformUniforms.offsetX.value = metadata.transform.offsetX;
+				existingNode.transformUniforms.offsetY.value = metadata.transform.offsetY;
+				existingNode.transformUniforms.rotation.value = metadata.transform.rotation;
+				existingNode.transformUniforms.scale.value = metadata.transform.scale;
+				existingNode.transformUniforms.anchorX.value = metadata.transform.anchorX;
+				existingNode.transformUniforms.anchorY.value = metadata.transform.anchorY;
+				existingNode.transformUniforms.edges.value = metadata.transform.edges === "stretch" ? 0 : metadata.transform.edges === "transparent" ? 1 : metadata.transform.edges === "mirror" ? 2 : 3;
+			}
+			if (newTransformState && !existingNode.transformRTTActive) {
+				existingNode.transformRTTActive = true;
+				needsRecompose = true;
+			}
+			if (!oldTransformState && newTransformState && !existingNode.transformRTTActive) needsRecompose = true;
+		}
+		if (needsRecompose && material && isInitialized) {
+			if (!metadataUpdateQueue.includes(nodeId)) metadataUpdateQueue.push(nodeId);
+			if (metadataUpdateBatchRAF === null) metadataUpdateBatchRAF = requestAnimationFrame(() => {
+				metadataUpdateBatchRAF = null;
+				metadataUpdateQueue = [];
+				updateMaterial();
+			});
+		} else renderFrame();
+	};
+	const removeNode = (id) => {
+		if (!nodeRegistry.nodes.has(id)) return;
+		const nodeInfo = nodeRegistry.nodes.get(id);
+		if (nodeInfo && nodeInfo.cleanupCallbacks.length > 0) for (const callback of nodeInfo.cleanupCallbacks) try {
+			callback();
+		} catch (e) {
+			console.error(`Error executing cleanup callback for node ${id}:`, e);
+		}
+		const childNodes = findChildNodes(id);
+		for (const child of childNodes) removeNode(child.id);
+		if (nodeRegistry.rootId === id) nodeRegistry.rootId = null;
+		if (nodeInfo) {
+			const childrenSet = parentToChildren.get(nodeInfo.parentId);
+			if (childrenSet) {
+				childrenSet.delete(id);
+				if (childrenSet.size === 0) parentToChildren.delete(nodeInfo.parentId);
+			}
+		}
+		nodeRegistry.nodes.delete(id);
+		if (material && isInitialized) updateMaterial();
+	};
+	const executeBeforeRenderCallbacks = (deltaTime) => {
+		const params = {
+			deltaTime,
+			pointer: {
+				x: pointerX,
+				y: pointerY
+			},
+			pointerActive,
+			dimensions: {
+				width: currentWidth,
+				height: currentHeight
+			}
+		};
+		for (const nodeInfo of nodeRegistry.nodes.values()) if (nodeInfo.beforeRenderCallbacks.length > 0) for (const callback of nodeInfo.beforeRenderCallbacks) try {
+			callback(params);
+		} catch (e) {
+			console.error(`Error executing before render callback for node ${nodeInfo.id}:`, e);
+		}
+	};
+	const executeAfterRenderCallbacks = (deltaTime) => {
+		const params = {
+			deltaTime,
+			pointer: {
+				x: pointerX,
+				y: pointerY
+			},
+			pointerActive,
+			dimensions: {
+				width: currentWidth,
+				height: currentHeight
+			}
+		};
+		for (const nodeInfo of nodeRegistry.nodes.values()) if (nodeInfo.afterRenderCallbacks.length > 0) for (const callback of nodeInfo.afterRenderCallbacks) try {
+			callback(params);
+		} catch (e) {
+			console.error(`Error executing after render callback for node ${nodeInfo.id}:`, e);
+		}
+	};
+	const renderFrame = async () => {
+		if (!canRender()) return;
+		const frameStartTime = enablePerformanceTracking ? performance.now() : 0;
+		const currentTime = frameStartTime || performance.now();
+		const deltaTime = lastRenderTime > 0 ? (currentTime - lastRenderTime) / 1e3 : .016;
+		const OFF_SCREEN_FPS_INTERVAL = 1e3;
+		if (!isVisible && lastRenderTime > 0) {
+			if (currentTime - lastRenderTime < OFF_SCREEN_FPS_INTERVAL) return;
+		}
+		const cappedDeltaTime = Math.min(deltaTime, .1);
+		lastRenderTime = currentTime;
+		if (enablePerformanceTracking) performance.mark("shader-cpu-start");
+		executeBeforeRenderCallbacks(cappedDeltaTime);
+		try {
+			if (isUpdatingMaterial) return;
+			if (enablePerformanceTracking) performance.mark("shader-gpu-start");
+			renderer.render(scene, camera);
+			executeAfterRenderCallbacks(cappedDeltaTime);
+			if (enablePerformanceTracking) {
+				performance.mark("shader-gpu-end");
+				if (renderer instanceof WebGPURenderer) try {
+					const backend = renderer.backend;
+					if (backend && backend.get && backend.get(renderer)) {
+						const renderContext = backend.get(renderer);
+						if (renderContext?.timestampQuery) {
+							const gpuTime = renderContext.timestampQuery.getResult();
+							if (gpuTime !== null && gpuTime !== void 0) performanceTracker.recordGpuTime(gpuTime / 1e6);
+						}
+					}
+				} catch (e) {}
+				try {
+					performance.measure("shader-gpu-time", "shader-gpu-start", "shader-gpu-end");
+					const gpuMeasure = performance.getEntriesByName("shader-gpu-time")[0];
+					if (gpuMeasure) performanceTracker.recordGpuTime(gpuMeasure.duration);
+					performance.clearMarks("shader-gpu-start");
+					performance.clearMarks("shader-gpu-end");
+					performance.clearMeasures("shader-gpu-time");
+				} catch (e) {}
+			}
+			if (enablePerformanceTracking) {
+				performance.mark("shader-cpu-end");
+				try {
+					performance.measure("shader-cpu-time", "shader-cpu-start", "shader-cpu-end");
+					const cpuMeasure = performance.getEntriesByName("shader-cpu-time")[0];
+					if (cpuMeasure) performanceTracker.recordCpuTime(cpuMeasure.duration);
+					performance.clearMarks("shader-cpu-start");
+					performance.clearMarks("shader-cpu-end");
+					performance.clearMeasures("shader-cpu-time");
+				} catch (e) {}
+				const frameTime = performance.now() - frameStartTime;
+				performanceTracker.recordFrame(frameTime);
+			}
+		} catch (error) {
+			console.error("Render frame error:", error);
+		}
+	};
+	const updatePerformanceNodeCounts = () => {
+		const nodeCount = Math.max(0, nodeRegistry.nodes.size - 1);
+		const rttNodeCount = actualRTTOperations;
+		performanceTracker.updateNodeCounts(nodeCount, rttNodeCount);
+	};
+	const getPerformanceStats = () => {
+		updatePerformanceNodeCounts();
+		const rendererInfo = renderer?.info;
+		return performanceTracker.getStats(rendererInfo);
+	};
+	const startAnimation = () => {
+		if (animationFrameId || !shouldAnimate) return;
+		performanceTracker.setRendering(true);
+		const animate = () => {
+			animationFrameId = requestAnimationFrame(animate);
+			renderFrame().catch(console.warn);
+		};
+		animate();
+	};
+	const stopAnimation = () => {
+		if (animationFrameId) {
+			cancelAnimationFrame(animationFrameId);
+			animationFrameId = null;
+		}
+		performanceTracker.setRendering(false);
+	};
+	const updatePointerCoords = (event) => {
+		if (!canvasElement) return;
+		let clientX;
+		let clientY;
+		if ("touches" in event) {
+			if (event.touches.length === 0) return;
+			clientX = event.touches[0].clientX;
+			clientY = event.touches[0].clientY;
+		} else {
+			clientX = event.clientX;
+			clientY = event.clientY;
+		}
+		const rect = canvasElement.getBoundingClientRect();
+		const x = (clientX - rect.left) / rect.width;
+		const y = (clientY - rect.top) / rect.height;
+		pointerX = x;
+		pointerY = y;
+	};
+	const globalMouseMoveHandler = (event) => {
+		if (!isInitialized || !canvasElement) return;
+		updatePointerCoords(event);
+	};
+	const globalTouchMoveHandler = (event) => {
+		if (!isInitialized || !canvasElement) return;
+		updatePointerCoords(event);
+	};
+	const globalMouseUpHandler = () => {
+		if (!isInitialized) return;
+		pointerActive = false;
+		renderFrame().catch(console.warn);
+	};
+	const globalTouchEndHandler = () => {
+		if (!isInitialized) return;
+		pointerActive = false;
+		renderFrame().catch(console.warn);
+	};
+	const canvasMouseDownHandler = () => {
+		pointerActive = true;
+		renderFrame().catch(console.warn);
+	};
+	const canvasTouchStartHandler = () => {
+		pointerActive = true;
+		renderFrame().catch(console.warn);
+	};
+	const processQueuedRegistrations = () => {
+		if (pendingRegistrationQueue.length === 0) return;
+		const queue = [...pendingRegistrationQueue];
+		pendingRegistrationQueue = [];
+		for (const { id, fragmentNodeFunc, parentId, metadata, uniforms, componentDefinition: componentDefinition$55 } of queue) if (fragmentNodeFunc) registerNode(id, fragmentNodeFunc, parentId, metadata, uniforms, componentDefinition$55);
+	};
+	const initialize = async ({ canvas, enablePerformanceTracking: enableTracking = false }) => {
+		if (isInitialized || isInitializing) return;
+		enablePerformanceTracking = enableTracking;
+		isInitializing = true;
+		initializationAbortController = new AbortController();
+		const localAbortController = initializationAbortController;
+		try {
+			canvasElement = canvas;
+			scene = new Scene();
+			scene.background = null;
+			camera = new OrthographicCamera(-1, 1, 1, -1, .1, 10);
+			camera.position.z = 1;
+			camera.lookAt(0, 0, 0);
+			globalEventUnregister = globalEventManager.register({
+				onMouseMove: globalMouseMoveHandler,
+				onTouchMove: globalTouchMoveHandler,
+				onMouseUp: globalMouseUpHandler,
+				onTouchEnd: globalTouchEndHandler
+			});
+			canvas.addEventListener("mousedown", canvasMouseDownHandler);
+			canvas.addEventListener("touchstart", canvasTouchStartHandler);
+			unloadHandler = () => {
+				cleanup();
+			};
+			window.addEventListener("beforeunload", unloadHandler);
+			if (localAbortController.signal.aborted) return;
+			try {
+				const rendererOptions = {
+					canvas,
+					antialias: true,
+					alpha: true,
+					depth: false,
+					powerPreference: "high-performance"
+				};
+				if (enablePerformanceTracking) {
+					rendererOptions.forceWebGL = false;
+					rendererOptions.requiredFeatures = ["timestamp-query"];
+				}
+				renderer = new WebGPURenderer(rendererOptions);
+				await renderer.init();
+				if (localAbortController.signal.aborted) return;
+			} catch (e) {
+				if (localAbortController.signal.aborted) return;
+				console.warn("[Shaders] WebGPU initialization failed, falling back to WebGL:", e);
+				try {
+					renderer = new WebGLRenderer({
+						canvas,
+						antialias: true,
+						alpha: true,
+						depth: false,
+						powerPreference: "high-performance"
+					});
+					if (localAbortController.signal.aborted) return;
+				} catch (webglError) {
+					if (localAbortController.signal.aborted) return;
+					console.error("[Shaders] Both WebGPU and WebGL initialization failed:", webglError);
+					return;
+				}
+			}
+			if (localAbortController.signal.aborted) return;
+			renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+			renderer.outputColorSpace = SRGBColorSpace;
+			material = new MeshBasicNodeMaterial({ transparent: true });
+			material.fragmentNode = vec4(0, 0, 0, 0);
+			mesh = new Mesh(new PlaneGeometry(2, 2), material);
+			scene.add(mesh);
+			const parentElement = canvas.parentElement;
+			if (!parentElement) {
+				console.warn("[Shaders] Canvas has no parent element for resize observation");
+				return;
+			}
+			resizeObserver = new ResizeObserver(handleResize);
+			resizeObserver.observe(parentElement);
+			intersectionObserver = new IntersectionObserver(handleVisibilityChange, { threshold: 0 });
+			intersectionObserver.observe(canvas);
+			const rect = canvas.getBoundingClientRect();
+			isVisible = rect.width > 0 && rect.height > 0 && rect.top < window.innerHeight && rect.bottom > 0 && rect.left < window.innerWidth && rect.right > 0;
+			shouldAnimate = true;
+			const { width, height } = canvas.getBoundingClientRect();
+			const roundedWidth = Math.round(width);
+			const roundedHeight = Math.round(height);
+			if (roundedWidth > 0 && roundedHeight > 0) {
+				currentWidth = roundedWidth;
+				currentHeight = roundedHeight;
+				hasInitialDimensions = true;
+				renderer.setSize(roundedWidth, roundedHeight, false);
+				const aspectRatio = roundedWidth / roundedHeight;
+				const frustumHeight = 2;
+				const frustumWidth = frustumHeight * aspectRatio;
+				camera.left = -frustumWidth / 2;
+				camera.right = frustumWidth / 2;
+				camera.top = frustumHeight / 2;
+				camera.bottom = -frustumHeight / 2;
+				camera.updateProjectionMatrix();
+				mesh.scale.set(frustumWidth, frustumHeight, 1);
+				await renderFrame();
+			} else hasInitialDimensions = false;
+			if (shouldAnimate) startAnimation();
+			if (!localAbortController.signal.aborted) {
+				isInitialized = true;
+				isRendererReady = true;
+				processQueuedRegistrations();
+			}
+		} catch (error) {
+			console.error("[Shaders] Initialization error:", error);
+		} finally {
+			isInitializing = false;
+			if (initializationAbortController === localAbortController) initializationAbortController = null;
+		}
+	};
+	const showLicenseWarning = () => {
+		if (!isDevelopment() || hasLoggedLicenseInfo) return;
+		console.warn("Shaders is running in development mode. Please purchase a license at https://shaders.com to use it in production.");
+		hasLoggedLicenseInfo = true;
+	};
+	const cleanup = () => {
+		if (initializationAbortController) initializationAbortController.abort();
+		if (resizeObserver) {
+			resizeObserver.disconnect();
+			resizeObserver = null;
+		}
+		if (intersectionObserver) {
+			intersectionObserver.disconnect();
+			intersectionObserver = null;
+		}
+		if (globalEventUnregister) {
+			globalEventUnregister();
+			globalEventUnregister = null;
+		}
+		if (canvasElement) {
+			canvasElement.removeEventListener("mousedown", canvasMouseDownHandler);
+			canvasElement.removeEventListener("touchstart", canvasTouchStartHandler);
+		}
+		if (unloadHandler) {
+			window.removeEventListener("beforeunload", unloadHandler);
+			unloadHandler = null;
+		}
+		stopAnimation();
+		disposePreviousTextures();
+		currentTextures.forEach((texture) => {
+			try {
+				if (texture?.renderTarget?.dispose) texture.renderTarget.dispose();
+			} catch (e) {}
+		});
+		currentTextures.clear();
+		nodeRegistry.nodes.clear();
+		nodeRegistry.rootId = null;
+		nodeRegistry.idToNodeId.clear();
+		parentToChildren.clear();
+		pendingRegistrationQueue = [];
+		isRendererReady = false;
+		registrationQueue = [];
+		if (registrationBatchRAF !== null) {
+			cancelAnimationFrame(registrationBatchRAF);
+			registrationBatchRAF = null;
+		}
+		metadataUpdateQueue = [];
+		if (metadataUpdateBatchRAF !== null) {
+			cancelAnimationFrame(metadataUpdateBatchRAF);
+			metadataUpdateBatchRAF = null;
+		}
+		pendingResize = null;
+		isResizeScheduled = false;
+		if (mesh) {
+			if (scene) scene.remove(mesh);
+			try {
+				if (mesh.geometry && typeof mesh.geometry.dispose === "function") mesh.geometry.dispose();
+			} catch (e) {}
+			try {
+				if (mesh.material instanceof Material && typeof mesh.material.dispose === "function") mesh.material.dispose();
+			} catch (e) {}
+		}
+		if (renderer && typeof renderer.dispose === "function") try {
+			renderer.dispose();
+		} catch (e) {}
+		canvasElement = null;
+		renderer = null;
+		camera = null;
+		scene = null;
+		mesh = null;
+		material = null;
+		isInitialized = false;
+		isInitializing = false;
+		hasInitialDimensions = false;
+		initializationAbortController = null;
+		currentWidth = 0;
+		currentHeight = 0;
+		isVisible = false;
+		shouldAnimate = true;
+		pointerX = .5;
+		pointerY = .5;
+		pointerActive = false;
+	};
+	const getRendererType = () => {
+		if (!renderer) return null;
+		return renderer instanceof WebGPURenderer ? "webgpu" : "webgl";
+	};
+	return {
+		initialize,
+		cleanup,
+		registerNode,
+		removeNode,
+		updateUniformValue: updateUniformValue$1,
+		updateNodeMetadata,
+		showLicenseWarning,
+		isInitialized: () => isInitialized,
+		startAnimation,
+		stopAnimation,
+		getPerformanceStats,
+		getNodeRegistry: () => ({ nodes: new Map(nodeRegistry.nodes) }),
+		getRendererType,
+		__testing: {
+			isUVComposable,
+			canSkipRTT,
+			hasUVPropagationOpportunity,
+			needsTransformation,
+			findUVChain,
+			findSiblingUVChain,
+			findChildNodes,
+			composeUVContextChain,
+			composeUVChain,
+			composeSiblingUVChain,
+			composeSiblingsWithUVContext,
+			applyMaskIfNeeded,
+			applyNodeTransformation,
+			getNodeRegistry: () => nodeRegistry,
+			getParentToChildren: () => parentToChildren
+		}
+	};
 }
-function si(e) {
-  const n = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), t = {
-    processingOrder: [],
-    maskSources: /* @__PURE__ */ new Map(),
-    circularDependencies: []
-  };
-  return e.forEach((u) => {
-    u.elementId && n.set(u.elementId, u.id);
-  }), e.forEach((u) => {
-    if (u.mask?.source) {
-      const p = u.mask.source.startsWith("#") ? u.mask.source.substring(1) : u.mask.source, h = n.get(p);
-      h ? (s.has(u.id) || s.set(u.id, []), s.get(u.id)?.push(h), t.maskSources.set(u.id, h)) : console.warn(`Mask source "${p}" not found for node "${u.id}"`);
-    }
-  }), t.processingOrder = Gr(s, t.circularDependencies), t;
+function resolveMaskDependencies(nodes) {
+	const elementIdToNodeId = /* @__PURE__ */ new Map();
+	const maskDependencies = /* @__PURE__ */ new Map();
+	const result = {
+		processingOrder: [],
+		maskSources: /* @__PURE__ */ new Map(),
+		circularDependencies: []
+	};
+	nodes.forEach((node) => {
+		if (node.elementId) elementIdToNodeId.set(node.elementId, node.id);
+	});
+	nodes.forEach((node) => {
+		if (node.mask?.source) {
+			const sourceElementId = node.mask.source.startsWith("#") ? node.mask.source.substring(1) : node.mask.source;
+			const sourceNodeId = elementIdToNodeId.get(sourceElementId);
+			if (sourceNodeId) {
+				if (!maskDependencies.has(node.id)) maskDependencies.set(node.id, []);
+				maskDependencies.get(node.id)?.push(sourceNodeId);
+				result.maskSources.set(node.id, sourceNodeId);
+			} else console.warn(`Mask source "${sourceElementId}" not found for node "${node.id}"`);
+		}
+	});
+	result.processingOrder = topologicalSort(maskDependencies, result.circularDependencies);
+	return result;
 }
-function Gr(e, n) {
-  const s = [], t = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set();
-  function p(d, k = []) {
-    if (t.has(d)) return;
-    if (u.has(d)) {
-      const B = [...k.slice(k.indexOf(d)), d];
-      n.push(B);
-      return;
-    }
-    u.add(d), k.push(d);
-    const U = e.get(d) || [];
-    for (const B of U) p(B, [...k]);
-    u.delete(d), t.add(d), s.push(d);
-  }
-  for (const d of e.keys()) t.has(d) || p(d);
-  const h = new Set([...e.values()].flat());
-  for (const d of h) !t.has(d) && !e.has(d) && s.push(d);
-  return s.reverse();
+function topologicalSort(dependencies, circularDependencies) {
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	const tempVisited = /* @__PURE__ */ new Set();
+	function visit(nodeId, path = []) {
+		if (visited.has(nodeId)) return;
+		if (tempVisited.has(nodeId)) {
+			const cycle = [...path.slice(path.indexOf(nodeId)), nodeId];
+			circularDependencies.push(cycle);
+			return;
+		}
+		tempVisited.add(nodeId);
+		path.push(nodeId);
+		const deps = dependencies.get(nodeId) || [];
+		for (const depId of deps) visit(depId, [...path]);
+		tempVisited.delete(nodeId);
+		visited.add(nodeId);
+		result.push(nodeId);
+	}
+	for (const nodeId of dependencies.keys()) if (!visited.has(nodeId)) visit(nodeId);
+	const allSourceNodeIds = new Set([...dependencies.values()].flat());
+	for (const sourceId of allSourceNodeIds) if (!visited.has(sourceId) && !dependencies.has(sourceId)) result.push(sourceId);
+	return result.reverse();
 }
-var { vec2: Nr, fract: Vr, sin: qr, dot: Pr } = le;
-const Xr = (e) => Vr(qr(Pr(e, Nr(12.12345, 78.12345))).mul(40000.12345)), li = (e = 0.03) => (n) => Xr(n).mul(e).mul(0.10012345);
-var { vec2: Yr } = le;
-const ci = (e = Yr(0), n = 0.02, s = 1, t = 1) => {
-  const { vec2: u, sin: p, cos: h, time: d } = le, k = t * 1.618033988749895, U = t * 2.718281828459045, B = (Math.sin(t) + 2) * 5, O = (Math.cos(t) + 2) * 5, Q = u(p(e.x.mul(s).mul(B).add(d.mul(0.1)).add(k)), h(e.y.mul(s).mul(B).add(d.mul(0.1)).add(U))), V = u(p(e.y.mul(s).mul(O).add(d.mul(0.05)).add(U)), h(e.x.mul(s).mul(O).add(d.mul(0.05)).add(k))), q = Q.add(V).mul(n);
-  return e.add(q);
-}, fi = (e, n, s = 0.6, t = 0.3, u = 1) => {
-  const { max: p, smoothstep: h, vec4: d } = le, k = p(p(e.r, e.g), e.b), U = h(s, s + t, k).mul(u).mul(1);
-  return d(e.rgb.add(n.rgb.mul(U)), e.a);
-}, ui = (e = {}) => {
-  const { inset: n = 0.4, softness: s = 0.5, offsetX: t = 0, offsetY: u = 0 } = e, { float: p, smoothstep: h, uv: d } = le, k = d(), U = k.x.sub(0.5).sub(p(t)).mul(2), B = k.y.sub(0.5).add(p(u)).mul(2), O = U.mul(U).add(B.mul(B)).sqrt();
-  return p(1).sub(h(p(1).sub(p(n)), p(1).sub(p(n)).add(p(s)), O.mul(p(1).add(p(s)))));
+var { vec2: vec2$2, fract, sin: sin$1, dot: dot$1 } = TSL;
+const noise = (st) => fract(sin$1(dot$1(st, vec2$2(12.12345, 78.12345))).mul(40000.12345));
+const grain = (intensity = .03) => (st) => noise(st).mul(intensity).mul(.10012345);
+var { vec2: vec2$1 } = TSL;
+const distort = (uv = vec2$1(0), intensity = .02, frequency = 1, seed = 1) => {
+	const { vec2: vec2$4, sin: sin$3, cos: cos$2, time } = TSL;
+	const phaseX = seed * 1.618033988749895;
+	const phaseY = seed * 2.718281828459045;
+	const freqMod1 = (Math.sin(seed) + 2) * 5;
+	const freqMod2 = (Math.cos(seed) + 2) * 5;
+	const flow1 = vec2$4(sin$3(uv.x.mul(frequency).mul(freqMod1).add(time.mul(.1)).add(phaseX)), cos$2(uv.y.mul(frequency).mul(freqMod1).add(time.mul(.1)).add(phaseY)));
+	const flow2 = vec2$4(sin$3(uv.y.mul(frequency).mul(freqMod2).add(time.mul(.05)).add(phaseY)), cos$2(uv.x.mul(frequency).mul(freqMod2).add(time.mul(.05)).add(phaseX)));
+	const offset = flow1.add(flow2).mul(intensity);
+	return uv.add(offset);
 };
-var Ir = () => {
-  const e = {};
-  return Object.entries({
-    AngularBlur: Zn,
-    Ascii: Kn,
-    Beam: et,
-    Blob: nt,
-    Blur: tt,
-    Bulge: rt,
-    ChannelBlur: ot,
-    Checkerboard: it,
-    ChromaFlow: at,
-    ChromaticAberration: st,
-    Circle: lt,
-    CRTScreen: ct,
-    CursorTrail: ft,
-    DiffuseBlur: ut,
-    Dither: mt,
-    DotGrid: dt,
-    Duotone: ht,
-    FilmGrain: pt,
-    FloatingParticles: gt,
-    GlassTiles: bt,
-    Glow: vt,
-    Godrays: Ct,
-    Grayscale: Rt,
-    Grid: kt,
-    GridDistortion: Tt,
-    Group: yt,
-    Halftone: wt,
-    HueShift: Ut,
-    ImageTexture: St,
-    Invert: Mt,
-    LinearBlur: xt,
-    LinearGradient: At,
-    Liquify: Dt,
-    Pixelate: zt,
-    PolarCoordinates: Et,
-    Posterize: Ft,
-    ProgressiveBlur: $t,
-    RadialGradient: Ot,
-    RectangularCoordinates: Bt,
-    Ripples: _t,
-    Saturation: Lt,
-    SimplexNoise: Gt,
-    SineWave: Nt,
-    SolidColor: Vt,
-    Spherize: qt,
-    Spiral: Pt,
-    Strands: Xt,
-    Stretch: Yt,
-    Swirl: It,
-    TiltShift: Ht,
-    Tritone: Wt,
-    Twirl: jt,
-    Vibrance: Qt,
-    WaveDistortion: Jt,
-    ZoomBlur: Zt
-  }).forEach(([s, t]) => {
-    const u = {};
-    t.props && Object.entries(t.props).forEach(([p, h]) => {
-      h.ui && (u[p] = {
-        ui: h.ui,
-        default: h.default,
-        description: h.description
-      });
-    }), e[t.name] = {
-      name: t.name,
-      fileName: s,
-      category: t.category || "Uncategorized",
-      definition: t,
-      propsMetadata: u
-    };
-  }), e;
+const glow = (color, glowColor, threshold = .6, softness = .3, intensity = 1) => {
+	const { max: max$1, smoothstep, vec4: vec4$1 } = TSL;
+	const brightness = max$1(max$1(color.r, color.g), color.b);
+	const glowAmount = smoothstep(threshold, threshold + softness, brightness).mul(intensity).mul(1);
+	return vec4$1(color.rgb.add(glowColor.rgb.mul(glowAmount)), color.a);
 };
-const Le = Ir();
-function mi() {
-  return Object.values(Le);
+const edgeMask = (options = {}) => {
+	const { inset = .4, softness = .5, offsetX = 0, offsetY = 0 } = options;
+	const { float: float$2, smoothstep, uv } = TSL;
+	const rawUV = uv();
+	const ovalX = rawUV.x.sub(.5).sub(float$2(offsetX)).mul(2);
+	const ovalY = rawUV.y.sub(.5).add(float$2(offsetY)).mul(2);
+	const ovalDistance = ovalX.mul(ovalX).add(ovalY.mul(ovalY)).sqrt();
+	return float$2(1).sub(smoothstep(float$2(1).sub(float$2(inset)), float$2(1).sub(float$2(inset)).add(float$2(softness)), ovalDistance.mul(float$2(1).add(float$2(softness)))));
+};
+var createShaderRegistry = () => {
+	const registry = {};
+	const shaderDefinitions = {
+		AngularBlur: componentDefinition,
+		Ascii: componentDefinition$1,
+		Beam: componentDefinition$2,
+		Blob: componentDefinition$3,
+		Blur: componentDefinition$4,
+		Bulge: componentDefinition$5,
+		ChannelBlur: componentDefinition$6,
+		Checkerboard: componentDefinition$7,
+		ChromaFlow: componentDefinition$8,
+		ChromaticAberration: componentDefinition$9,
+		Circle: componentDefinition$10,
+		CRTScreen: componentDefinition$11,
+		CursorTrail: componentDefinition$12,
+		DiffuseBlur: componentDefinition$13,
+		Dither: componentDefinition$14,
+		DotGrid: componentDefinition$15,
+		Duotone: componentDefinition$16,
+		FilmGrain: componentDefinition$17,
+		FloatingParticles: componentDefinition$18,
+		GlassTiles: componentDefinition$19,
+		Glow: componentDefinition$20,
+		Godrays: componentDefinition$21,
+		Grayscale: componentDefinition$22,
+		Grid: componentDefinition$23,
+		GridDistortion: componentDefinition$24,
+		Group: componentDefinition$25,
+		Halftone: componentDefinition$26,
+		HueShift: componentDefinition$27,
+		ImageTexture: componentDefinition$28,
+		Invert: componentDefinition$29,
+		LinearBlur: componentDefinition$30,
+		LinearGradient: componentDefinition$31,
+		Liquify: componentDefinition$32,
+		Pixelate: componentDefinition$33,
+		PolarCoordinates: componentDefinition$34,
+		Posterize: componentDefinition$35,
+		ProgressiveBlur: componentDefinition$36,
+		RadialGradient: componentDefinition$37,
+		RectangularCoordinates: componentDefinition$38,
+		Ripples: componentDefinition$39,
+		Saturation: componentDefinition$40,
+		SimplexNoise: componentDefinition$41,
+		SineWave: componentDefinition$42,
+		SolidColor: componentDefinition$43,
+		Spherize: componentDefinition$44,
+		Spiral: componentDefinition$45,
+		Strands: componentDefinition$46,
+		Stretch: componentDefinition$47,
+		Swirl: componentDefinition$48,
+		TiltShift: componentDefinition$49,
+		Tritone: componentDefinition$50,
+		Twirl: componentDefinition$51,
+		Vibrance: componentDefinition$52,
+		WaveDistortion: componentDefinition$53,
+		ZoomBlur: componentDefinition$54
+	};
+	Object.entries(shaderDefinitions).forEach(([fileName, def]) => {
+		const propsMetadata = {};
+		if (def.props) Object.entries(def.props).forEach(([propName, propConfig]) => {
+			if (propConfig.ui) propsMetadata[propName] = {
+				ui: propConfig.ui,
+				default: propConfig.default,
+				description: propConfig.description
+			};
+		});
+		registry[def.name] = {
+			name: def.name,
+			fileName,
+			category: def.category || "Uncategorized",
+			definition: def,
+			propsMetadata
+		};
+	});
+	return registry;
+};
+const shaderRegistry = createShaderRegistry();
+function getAllShaders() {
+	return Object.values(shaderRegistry);
 }
-function di(e) {
-  return Le[e];
+function getShaderByName(name) {
+	return shaderRegistry[name];
 }
-function hi(e) {
-  return Object.values(Le).filter((n) => n.category === e);
+function getShadersByCategory(category) {
+	return Object.values(shaderRegistry).filter((shader) => shader.category === category);
 }
-function pi() {
-  const e = new Set(Object.values(Le).map((n) => n.category));
-  return Array.from(e).sort();
+function getShaderCategories() {
+	const categories = new Set(Object.values(shaderRegistry).map((shader) => shader.category));
+	return Array.from(categories).sort();
 }
-export {
-  Jr as createAnimatedTime,
-  ii as createUniformsMap,
-  ci as distort,
-  ui as edgeMask,
-  mi as getAllShaders,
-  di as getShaderByName,
-  pi as getShaderCategories,
-  hi as getShadersByCategory,
-  fi as glow,
-  li as grain,
-  si as resolveMaskDependencies,
-  Le as shaderRegistry,
-  ai as shaderRenderer,
-  Br as updateUniformValue
-};
+export { createAnimatedTime, createUniformsMap, distort, edgeMask, getAllShaders, getShaderByName, getShaderCategories, getShadersByCategory, glow, grain, resolveMaskDependencies, shaderRegistry, shaderRenderer, updateUniformValue };