textmode.synth.js 1.1.1 → 1.2.0-beta.1

package/dist/textmode.synth.esm.js

@@ -1,12 +1,12 @@
-const re = { src: { returnType: "vec4", args: [{ type: "vec2", name: "_st" }] }, coord: { returnType: "vec2", args: [{ type: "vec2", name: "_st" }] }, color: { returnType: "vec4", args: [{ type: "vec4", name: "_c0" }] }, combine: { returnType: "vec4", args: [{ type: "vec4", name: "_c0" }, { type: "vec4", name: "_c1" }] }, combineCoord: { returnType: "vec2", args: [{ type: "vec2", name: "_st" }, { type: "vec4", name: "_c0" }] } };
-function oe(t) {
-  const e = re[t.type], n = [...e.args, ...t.inputs.map((o) => ({ type: o.type, name: o.name }))].map((o) => `${o.type} ${o.name}`).join(", "), r = `
+const ae = { src: { returnType: "vec4", args: [{ type: "vec2", name: "_st" }] }, coord: { returnType: "vec2", args: [{ type: "vec2", name: "_st" }] }, color: { returnType: "vec4", args: [{ type: "vec4", name: "_c0" }] }, combine: { returnType: "vec4", args: [{ type: "vec4", name: "_c0" }, { type: "vec4", name: "_c1" }] }, combineCoord: { returnType: "vec2", args: [{ type: "vec2", name: "_st" }, { type: "vec4", name: "_c0" }] } };
+function se(t) {
+  const e = ae[t.type], n = [...e.args, ...t.inputs.map((o) => ({ type: o.type, name: o.name }))].map((o) => `${o.type} ${o.name}`).join(", "), r = `
 ${e.returnType} ${t.name}(${n}) {
 ${t.glsl}
 }`;
   return { ...t, glslFunction: r };
 }
-class ae {
+class ce {
   _transforms = /* @__PURE__ */ new Map();
   _processedCache = /* @__PURE__ */ new Map();
   register(e) {
@@ -22,7 +22,7 @@ class ae {
     let n = this._processedCache.get(e);
     if (!n) {
       const r = this._transforms.get(e);
-      r && (n = oe(r), this._processedCache.set(e, n));
+      r && (n = se(r), this._processedCache.set(e, n));
     }
     return n;
   }
@@ -51,31 +51,31 @@ class ae {
     return this._transforms.size;
   }
 }
-const P = new ae(), Y = /* @__PURE__ */ new Set(["src"]);
-class se {
+const L = new ce(), G = /* @__PURE__ */ new Set(["src"]);
+class le {
   _generatedFunctions = {};
   _synthSourceClass = null;
   setSynthSourceClass(e) {
     this._synthSourceClass = e;
   }
   injectMethods(e) {
-    const n = P.getAll();
+    const n = L.getAll();
     for (const r of n) this._injectMethod(e, r);
   }
   _injectMethod(e, n) {
-    const r = this._synthSourceClass, { name: o, inputs: a, type: u } = n, s = e;
-    if (u === "combine" || u === "combineCoord") s[o] = function(c, ...i) {
-      let l = c;
-      if (r && !(c instanceof r)) {
-        const p = new r(), f = typeof c == "number" ? [c, c, c, null] : [c, null, null, null];
-        p.addTransform("solid", f), l = p;
+    const r = this._synthSourceClass, { name: o, inputs: a, type: u } = n, l = e;
+    if (u === "combine" || u === "combineCoord") l[o] = function(m, ...i) {
+      let s = m;
+      if (r && !(m instanceof r)) {
+        const c = new r(), f = typeof m == "number" ? [m, m, m, null] : [m, null, null, null];
+        c.addTransform("solid", f), s = c;
       }
-      return this.addCombineTransform(o, l, k(a, i));
+      return this.addCombineTransform(o, s, U(a, i));
     };
     else {
-      const c = this;
-      s[o] = function(...i) {
-        return i = c._expandColorArgs(o, i), this.addTransform(o, k(a, i));
+      const m = this;
+      l[o] = function(...i) {
+        return i = m._expandColorArgs(o, i), this.addTransform(o, U(a, i));
       };
     }
   }
@@ -88,12 +88,12 @@ class se {
   }
   generateStandaloneFunctions() {
     if (!this._synthSourceClass) throw new Error("[TransformFactory] SynthSource class not set. Call setSynthSourceClass first.");
-    const e = {}, n = P.getAll(), r = this._synthSourceClass;
-    for (const o of n) if (Y.has(o.type)) {
+    const e = {}, n = L.getAll(), r = this._synthSourceClass;
+    for (const o of n) if (G.has(o.type)) {
       const { name: a, inputs: u } = o;
-      e[a] = (...s) => {
-        const c = new r();
-        return s = this._expandColorArgs(a, s), c.addTransform(a, k(u, s));
+      e[a] = (...l) => {
+        const m = new r();
+        return l = this._expandColorArgs(a, l), m.addTransform(a, U(u, l));
       };
     }
     return this._generatedFunctions = e, e;
@@ -102,27 +102,47 @@ class se {
     return this._generatedFunctions;
   }
   addTransform(e, n) {
-    if (P.register(e), n && this._injectMethod(n, e), Y.has(e.type) && this._synthSourceClass) {
+    if (L.register(e), n && this._injectMethod(n, e), G.has(e.type) && this._synthSourceClass) {
       const r = this._synthSourceClass, { name: o, inputs: a } = e;
       this._generatedFunctions[o] = (...u) => {
-        const s = new r();
-        return u = this._expandColorArgs(o, u), s.addTransform(o, k(a, u));
+        const l = new r();
+        return u = this._expandColorArgs(o, u), l.addTransform(o, U(a, u));
       };
     }
   }
 }
-function k(t, e) {
+function U(t, e) {
   return t.map((n, r) => e[r] ?? n.default);
 }
-const z = new se(), S = { charColor: "prevCharColorBuffer", char: "prevCharBuffer", cellColor: "prevCellColorBuffer" }, $ = { charColor: "_charColor", char: "_char", cellColor: "_cellColor" }, ce = { name: "osc", type: "src", inputs: [{ name: "frequency", type: "float", default: 60 }, { name: "sync", type: "float", default: 0.1 }, { name: "offset", type: "float", default: 0 }], glsl: `
+const B = new le(), $ = { charColor: "prevCharColorBuffer", char: "prevCharBuffer", cellColor: "prevCellColorBuffer" }, R = { charColor: "_charColor", char: "_char", cellColor: "_cellColor" }, ie = { name: "osc", type: "src", inputs: [{ name: "frequency", type: "float", default: 60 }, { name: "sync", type: "float", default: 0.1 }, { name: "offset", type: "float", default: 0 }], glsl: `
 	vec2 st = _st;
 	float r = sin((st.x - offset/frequency + time*sync) * frequency) * 0.5 + 0.5;
 	float g = sin((st.x + time*sync) * frequency) * 0.5 + 0.5;
 	float b = sin((st.x + offset/frequency + time*sync) * frequency) * 0.5 + 0.5;
 	return vec4(r, g, b, 1.0);
-`, description: "Generate oscillating color pattern" }, ie = { name: "noise", type: "src", inputs: [{ name: "scale", type: "float", default: 10 }, { name: "offset", type: "float", default: 0.1 }], glsl: `
+`, description: "Generate oscillating color pattern" }, ue = { name: "noise", type: "src", inputs: [{ name: "scale", type: "float", default: 10 }, { name: "offset", type: "float", default: 0.1 }], glsl: `
 	return vec4(vec3(_noise(vec3(_st * scale, offset * time))), 1.0);
-`, description: "Generate noise pattern" }, le = { name: "voronoi", type: "src", inputs: [{ name: "scale", type: "float", default: 5 }, { name: "speed", type: "float", default: 0.3 }, { name: "blending", type: "float", default: 0.3 }], glsl: `
+`, description: "Generate noise pattern" }, fe = { name: "plasma", type: "src", inputs: [{ name: "scale", type: "float", default: 10 }, { name: "speed", type: "float", default: 0.5 }, { name: "phase", type: "float", default: 0 }, { name: "contrast", type: "float", default: 1 }], glsl: `
+	float t = time * speed + phase;
+	float v = 0.0;
+	v += sin((_st.x * scale) + t);
+	v += sin((_st.y * scale * 1.1) + t * 1.2);
+	v += sin(((_st.x + _st.y) * scale * 0.7) + t * 0.8);
+	v = v / 3.0;
+	v = v * 0.5 + 0.5;
+	v = clamp((v - 0.5) * contrast + 0.5, 0.0, 1.0);
+	return vec4(vec3(v), 1.0);
+`, description: "Generate plasma-like sine field" }, me = { name: "moire", type: "src", inputs: [{ name: "freqA", type: "float", default: 20 }, { name: "freqB", type: "float", default: 21 }, { name: "angleA", type: "float", default: 0 }, { name: "angleB", type: "float", default: 1.5708 }, { name: "speed", type: "float", default: 0.1 }, { name: "phase", type: "float", default: 0 }], glsl: `
+	float t = time * speed + phase;
+	vec2 p = _st - vec2(0.5);
+	vec2 dirA = vec2(cos(angleA), sin(angleA));
+	vec2 dirB = vec2(cos(angleB), sin(angleB));
+	float a = sin(dot(p, dirA) * freqA + t);
+	float b = sin(dot(p, dirB) * freqB - t * 0.7);
+	float v = a * b;
+	v = v * 0.5 + 0.5;
+	return vec4(vec3(v), 1.0);
+`, description: "Generate moire interference patterns" }, pe = { name: "voronoi", type: "src", inputs: [{ name: "scale", type: "float", default: 5 }, { name: "speed", type: "float", default: 0.3 }, { name: "blending", type: "float", default: 0.3 }], glsl: `
 	vec3 color = vec3(0.0);
 	vec2 st = _st * scale;
 	vec2 i_st = floor(st);
@@ -146,20 +166,23 @@ const z = new se(), S = { charColor: "prevCharColorBuffer", char: "prevCharBuffe
 	color += dot(m_point, vec2(0.3, 0.6));
 	color *= 1.0 - blending * m_dist;
 	return vec4(color, 1.0);
-`, description: "Generate voronoi pattern" }, ue = { name: "gradient", type: "src", inputs: [{ name: "speed", type: "float", default: 0 }], glsl: `
+`, description: "Generate voronoi pattern" }, de = { name: "gradient", type: "src", inputs: [{ name: "speed", type: "float", default: 0 }], glsl: `
 	return vec4(_st, sin(time * speed), 1.0);
-`, description: "Generate gradient pattern" }, fe = { name: "shape", type: "src", inputs: [{ name: "sides", type: "float", default: 3 }, { name: "radius", type: "float", default: 0.3 }, { name: "smoothing", type: "float", default: 0.01 }], glsl: `
+`, description: "Generate gradient pattern" }, he = { name: "shape", type: "src", inputs: [{ name: "sides", type: "float", default: 3 }, { name: "radius", type: "float", default: 0.3 }, { name: "smoothing", type: "float", default: 0.01 }], glsl: `
 	vec2 st = _st * 2.0 - 1.0;
 	float a = atan(st.x, st.y) + 3.1416;
 	float r = (2.0 * 3.1416) / sides;
 	float d = cos(floor(0.5 + a/r) * r - a) * length(st);
 	return vec4(vec3(1.0 - smoothstep(radius, radius + smoothing + 0.0000001, d)), 1.0);
-`, description: "Generate polygon shape" }, pe = { name: "solid", type: "src", inputs: [{ name: "r", type: "float", default: 0 }, { name: "g", type: "float", default: 0 }, { name: "b", type: "float", default: 0 }, { name: "a", type: "float", default: 1 }], glsl: `
+`, description: "Generate polygon shape" }, ge = { name: "solid", type: "src", inputs: [{ name: "r", type: "float", default: 0 }, { name: "g", type: "float", default: 0 }, { name: "b", type: "float", default: 0 }, { name: "a", type: "float", default: 1 }], glsl: `
 	return vec4(r, g, b, a);
-`, description: "Generate solid color" }, me = { name: "src", type: "src", inputs: [], glsl: `
-	return texture(${S.charColor}, fract(_st));
-`, description: "Sample the previous frame for feedback effects. Context-aware: automatically samples the appropriate texture based on where it is used (char, charColor, or cellColor context)." }, he = [ce, ie, le, ue, fe, pe, me];
-function q(t) {
+`, description: "Generate solid color" }, ye = { name: "src", type: "src", inputs: [], glsl: `
+	return texture(${$.charColor}, fract(_st));
+`, description: "Sample the previous frame for feedback effects. Context-aware: automatically samples the appropriate texture based on where it is used (char, charColor, or cellColor context)." }, _e = { name: "srcTexture", type: "src", inputs: [], glsl: `
+	// Placeholder - actual texture sampling is handled dynamically per TextmodeSource
+	return texture(u_textmodeSource0, fract(_st));
+`, description: "Sample from a TextmodeSource (image/video). Context-aware: the actual sampler uniform is determined at compile time based on the source reference." }, ve = [ie, ue, fe, me, pe, de, he, ge, ye, _e];
+function Q(t) {
   const e = t === "x" ? "scrollX" : "scrollY";
   return { name: e, type: "coord", inputs: [{ name: e, type: "float", default: 0.5 }, { name: "speed", type: "float", default: 0 }], glsl: `
 	vec2 st = _st;
@@ -167,38 +190,38 @@ function q(t) {
 	return fract(st);
 `, description: `Scroll ${t.toUpperCase()} coordinate` };
 }
-function H(t) {
+function W(t) {
   return { name: t === "x" ? "repeatX" : "repeatY", type: "coord", inputs: [{ name: "reps", type: "float", default: 3 }, { name: "offset", type: "float", default: 0 }], glsl: `
 	vec2 st = _st * vec2(${t === "x" ? "reps, 1.0" : "1.0, reps"});
 	st.${t === "x" ? "y" : "x"} += step(1.0, mod(st.${t}, 2.0)) * offset;
 	return fract(st);
 `, description: "Repeat pattern " + (t === "x" ? "horizontally" : "vertically") };
 }
-const de = { name: "rotate", type: "coord", inputs: [{ name: "angle", type: "float", default: 10 }, { name: "speed", type: "float", default: 0 }], glsl: `
+const xe = { name: "rotate", type: "coord", inputs: [{ name: "angle", type: "float", default: 10 }, { name: "speed", type: "float", default: 0 }], glsl: `
 	vec2 xy = _st - vec2(0.5);
 	float ang = angle + speed * time;
 	xy = mat2(cos(ang), -sin(ang), sin(ang), cos(ang)) * xy;
 	xy += 0.5;
 	return xy;
-`, description: "Rotate coordinates" }, ye = { name: "scale", type: "coord", inputs: [{ name: "amount", type: "float", default: 1.5 }, { name: "xMult", type: "float", default: 1 }, { name: "yMult", type: "float", default: 1 }, { name: "offsetX", type: "float", default: 0.5 }, { name: "offsetY", type: "float", default: 0.5 }], glsl: `
+`, description: "Rotate coordinates" }, Ce = { name: "scale", type: "coord", inputs: [{ name: "amount", type: "float", default: 1.5 }, { name: "xMult", type: "float", default: 1 }, { name: "yMult", type: "float", default: 1 }, { name: "offsetX", type: "float", default: 0.5 }, { name: "offsetY", type: "float", default: 0.5 }], glsl: `
 	vec2 xy = _st - vec2(offsetX, offsetY);
 	xy *= (1.0 / vec2(amount * xMult, amount * yMult));
 	xy += vec2(offsetX, offsetY);
 	return xy;
-`, description: "Scale coordinates" }, ge = { name: "scroll", type: "coord", inputs: [{ name: "scrollX", type: "float", default: 0.5 }, { name: "scrollY", type: "float", default: 0.5 }, { name: "speedX", type: "float", default: 0 }, { name: "speedY", type: "float", default: 0 }], glsl: `
+`, description: "Scale coordinates" }, be = { name: "scroll", type: "coord", inputs: [{ name: "scrollX", type: "float", default: 0.5 }, { name: "scrollY", type: "float", default: 0.5 }, { name: "speedX", type: "float", default: 0 }, { name: "speedY", type: "float", default: 0 }], glsl: `
 	vec2 st = _st;
 	st.x += scrollX + time * speedX;
 	st.y += scrollY + time * speedY;
 	return fract(st);
-`, description: "Scroll coordinates" }, _e = q("x"), ve = q("y"), Ce = { name: "pixelate", type: "coord", inputs: [{ name: "pixelX", type: "float", default: 20 }, { name: "pixelY", type: "float", default: 20 }], glsl: `
+`, description: "Scroll coordinates" }, Se = Q("x"), we = Q("y"), $e = { name: "pixelate", type: "coord", inputs: [{ name: "pixelX", type: "float", default: 20 }, { name: "pixelY", type: "float", default: 20 }], glsl: `
 	vec2 xy = vec2(pixelX, pixelY);
 	return (floor(_st * xy) + 0.5) / xy;
-`, description: "Pixelate coordinates" }, xe = { name: "repeat", type: "coord", inputs: [{ name: "repeatX", type: "float", default: 3 }, { name: "repeatY", type: "float", default: 3 }, { name: "offsetX", type: "float", default: 0 }, { name: "offsetY", type: "float", default: 0 }], glsl: `
+`, description: "Pixelate coordinates" }, Me = { name: "repeat", type: "coord", inputs: [{ name: "repeatX", type: "float", default: 3 }, { name: "repeatY", type: "float", default: 3 }, { name: "offsetX", type: "float", default: 0 }, { name: "offsetY", type: "float", default: 0 }], glsl: `
 	vec2 st = _st * vec2(repeatX, repeatY);
 	st.x += step(1.0, mod(st.y, 2.0)) * offsetX;
 	st.y += step(1.0, mod(st.x, 2.0)) * offsetY;
 	return fract(st);
-`, description: "Repeat pattern" }, be = H("x"), Se = H("y"), we = { name: "kaleid", type: "coord", inputs: [{ name: "nSides", type: "float", default: 4 }], glsl: `
+`, description: "Repeat pattern" }, Te = W("x"), Fe = W("y"), Re = { name: "kaleid", type: "coord", inputs: [{ name: "nSides", type: "float", default: 4 }], glsl: `
 	vec2 st = _st;
 	st -= 0.5;
 	float r = length(st);
@@ -207,81 +230,184 @@ const de = { name: "rotate", type: "coord", inputs: [{ name: "angle", type: "flo
 	a = mod(a, pi / nSides);
 	a = abs(a - pi / nSides / 2.0);
 	return r * vec2(cos(a), sin(a));
-`, description: "Kaleidoscope effect" }, Me = [de, ye, ge, _e, ve, Ce, xe, be, Se, we], $e = [{ name: "scale", type: "float", default: 1 }, { name: "offset", type: "float", default: 0 }];
-function V(t) {
-  return { name: t, type: "color", inputs: $e, glsl: `
+`, description: "Kaleidoscope effect" }, Ae = { name: "polar", type: "coord", inputs: [{ name: "angle", type: "float", default: 0 }, { name: "radius", type: "float", default: 1 }], glsl: `
+	vec2 st = _st - vec2(0.5);
+	float r = length(st) * radius;
+	float a = atan(st.y, st.x) + angle;
+	a = a / (2.0 * 3.1416);
+	return vec2(fract(a), r);
+`, description: "Convert to polar coordinates" }, Pe = { name: "twirl", type: "coord", inputs: [{ name: "amount", type: "float", default: 2 }, { name: "radius", type: "float", default: 0.5 }, { name: "centerX", type: "float", default: 0.5 }, { name: "centerY", type: "float", default: 0.5 }], glsl: `
+	vec2 center = vec2(centerX, centerY);
+	vec2 p = _st - center;
+	float r = length(p);
+	float safeRadius = max(radius, 0.00001);
+	float t = clamp((safeRadius - r) / safeRadius, 0.0, 1.0);
+	float angle = amount * t * t;
+	float s = sin(angle);
+	float c = cos(angle);
+	p = vec2(c * p.x - s * p.y, s * p.x + c * p.y);
+	return p + center;
+`, description: "Twirl distortion with radial falloff" }, ke = { name: "swirl", type: "coord", inputs: [{ name: "amount", type: "float", default: 4 }, { name: "centerX", type: "float", default: 0.5 }, { name: "centerY", type: "float", default: 0.5 }], glsl: `
+	vec2 center = vec2(centerX, centerY);
+	vec2 p = _st - center;
+	float r = length(p);
+	float angle = amount * r;
+	float s = sin(angle);
+	float c = cos(angle);
+	p = vec2(c * p.x - s * p.y, s * p.x + c * p.y);
+	return p + center;
+`, description: "Swirl distortion around a center" }, Ie = { name: "mirror", type: "coord", inputs: [{ name: "mirrorX", type: "float", default: 1 }, { name: "mirrorY", type: "float", default: 1 }], glsl: `
+	vec2 m = abs(fract(_st * 2.0) - 1.0);
+	vec2 mixAmt = clamp(vec2(mirrorX, mirrorY), 0.0, 1.0);
+	return mix(_st, m, mixAmt);
+`, description: "Mirror coordinates across X and/or Y axes" }, Le = { name: "shear", type: "coord", inputs: [{ name: "x", type: "float", default: 0 }, { name: "y", type: "float", default: 0 }, { name: "centerX", type: "float", default: 0.5 }, { name: "centerY", type: "float", default: 0.5 }], glsl: `
+	vec2 center = vec2(centerX, centerY);
+	vec2 p = _st - center;
+	p = vec2(p.x + y * p.y, p.y + x * p.x);
+	return p + center;
+`, description: "Shear coordinates along X and Y" }, Ue = { name: "barrel", type: "coord", inputs: [{ name: "amount", type: "float", default: 0.5 }, { name: "centerX", type: "float", default: 0.5 }, { name: "centerY", type: "float", default: 0.5 }], glsl: `
+	vec2 center = vec2(centerX, centerY);
+	vec2 p = _st - center;
+	float r2 = dot(p, p);
+	p *= 1.0 + amount * r2;
+	return p + center;
+`, description: "Barrel distortion (bulge outward)" }, De = { name: "pinch", type: "coord", inputs: [{ name: "amount", type: "float", default: 0.5 }, { name: "centerX", type: "float", default: 0.5 }, { name: "centerY", type: "float", default: 0.5 }], glsl: `
+	vec2 center = vec2(centerX, centerY);
+	vec2 p = _st - center;
+	float r2 = dot(p, p);
+	p *= 1.0 / (1.0 + amount * r2);
+	return p + center;
+`, description: "Pinch distortion (pull inward)" }, Ne = { name: "fisheye", type: "coord", inputs: [{ name: "amount", type: "float", default: 1 }, { name: "centerX", type: "float", default: 0.5 }, { name: "centerY", type: "float", default: 0.5 }], glsl: `
+	vec2 center = vec2(centerX, centerY);
+	vec2 p = _st - center;
+	float r = length(p);
+	if (r > 0.0) {
+		float k = max(amount, 0.00001);
+		float r2 = atan(r * k) / atan(k);
+		p = p / r * r2;
+	}
+	return p + center;
+`, description: "Fisheye lens distortion" }, Oe = [xe, Ce, be, Se, we, $e, Me, Te, Fe, Re, Ae, Pe, ke, Ie, Le, Ue, De, Ne], ze = [{ name: "scale", type: "float", default: 1 }, { name: "offset", type: "float", default: 0 }];
+function X(t) {
+  return { name: t, type: "color", inputs: ze, glsl: `
 	return vec4(_c0.${t} * scale + offset);
 `, description: `Extract ${t === "r" ? "red" : t === "g" ? "green" : "blue"} channel` };
 }
-const Te = { name: "brightness", type: "color", inputs: [{ name: "amount", type: "float", default: 0.4 }], glsl: `
+const Ye = { name: "brightness", type: "color", inputs: [{ name: "amount", type: "float", default: 0.4 }], glsl: `
 	return vec4(_c0.rgb + vec3(amount), _c0.a);
-`, description: "Adjust brightness" }, Fe = { name: "contrast", type: "color", inputs: [{ name: "amount", type: "float", default: 1.6 }], glsl: `
+`, description: "Adjust brightness" }, Be = { name: "contrast", type: "color", inputs: [{ name: "amount", type: "float", default: 1.6 }], glsl: `
 	vec4 c = (_c0 - vec4(0.5)) * vec4(amount) + vec4(0.5);
 	return vec4(c.rgb, _c0.a);
-`, description: "Adjust contrast" }, Pe = { name: "invert", type: "color", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+`, description: "Adjust contrast" }, Ee = { name: "invert", type: "color", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
 	return vec4((1.0 - _c0.rgb) * amount + _c0.rgb * (1.0 - amount), _c0.a);
-`, description: "Invert colors" }, ke = { name: "saturate", type: "color", inputs: [{ name: "amount", type: "float", default: 2 }], glsl: `
+`, description: "Invert colors" }, Ve = { name: "saturate", type: "color", inputs: [{ name: "amount", type: "float", default: 2 }], glsl: `
 	vec3 intensity = vec3(_luminance(_c0.rgb));
 	return vec4(mix(intensity, _c0.rgb, amount), _c0.a);
-`, description: "Adjust saturation" }, Ie = { name: "hue", type: "color", inputs: [{ name: "hue", type: "float", default: 0.4 }], glsl: `
+`, description: "Adjust saturation" }, Xe = { name: "hue", type: "color", inputs: [{ name: "hue", type: "float", default: 0.4 }], glsl: `
 	vec3 c = _rgbToHsv(_c0.rgb);
 	c.r += hue;
 	return vec4(_hsvToRgb(c), _c0.a);
-`, description: "Shift hue" }, Le = { name: "colorama", type: "color", inputs: [{ name: "amount", type: "float", default: 5e-3 }], glsl: `
+`, description: "Shift hue" }, je = { name: "colorama", type: "color", inputs: [{ name: "amount", type: "float", default: 5e-3 }], glsl: `
 	vec3 c = _rgbToHsv(_c0.rgb);
 	c += vec3(amount);
 	c = _hsvToRgb(c);
 	c = fract(c);
 	return vec4(c, _c0.a);
-`, description: "Color cycle effect" }, Ae = { name: "posterize", type: "color", inputs: [{ name: "bins", type: "float", default: 3 }, { name: "gamma", type: "float", default: 0.6 }], glsl: `
+`, description: "Color cycle effect" }, qe = { name: "posterize", type: "color", inputs: [{ name: "bins", type: "float", default: 3 }, { name: "gamma", type: "float", default: 0.6 }], glsl: `
 	vec4 c2 = pow(_c0, vec4(gamma));
 	c2 *= vec4(bins);
 	c2 = floor(c2);
 	c2 /= vec4(bins);
 	c2 = pow(c2, vec4(1.0 / gamma));
 	return vec4(c2.xyz, _c0.a);
-`, description: "Posterize colors" }, Re = { name: "luma", type: "color", inputs: [{ name: "threshold", type: "float", default: 0.5 }, { name: "tolerance", type: "float", default: 0.1 }], glsl: `
+`, description: "Posterize colors" }, Ge = { name: "luma", type: "color", inputs: [{ name: "threshold", type: "float", default: 0.5 }, { name: "tolerance", type: "float", default: 0.1 }], glsl: `
 	float a = _smoothThreshold(_luminance(_c0.rgb), threshold, tolerance);
 	return vec4(_c0.rgb * a, a);
-`, description: "Luma key" }, Ue = { name: "thresh", type: "color", inputs: [{ name: "threshold", type: "float", default: 0.5 }, { name: "tolerance", type: "float", default: 0.04 }], glsl: `
+`, description: "Luma key" }, He = { name: "thresh", type: "color", inputs: [{ name: "threshold", type: "float", default: 0.5 }, { name: "tolerance", type: "float", default: 0.04 }], glsl: `
 	return vec4(vec3(_smoothThreshold(_luminance(_c0.rgb), threshold, tolerance)), _c0.a);
-`, description: "Threshold" }, ze = { name: "color", type: "color", inputs: [{ name: "r", type: "float", default: 1 }, { name: "g", type: "float", default: 1 }, { name: "b", type: "float", default: 1 }, { name: "a", type: "float", default: 1 }], glsl: `
+`, description: "Threshold" }, Ke = { name: "color", type: "color", inputs: [{ name: "r", type: "float", default: 1 }, { name: "g", type: "float", default: 1 }, { name: "b", type: "float", default: 1 }, { name: "a", type: "float", default: 1 }], glsl: `
 	vec4 c = vec4(r, g, b, a);
 	vec4 pos = step(0.0, c);
 	return vec4(mix((1.0 - _c0.rgb) * abs(c.rgb), c.rgb * _c0.rgb, pos.rgb), c.a * _c0.a);
-`, description: "Multiply by color" }, De = V("r"), Oe = V("g"), Ne = V("b"), Ve = { name: "shift", type: "color", inputs: [{ name: "r", type: "float", default: 0.5 }, { name: "g", type: "float", default: 0 }, { name: "b", type: "float", default: 0 }, { name: "a", type: "float", default: 0 }], glsl: `
+`, description: "Multiply by color" }, Qe = X("r"), We = X("g"), Je = X("b"), Ze = { name: "shift", type: "color", inputs: [{ name: "r", type: "float", default: 0.5 }, { name: "g", type: "float", default: 0 }, { name: "b", type: "float", default: 0 }, { name: "a", type: "float", default: 0 }], glsl: `
 	vec4 c2 = vec4(_c0);
 	c2.r += fract(r);
 	c2.g += fract(g);
 	c2.b += fract(b);
 	c2.a += fract(a);
 	return vec4(c2.rgba);
-`, description: "Shift color channels by adding offset values" }, Ee = { name: "gamma", type: "color", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+`, description: "Shift color channels by adding offset values" }, et = { name: "gamma", type: "color", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
 	return vec4(pow(max(vec3(0.0), _c0.rgb), vec3(1.0 / amount)), _c0.a);
-`, description: "Apply gamma correction" }, Be = { name: "levels", type: "color", inputs: [{ name: "inMin", type: "float", default: 0 }, { name: "inMax", type: "float", default: 1 }, { name: "outMin", type: "float", default: 0 }, { name: "outMax", type: "float", default: 1 }, { name: "gamma", type: "float", default: 1 }], glsl: `
+`, description: "Apply gamma correction" }, tt = { name: "levels", type: "color", inputs: [{ name: "inMin", type: "float", default: 0 }, { name: "inMax", type: "float", default: 1 }, { name: "outMin", type: "float", default: 0 }, { name: "outMax", type: "float", default: 1 }, { name: "gamma", type: "float", default: 1 }], glsl: `
 	vec3 v = clamp((_c0.rgb - vec3(inMin)) / (vec3(inMax - inMin) + 0.0000001), 0.0, 1.0);
 	v = pow(v, vec3(1.0 / gamma));
 	v = mix(vec3(outMin), vec3(outMax), v);
 	return vec4(v, _c0.a);
-`, description: "Adjust input/output levels and gamma" }, je = { name: "clamp", type: "color", inputs: [{ name: "min", type: "float", default: 0 }, { name: "max", type: "float", default: 1 }], glsl: `
+`, description: "Adjust input/output levels and gamma" }, nt = { name: "clamp", type: "color", inputs: [{ name: "min", type: "float", default: 0 }, { name: "max", type: "float", default: 1 }], glsl: `
 	return vec4(clamp(_c0.rgb, vec3(min), vec3(max)), _c0.a);
-`, description: "Clamp color values to a range" }, Ye = [Te, Fe, Pe, ke, Ie, Le, Ae, Re, Ue, ze, De, Oe, Ne, Ve, Ee, Be, je], Xe = { name: "add", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+`, description: "Clamp color values to a range" }, rt = [Ye, Be, Ee, Ve, Xe, je, qe, Ge, He, Ke, Qe, We, Je, Ze, et, tt, nt], ot = { name: "add", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
 	return (_c0 + _c1) * amount + _c0 * (1.0 - amount);
-`, description: "Add another source" }, Ge = { name: "sub", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+`, description: "Add another source" }, at = { name: "sub", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
 	return (_c0 - _c1) * amount + _c0 * (1.0 - amount);
-`, description: "Subtract another source" }, qe = { name: "mult", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+`, description: "Subtract another source" }, st = { name: "mult", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
 	return _c0 * (1.0 - amount) + (_c0 * _c1) * amount;
-`, description: "Multiply with another source" }, He = { name: "blend", type: "combine", inputs: [{ name: "amount", type: "float", default: 0.5 }], glsl: `
+`, description: "Multiply with another source" }, ct = { name: "blend", type: "combine", inputs: [{ name: "amount", type: "float", default: 0.5 }], glsl: `
 	return _c0 * (1.0 - amount) + _c1 * amount;
-`, description: "Blend with another source" }, Ke = { name: "diff", type: "combine", inputs: [], glsl: `
+`, description: "Blend with another source" }, lt = { name: "diff", type: "combine", inputs: [], glsl: `
 	return vec4(abs(_c0.rgb - _c1.rgb), max(_c0.a, _c1.a));
-`, description: "Difference with another source" }, Qe = { name: "layer", type: "combine", inputs: [], glsl: `
+`, description: "Difference with another source" }, it = { name: "layer", type: "combine", inputs: [], glsl: `
 	return vec4(mix(_c0.rgb, _c1.rgb, _c1.a), clamp(_c0.a + _c1.a, 0.0, 1.0));
-`, description: "Layer another source on top" }, We = { name: "mask", type: "combine", inputs: [], glsl: `
+`, description: "Layer another source on top" }, ut = { name: "mask", type: "combine", inputs: [], glsl: `
 	float a = _luminance(_c1.rgb);
 	return vec4(_c0.rgb * a, a * _c0.a);
-`, description: "Mask with another source" }, Je = [Xe, Ge, qe, He, Ke, Qe, We];
-function K(t) {
+`, description: "Mask with another source" }, ft = { name: "screen", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+	vec3 result = 1.0 - (1.0 - _c0.rgb) * (1.0 - _c1.rgb);
+	vec3 outRgb = mix(_c0.rgb, result, amount);
+	float outA = mix(_c0.a, _c1.a, amount);
+	return vec4(outRgb, outA);
+`, description: "Screen blend with another source" }, mt = { name: "overlay", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+	vec3 mult = 2.0 * _c0.rgb * _c1.rgb;
+	vec3 screen = 1.0 - 2.0 * (1.0 - _c0.rgb) * (1.0 - _c1.rgb);
+	vec3 result = mix(mult, screen, step(0.5, _c0.rgb));
+	vec3 outRgb = mix(_c0.rgb, result, amount);
+	float outA = mix(_c0.a, _c1.a, amount);
+	return vec4(outRgb, outA);
+`, description: "Overlay blend with another source" }, pt = { name: "softlight", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+	vec3 result = (1.0 - 2.0 * _c1.rgb) * _c0.rgb * _c0.rgb + 2.0 * _c1.rgb * _c0.rgb;
+	vec3 outRgb = mix(_c0.rgb, result, amount);
+	float outA = mix(_c0.a, _c1.a, amount);
+	return vec4(outRgb, outA);
+`, description: "Soft light blend with another source" }, dt = { name: "hardlight", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+	vec3 mult = 2.0 * _c0.rgb * _c1.rgb;
+	vec3 screen = 1.0 - 2.0 * (1.0 - _c0.rgb) * (1.0 - _c1.rgb);
+	vec3 result = mix(mult, screen, step(0.5, _c1.rgb));
+	vec3 outRgb = mix(_c0.rgb, result, amount);
+	float outA = mix(_c0.a, _c1.a, amount);
+	return vec4(outRgb, outA);
+`, description: "Hard light blend with another source" }, ht = { name: "dodge", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+	vec3 result = _c0.rgb / max(vec3(0.00001), 1.0 - _c1.rgb);
+	result = clamp(result, 0.0, 1.0);
+	vec3 outRgb = mix(_c0.rgb, result, amount);
+	float outA = mix(_c0.a, _c1.a, amount);
+	return vec4(outRgb, outA);
+`, description: "Color dodge blend with another source" }, gt = { name: "burn", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+	vec3 result = 1.0 - (1.0 - _c0.rgb) / max(vec3(0.00001), _c1.rgb);
+	result = clamp(result, 0.0, 1.0);
+	vec3 outRgb = mix(_c0.rgb, result, amount);
+	float outA = mix(_c0.a, _c1.a, amount);
+	return vec4(outRgb, outA);
+`, description: "Color burn blend with another source" }, yt = { name: "lighten", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+	vec3 result = max(_c0.rgb, _c1.rgb);
+	vec3 outRgb = mix(_c0.rgb, result, amount);
+	float outA = mix(_c0.a, _c1.a, amount);
+	return vec4(outRgb, outA);
+`, description: "Lighten blend with another source" }, _t = { name: "darken", type: "combine", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+	vec3 result = min(_c0.rgb, _c1.rgb);
+	vec3 outRgb = mix(_c0.rgb, result, amount);
+	float outA = mix(_c0.a, _c1.a, amount);
+	return vec4(outRgb, outA);
+`, description: "Darken blend with another source" }, vt = [ot, at, st, ct, lt, it, ut, ft, mt, pt, dt, ht, gt, yt, _t];
+function J(t) {
   const e = t === "x" ? "scrollX" : "scrollY";
   return { name: t === "x" ? "modulateScrollX" : "modulateScrollY", type: "combineCoord", inputs: [{ name: e, type: "float", default: 0.5 }, { name: "speed", type: "float", default: 0 }], glsl: `
 	vec2 st = _st;
@@ -289,30 +415,30 @@ function K(t) {
 	return fract(st);
 `, description: `Modulate ${t.toUpperCase()} scroll with another source` };
 }
-function Q(t) {
+function Z(t) {
   return { name: t === "x" ? "modulateRepeatX" : "modulateRepeatY", type: "combineCoord", inputs: [{ name: "reps", type: "float", default: 3 }, { name: "offset", type: "float", default: 0.5 }], glsl: `
 	vec2 st = _st * vec2(${t === "x" ? "reps, 1.0" : "1.0, reps"});
 	st.${t === "x" ? "y" : "x"} += step(1.0, mod(st.${t}, 2.0)) + _c0.r * offset;
 	return fract(st);
 `, description: `Modulate ${t.toUpperCase()} repeat with another source` };
 }
-const Ze = { name: "modulate", type: "combineCoord", inputs: [{ name: "amount", type: "float", default: 0.1 }], glsl: `
+const xt = { name: "modulate", type: "combineCoord", inputs: [{ name: "amount", type: "float", default: 0.1 }], glsl: `
 	return _st + _c0.xy * amount;
-`, description: "Modulate coordinates with another source" }, et = { name: "modulateScale", type: "combineCoord", inputs: [{ name: "multiple", type: "float", default: 1 }, { name: "offset", type: "float", default: 1 }], glsl: `
+`, description: "Modulate coordinates with another source" }, Ct = { name: "modulateScale", type: "combineCoord", inputs: [{ name: "multiple", type: "float", default: 1 }, { name: "offset", type: "float", default: 1 }], glsl: `
 	vec2 xy = _st - vec2(0.5);
 	xy *= (1.0 / vec2(offset + multiple * _c0.r, offset + multiple * _c0.g));
 	xy += vec2(0.5);
 	return xy;
-`, description: "Modulate scale with another source" }, tt = { name: "modulateRotate", type: "combineCoord", inputs: [{ name: "multiple", type: "float", default: 1 }, { name: "offset", type: "float", default: 0 }], glsl: `
+`, description: "Modulate scale with another source" }, bt = { name: "modulateRotate", type: "combineCoord", inputs: [{ name: "multiple", type: "float", default: 1 }, { name: "offset", type: "float", default: 0 }], glsl: `
 	vec2 xy = _st - vec2(0.5);
 	float angle = offset + _c0.x * multiple;
 	xy = mat2(cos(angle), -sin(angle), sin(angle), cos(angle)) * xy;
 	xy += 0.5;
 	return xy;
-`, description: "Modulate rotation with another source" }, nt = { name: "modulatePixelate", type: "combineCoord", inputs: [{ name: "multiple", type: "float", default: 10 }, { name: "offset", type: "float", default: 3 }], glsl: `
+`, description: "Modulate rotation with another source" }, St = { name: "modulatePixelate", type: "combineCoord", inputs: [{ name: "multiple", type: "float", default: 10 }, { name: "offset", type: "float", default: 3 }], glsl: `
 	vec2 xy = vec2(offset + _c0.x * multiple, offset + _c0.y * multiple);
 	return (floor(_st * xy) + 0.5) / xy;
-`, description: "Modulate pixelation with another source" }, rt = { name: "modulateKaleid", type: "combineCoord", inputs: [{ name: "nSides", type: "float", default: 4 }], glsl: `
+`, description: "Modulate pixelation with another source" }, wt = { name: "modulateKaleid", type: "combineCoord", inputs: [{ name: "nSides", type: "float", default: 4 }], glsl: `
 	vec2 st = _st - 0.5;
 	float r = length(st);
 	float a = atan(st.y, st.x);
@@ -320,24 +446,24 @@ const Ze = { name: "modulate", type: "combineCoord", inputs: [{ name: "amount",
 	a = mod(a, pi / nSides);
 	a = abs(a - pi / nSides / 2.0);
 	return (_c0.r + r) * vec2(cos(a), sin(a));
-`, description: "Modulate kaleidoscope with another source" }, ot = K("x"), at = K("y"), st = { name: "modulateRepeat", type: "combineCoord", inputs: [{ name: "repeatX", type: "float", default: 3 }, { name: "repeatY", type: "float", default: 3 }, { name: "offsetX", type: "float", default: 0.5 }, { name: "offsetY", type: "float", default: 0.5 }], glsl: `
+`, description: "Modulate kaleidoscope with another source" }, $t = J("x"), Mt = J("y"), Tt = { name: "modulateRepeat", type: "combineCoord", inputs: [{ name: "repeatX", type: "float", default: 3 }, { name: "repeatY", type: "float", default: 3 }, { name: "offsetX", type: "float", default: 0.5 }, { name: "offsetY", type: "float", default: 0.5 }], glsl: `
 	vec2 st = _st * vec2(repeatX, repeatY);
 	st.x += step(1.0, mod(st.y, 2.0)) + _c0.r * offsetX;
 	st.y += step(1.0, mod(st.x, 2.0)) + _c0.g * offsetY;
 	return fract(st);
-`, description: "Modulate repeat pattern with another source" }, ct = Q("x"), it = Q("y"), lt = { name: "modulateHue", type: "combineCoord", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
+`, description: "Modulate repeat pattern with another source" }, Ft = Z("x"), Rt = Z("y"), At = { name: "modulateHue", type: "combineCoord", inputs: [{ name: "amount", type: "float", default: 1 }], glsl: `
 	return _st + (vec2(_c0.g - _c0.r, _c0.b - _c0.g) * amount * 1.0 / resolution);
-`, description: "Modulate coordinates based on hue differences" }, ut = [Ze, et, tt, nt, rt, ot, at, st, ct, it, lt], ft = [...he, ...Me, ...Ye, ...Je, ...ut];
-class F {
+`, description: "Modulate coordinates based on hue differences" }, Pt = [xt, Ct, bt, St, wt, $t, Mt, Tt, Ft, Rt, At], kt = [...ve, ...Oe, ...rt, ...vt, ...Pt];
+class k {
   _transforms;
   constructor(e) {
     this._transforms = e;
   }
   static empty() {
-    return new F([]);
+    return new k([]);
   }
   static from(e) {
-    return new F([...e]);
+    return new k([...e]);
   }
   get transforms() {
     return this._transforms;
@@ -352,7 +478,7 @@ class F {
     return this._transforms.length === 0;
   }
   append(e) {
-    return new F([...this._transforms, e]);
+    return new k([...this._transforms, e]);
   }
   get(e) {
     return this._transforms[e];
@@ -361,7 +487,7 @@ class F {
     return this._transforms[Symbol.iterator]();
   }
 }
-class y {
+class _ {
   _chain;
   _charMapping;
   _nestedSources;
@@ -369,8 +495,9 @@ class y {
   _charColorSource;
   _cellColorSource;
   _charSource;
+  _textmodeSourceRefs;
   constructor(e) {
-    this._chain = e?.chain ?? F.empty(), this._charMapping = e?.charMapping, this._charColorSource = e?.charColorSource, this._cellColorSource = e?.cellColorSource, this._charSource = e?.charSource, this._nestedSources = e?.nestedSources ?? /* @__PURE__ */ new Map(), this._externalLayerRefs = e?.externalLayerRefs ?? /* @__PURE__ */ new Map();
+    this._chain = e?.chain ?? k.empty(), this._charMapping = e?.charMapping, this._charColorSource = e?.charColorSource, this._cellColorSource = e?.cellColorSource, this._charSource = e?.charSource, this._nestedSources = e?.nestedSources ?? /* @__PURE__ */ new Map(), this._externalLayerRefs = e?.externalLayerRefs ?? /* @__PURE__ */ new Map(), this._textmodeSourceRefs = e?.textmodeSourceRefs ?? /* @__PURE__ */ new Map();
   }
   addTransform(e, n) {
     const r = { name: e, userArgs: n };
@@ -384,14 +511,19 @@ class y {
     const n = this._chain.length;
     return this._externalLayerRefs.set(n, e), this.addTransform("src", []);
   }
+  addTextmodeSourceRef(e) {
+    const n = this._chain.length;
+    return this._textmodeSourceRefs.set(n, e), this.addTransform("srcTexture", []);
+  }
   charMap(e) {
+    if (e.length === 0) return this._charMapping = void 0, this;
     const n = Array.from(e), r = [];
     for (const o of n) r.push(o.codePointAt(0) ?? 32);
     return this._charMapping = { chars: e, indices: r }, this;
   }
   _ensureSource(e, n, r, o) {
-    if (e instanceof y) return e;
-    const a = new y(), u = typeof e == "number" && n === void 0 && r === void 0 && o === void 0 ? [e, e, e, null] : [e, n, r, o].map((s) => s === void 0 ? null : s);
+    if (e instanceof _) return e;
+    const a = new _(), u = typeof e == "number" && n === void 0 && r === void 0 && o === void 0 ? [e, e, e, null] : [e, n, r, o].map((l) => l === void 0 ? null : l);
     return a.addTransform("solid", u), a;
   }
   charColor(e, n, r, o) {
@@ -409,10 +541,12 @@ class y {
   }
   clone() {
     const e = /* @__PURE__ */ new Map();
-    for (const [r, o] of this._nestedSources) e.set(r, o.clone());
+    for (const [o, a] of this._nestedSources) e.set(o, a.clone());
     const n = /* @__PURE__ */ new Map();
-    for (const [r, o] of this._externalLayerRefs) n.set(r, { ...o });
-    return new y({ chain: F.from(this._chain.transforms), charMapping: this._charMapping, charColorSource: this._charColorSource?.clone(), cellColorSource: this._cellColorSource?.clone(), charSource: this._charSource?.clone(), nestedSources: e, externalLayerRefs: n });
+    for (const [o, a] of this._externalLayerRefs) n.set(o, { ...a });
+    const r = /* @__PURE__ */ new Map();
+    for (const [o, a] of this._textmodeSourceRefs) r.set(o, { ...a });
+    return new _({ chain: k.from(this._chain.transforms), charMapping: this._charMapping, charColorSource: this._charColorSource?.clone(), cellColorSource: this._cellColorSource?.clone(), charSource: this._charSource?.clone(), nestedSources: e, externalLayerRefs: n, textmodeSourceRefs: r });
   }
   get transforms() {
     return this._chain.transforms;
@@ -435,53 +569,56 @@ class y {
   get externalLayerRefs() {
     return this._externalLayerRefs;
   }
+  get textmodeSourceRefs() {
+    return this._textmodeSourceRefs;
+  }
 }
-const D = { linear: (t) => t, easeInQuad: (t) => t * t, easeOutQuad: (t) => t * (2 - t), easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : (4 - 2 * t) * t - 1, easeInCubic: (t) => t * t * t, easeOutCubic: (t) => --t * t * t + 1, easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1, easeInQuart: (t) => t * t * t * t, easeOutQuart: (t) => 1 - --t * t * t * t, easeInOutQuart: (t) => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t, easeInQuint: (t) => t * t * t * t * t, easeOutQuint: (t) => 1 + --t * t * t * t * t, easeInOutQuint: (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * --t * t * t * t * t, sin: (t) => (1 + Math.sin(Math.PI * t - Math.PI / 2)) / 2 };
-function X(t, e) {
+const E = { linear: (t) => t, easeInQuad: (t) => t * t, easeOutQuad: (t) => t * (2 - t), easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : (4 - 2 * t) * t - 1, easeInCubic: (t) => t * t * t, easeOutCubic: (t) => --t * t * t + 1, easeInOutCubic: (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1, easeInQuart: (t) => t * t * t * t, easeOutQuart: (t) => 1 - --t * t * t * t, easeInOutQuart: (t) => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t, easeInQuint: (t) => t * t * t * t * t, easeOutQuint: (t) => 1 + --t * t * t * t * t, easeInOutQuint: (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * --t * t * t * t * t, sin: (t) => (1 + Math.sin(Math.PI * t - Math.PI / 2)) / 2 };
+function H(t, e) {
   return (t % e + e) % e;
 }
-function pt(t, e, n, r, o) {
+function It(t, e, n, r, o) {
   return e === n ? (r + o) / 2 : (t - e) * (o - r) / (n - e) + r;
 }
-function mt() {
+function Lt() {
   "fast" in Array.prototype || (Object.defineProperty(Array.prototype, "fast", { value: function(t = 1) {
     return this._speed = t, this;
   }, writable: !0, configurable: !0, enumerable: !1 }), Object.defineProperty(Array.prototype, "smooth", { value: function(t = 1) {
     return this._smooth = t, this;
   }, writable: !0, configurable: !0, enumerable: !1 }), Object.defineProperty(Array.prototype, "ease", { value: function(t = "linear") {
-    return typeof t == "function" ? (this._smooth = 1, this._ease = t) : D[t] && (this._smooth = 1, this._ease = D[t]), this;
+    return typeof t == "function" ? (this._smooth = 1, this._ease = t) : E[t] && (this._smooth = 1, this._ease = E[t]), this;
   }, writable: !0, configurable: !0, enumerable: !1 }), Object.defineProperty(Array.prototype, "offset", { value: function(t = 0.5) {
     return this._offset = t % 1, this;
   }, writable: !0, configurable: !0, enumerable: !1 }), Object.defineProperty(Array.prototype, "fit", { value: function(t = 0, e = 1) {
-    const n = Math.min(...this), r = Math.max(...this), o = this.map((a) => pt(a, n, r, t, e));
+    const n = Math.min(...this), r = Math.max(...this), o = this.map((a) => It(a, n, r, t, e));
     return o._speed = this._speed, o._smooth = this._smooth, o._ease = this._ease, o._offset = this._offset, o;
   }, writable: !0, configurable: !0, enumerable: !1 }));
 }
-function ht(t, e) {
+function Ut(t, e) {
   const n = t._speed ?? 1, r = t._smooth ?? 0;
   let o = e.time * n * (e.bpm / 60) + (t._offset ?? 0);
   if (r !== 0) {
-    const a = t._ease ?? D.linear, u = o - r / 2, s = Math.floor(u), c = X(s, t.length), i = (c + 1) % t.length, l = t[c], p = t[i];
-    return a(Math.min((u - s) / r, 1)) * (p - l) + l;
+    const a = t._ease ?? E.linear, u = o - r / 2, l = Math.floor(u), m = H(l, t.length), i = (m + 1) % t.length, s = t[m], c = t[i];
+    return a(Math.min((u - l) / r, 1)) * (c - s) + s;
   }
-  return t[Math.floor(X(o, t.length))];
+  return t[Math.floor(H(o, t.length))];
 }
-function dt(t) {
+function Dt(t) {
   return Array.isArray(t) && t.length > 0 && typeof t[0] == "number";
 }
-mt(), P.registerMany(ft), z.setSynthSourceClass(y), z.injectMethods(y.prototype);
-const w = z.generateStandaloneFunctions(), _ = "textmode.synth.js";
-function O(t) {
+Lt(), L.registerMany(kt), B.setSynthSourceClass(_), B.injectMethods(_.prototype);
+const S = B.generateStandaloneFunctions(), C = "textmode.synth.js";
+function V(t) {
   return t === "char" || t === "cellColor" ? t : "charColor";
 }
-function W(t, e) {
-  const n = O(e);
+function ee(t, e) {
+  const n = V(e);
   n === "char" ? t.usesChar = !0 : n === "cellColor" ? t.usesCellColor = !0 : t.usesCharColor = !0;
 }
-class yt {
+class Nt {
   _usage = { usesChar: !1, usesCharColor: !1, usesCellColor: !1 };
   trackUsage(e) {
-    W(this._usage, e);
+    ee(this._usage, e);
   }
   reset() {
     this._usage.usesChar = !1, this._usage.usesCharColor = !1, this._usage.usesCellColor = !1;
@@ -502,7 +639,7 @@ class yt {
     return this._usage.usesCellColor;
   }
 }
-class gt {
+class Ot {
   _externalLayers = /* @__PURE__ */ new Map();
   _counter = 0;
   _layerIdToPrefix = /* @__PURE__ */ new Map();
@@ -513,7 +650,7 @@ class gt {
   trackUsage(e, n) {
     const r = this.getPrefix(e.layerId);
     let o = this._externalLayers.get(e.layerId);
-    o || (o = { layerId: e.layerId, uniformPrefix: r, usesChar: !1, usesCharColor: !1, usesCellColor: !1 }, this._externalLayers.set(e.layerId, o)), W(o, n);
+    o || (o = { layerId: e.layerId, uniformPrefix: r, usesChar: !1, usesCharColor: !1, usesCellColor: !1 }, this._externalLayers.set(e.layerId, o)), ee(o, n);
   }
   hasLayer(e) {
     return this._externalLayers.has(e);
@@ -534,74 +671,134 @@ class gt {
     this._externalLayers.clear(), this._counter = 0, this._layerIdToPrefix.clear();
   }
 }
-class _t {
-  getContextAwareGlslFunction(e, n, r, o, a) {
-    return n !== "src" ? e.glslFunction : o && a ? this._generateExternalSrcFunction(o, r, a) : this._generateSelfFeedbackSrcFunction(r);
+class zt {
+  _sources = /* @__PURE__ */ new Map();
+  _counter = 0;
+  reset() {
+    this._sources.clear(), this._counter = 0;
+  }
+  trackUsage(e, n) {
+    let r = this._sources.get(e.sourceId);
+    switch (r || (r = { sourceId: e.sourceId, uniformName: "u_tms" + this._counter++, usesChar: !1, usesCharColor: !1, usesCellColor: !1, sourceRef: e }, this._sources.set(e.sourceId, r)), n) {
+      case "char":
+        r.usesChar = !0;
+        break;
+      case "charColor":
+      case "main":
+        r.usesCharColor = !0;
+        break;
+      case "cellColor":
+        r.usesCellColor = !0;
+    }
+  }
+  getSources() {
+    return this._sources;
+  }
+  getUniformName(e) {
+    return this._sources.get(e)?.uniformName ?? "u_tms0";
+  }
+  hasAnySources() {
+    return this._sources.size > 0;
+  }
+}
+class Yt {
+  getContextAwareGlslFunction(e, n, r, o, a, u, l) {
+    return n === "srcTexture" && a && l ? this._generateTextmodeSourceFunction(a, r, l) : n !== "src" ? e.glslFunction : o && u ? this._generateExternalSrcFunction(o, r, u) : this._generateSelfFeedbackSrcFunction(r);
   }
-  getFunctionName(e, n, r, o) {
-    return e.name !== "src" ? e.name : r && o ? `src_ext_${o(r.layerId)}_${n}` : `src_${n}`;
+  getFunctionName(e, n, r, o, a, u) {
+    return e.name === "srcTexture" && o && u ? `srcTexture_${u(o.sourceId)}_${n}` : e.name !== "src" ? e.name : r && a ? `src_ext_${a(r.layerId)}_${n}` : `src_${n}`;
   }
-  generateTransformCode(e, n, r, o, a, u, s, c, i, l, p, f, g) {
-    const v = this.getFunctionName(n, l, f, g), C = (...m) => [...m, ...i].join(", ");
-    let h = a, d = u, b = s, x = c;
+  generateTransformCode(e, n, r, o, a, u, l, m, i, s, c, f, p, b, w) {
+    const d = this.getFunctionName(n, s, f, p, b, w), g = (...h) => [...h, ...i].join(", ");
+    let v = a, M = u, x = l, I = m;
     switch (n.type) {
       case "src": {
-        const m = `c${r}`;
-        e.push(`	vec4 ${m} = ${v}(${C(o)});`), h = m;
+        const h = `c${r}`;
+        e.push(`	vec4 ${h} = ${d}(${g(o)});`), v = h;
         break;
       }
       case "coord": {
-        const m = `st${r}`;
-        e.push(`	vec2 ${m} = ${v}(${C(o)});`), e.push(`	${o} = ${m};`);
+        const h = `st${r}`;
+        e.push(`	vec2 ${h} = ${d}(${g(o)});`), e.push(`	${o} = ${h};`);
         break;
       }
       case "color": {
-        const m = `c${r}`;
-        e.push(`	vec4 ${m} = ${v}(${C(a)});`), h = m;
+        const h = `c${r}`;
+        e.push(`	vec4 ${h} = ${d}(${g(a)});`), v = h;
         break;
       }
       case "combine": {
-        const m = `c${r}`;
-        e.push(`	vec4 ${m} = ${v}(${C(a, p ?? "vec4(0.0)")});`), h = m;
+        const h = `c${r}`;
+        e.push(`	vec4 ${h} = ${d}(${g(a, c ?? "vec4(0.0)")});`), v = h;
         break;
       }
       case "combineCoord": {
-        const m = `st${r}`;
-        e.push(`	vec2 ${m} = ${v}(${C(o, p ?? "vec4(0.0)")});`), e.push(`	${o} = ${m};`);
+        const h = `st${r}`;
+        e.push(`	vec2 ${h} = ${d}(${g(o, c ?? "vec4(0.0)")});`), e.push(`	${o} = ${h};`);
         break;
       }
     }
-    return { colorVar: h, charVar: d, flagsVar: b, rotationVar: x };
+    return { colorVar: v, charVar: M, flagsVar: x, rotationVar: I };
   }
   _generateExternalSrcFunction(e, n, r) {
-    const o = r(e.layerId), a = O(n);
+    const o = r(e.layerId), a = V(n);
     return `
 vec4 ${`src_ext_${o}_${n}`}(vec2 _st) {
-	return texture(${`${o}${$[a]}`}, fract(_st));
+	return texture(${`${o}${R[a]}`}, fract(_st));
 }
 `;
   }
   _generateSelfFeedbackSrcFunction(e) {
-    const n = O(e);
+    const n = V(e);
     return `
 vec4 ${`src_${e}`}(vec2 _st) {
-	return texture(${S[n]}, fract(_st));
+	return texture(${$[n]}, fract(_st));
+}
+`;
+  }
+  _generateTextmodeSourceFunction(e, n, r) {
+    const o = r(e.sourceId);
+    return `
+vec4 ${`srcTexture_${o}_${n}`}(vec2 _st) {
+	// Flip Y axis to match image orientation (top-left origin)
+	vec2 st = vec2(_st.x, 1.0 - _st.y);
+
+	// Source dimensions
+	vec2 dim = ${o}_dim;
+
+	// Scale coordinates based on source dimensions vs grid resolution
+	// Higher scale value = smaller texture relative to screen
+	vec2 scale = u_resolution / dim;
+	
+	// Calculate offset to center the texture
+	// offset = (scale - 1.0) * 0.5
+	vec2 offset = (scale - 1.0) * 0.5;
+	
+	// Apply scaling and offset
+	vec2 uv = st * scale - offset;
+
+	// Bounds check - return black/transparent if outside texture area
+	if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+		return vec4(0.0);
+	}
+
+	return texture(${o}, uv);
 }
 `;
   }
 }
-let J = null;
-function Dt(t) {
-  J = t;
+let te = null;
+function cn(t) {
+  te = t;
 }
-function G(t, e, n) {
-  const r = n ?? J;
+function K(t, e, n) {
+  const r = n ?? te;
   if (r) try {
     r(t, e);
   } catch {
   }
 }
-function Z(t) {
+function ne(t) {
   if (t === void 0) return "undefined";
   if (t === null) return "null";
   if (typeof t == "number") {
@@ -610,37 +807,37 @@ function Z(t) {
   }
   if (Array.isArray(t)) {
     const e = t.findIndex((n) => typeof n != "number" || !Number.isFinite(n));
-    if (e >= 0) return `array with invalid element at index ${e}: ${Z(t[e])}`;
+    if (e >= 0) return `array with invalid element at index ${e}: ${ne(t[e])}`;
   }
   return String(t);
 }
-function vt(t) {
+function Bt(t) {
   return t != null && (typeof t == "number" ? Number.isFinite(t) : !!Array.isArray(t) && t.length > 0 && t.every((e) => typeof e == "number" && Number.isFinite(e)));
 }
-function Ct(t, e, n) {
+function Et(t, e, n) {
   return (r) => {
     let o;
     try {
       o = t(r);
     } catch (a) {
-      return G(a, e, r.onError), n;
+      return K(a, e, r.onError), n;
     }
-    return vt(o) ? o : (G(new Error(`[textmode.synth.js] Invalid dynamic parameter value for "${e}": ${Z(o)}`), e, r.onError), n);
+    return Bt(o) ? o : (K(new Error(`[textmode.synth.js] Invalid dynamic parameter value for "${e}": ${ne(o)}`), e, r.onError), n);
   };
 }
-class xt {
+class Vt {
   _uniforms = /* @__PURE__ */ new Map();
   _dynamicUpdaters = /* @__PURE__ */ new Map();
   processArgument(e, n, r) {
-    return dt(e) ? this._createDynamicUniform(n, r, (o) => ht(e, o)) : typeof e == "function" ? this._createDynamicUniform(n, r, e) : typeof e == "number" ? { glslValue: R(e) } : this.processDefault(n);
+    return Dt(e) ? this._createDynamicUniform(n, r, (o) => Ut(e, o)) : typeof e == "function" ? this._createDynamicUniform(n, r, e) : typeof e == "number" ? { glslValue: z(e) } : this.processDefault(n);
   }
   _createDynamicUniform(e, n, r) {
-    const o = `${n}_${e.name}`, a = { name: o, type: e.type, value: e.default ?? 0, isDynamic: !0 }, u = Ct(r, o, a.value);
+    const o = `${n}_${e.name}`, a = { name: o, type: e.type, value: e.default ?? 0, isDynamic: !0 }, u = Et(r, o, a.value);
     return this._uniforms.set(o, a), this._dynamicUpdaters.set(o, u), { glslValue: o, uniform: a, updater: u };
   }
   processDefault(e) {
     const n = e.default;
-    return typeof n == "number" ? { glslValue: R(n) } : Array.isArray(n) ? { glslValue: `vec${n.length}(${n.map(R).join(", ")})` } : { glslValue: "0.0" };
+    return typeof n == "number" ? { glslValue: z(n) } : Array.isArray(n) ? { glslValue: `vec${n.length}(${n.map(z).join(", ")})` } : { glslValue: "0.0" };
   }
   getUniforms() {
     return new Map(this._uniforms);
@@ -652,10 +849,10 @@ class xt {
     this._uniforms.clear(), this._dynamicUpdaters.clear();
   }
 }
-function R(t) {
+function z(t) {
   return Number.isInteger(t) ? t.toString() + ".0" : t.toString();
 }
-const bt = `
+const Xt = `
 // Utility functions
 float _luminance(vec3 rgb) {
 	const vec3 W = vec3(0.2125, 0.7154, 0.0721);
@@ -764,21 +961,25 @@ int _unpackChar(vec4 c) {
 	return int(c.r * 255.0 + c.g * 255.0 * 256.0);
 }
 `;
-function St(t) {
-  const { uniforms: e, glslFunctions: n, mainCode: r, charOutputCode: o, primaryColorVar: a, cellColorVar: u, charMapping: s, usesFeedback: c, usesCharFeedback: i, usesCellColorFeedback: l, usesCharSource: p, externalLayers: f } = t, g = Array.from(e.values()).map((m) => `uniform ${m.type} ${m.name};`).join(`
+function jt(t) {
+  const { uniforms: e, glslFunctions: n, mainCode: r, charOutputCode: o, primaryColorVar: a, cellColorVar: u, charMapping: l, usesFeedback: m, usesCharFeedback: i, usesCellColorFeedback: s, usesCharSource: c, externalLayers: f, textmodeSources: p } = t, b = Array.from(e.values()).map((y) => `uniform ${y.type} ${y.name};`).join(`
 `);
-  let v = "", C = "";
-  s && (v = `uniform int u_charMap[${s.indices.length}];
-uniform int u_charMapSize;`, C = `
+  let w = "", d = "";
+  l && (w = `uniform int u_charMap[${l.indices.length}];
+uniform int u_charMapSize;`, d = `
 	// Apply character mapping
 	int rawCharIdx = _unpackChar(charOutput);
 	int mappedCharIdx = u_charMap[int(mod(float(rawCharIdx), float(u_charMapSize)))];
 	charOutput = _packChar(mappedCharIdx);`);
-  const h = [];
-  c && h.push(`uniform sampler2D ${S.charColor};`), i && h.push(`uniform sampler2D ${S.char};`), l && h.push(`uniform sampler2D ${S.cellColor};`);
-  const d = h.join(`
-`), b = p ? "uniform float u_charSourceCount;" : "", x = [];
-  if (f) for (const [, m] of f) m.usesChar && x.push(`uniform sampler2D ${m.uniformPrefix}${$.char};`), m.usesCharColor && x.push(`uniform sampler2D ${m.uniformPrefix}${$.charColor};`), m.usesCellColor && x.push(`uniform sampler2D ${m.uniformPrefix}${$.cellColor};`);
+  const g = [];
+  m && g.push(`uniform sampler2D ${$.charColor};`), i && g.push(`uniform sampler2D ${$.char};`), s && g.push(`uniform sampler2D ${$.cellColor};`);
+  const v = g.join(`
+`), M = c ? "uniform float u_charSourceCount;" : "", x = [];
+  if (f) for (const [, y] of f) y.usesChar && x.push(`uniform sampler2D ${y.uniformPrefix}${R.char};`), y.usesCharColor && x.push(`uniform sampler2D ${y.uniformPrefix}${R.charColor};`), y.usesCellColor && x.push(`uniform sampler2D ${y.uniformPrefix}${R.cellColor};`);
+  const I = x.length > 0 ? `// External layer samplers
+${x.join(`
+`)}` : "", h = [];
+  if (p) for (const [, y] of p) h.push(`uniform sampler2D ${y.uniformName};`), h.push(`uniform vec2 ${y.uniformName}_dim;`);
   return `#version 300 es
 precision highp float;
 
@@ -792,18 +993,19 @@ layout(location = 2) out vec4 o_secondaryColor;
 
 // Standard uniforms
 uniform float time;
-uniform vec2 resolution;
-${d}
-${x.length > 0 ? `// External layer samplers
-${x.join(`
-`)}` : ""}
+uniform vec2 u_resolution;
 ${v}
-${b}
+${I}
+${h.length > 0 ? `// TextmodeSource samplers (images/videos)
+${h.join(`
+`)}` : ""}
+${w}
+${M}
 
 // Dynamic uniforms
-${g}
+${b}
 
-${bt}
+${Xt}
 
 // Transform functions
 ${Array.from(n).join(`
@@ -815,7 +1017,7 @@ ${r.join(`
 `)}
 
 ${o}
-${C}
+${d}
 
 	// Output to MRT
 	o_character = charOutput;
@@ -824,7 +1026,7 @@ ${C}
 }
 `;
 }
-function wt(t, e, n) {
+function qt(t, e, n) {
   return t ? `
 	// Character output from generator
 	vec4 charOutput = ${e};` : `
@@ -834,13 +1036,14 @@ function wt(t, e, n) {
 	vec4 charOutput = _packChar(charIdx);`;
 }
 function N(t) {
-  return new Mt().compile(t);
-}
-class Mt {
-  _uniformManager = new xt();
-  _feedbackTracker = new yt();
-  _externalLayerManager = new gt();
-  _codeGenerator = new _t();
+  return new Gt().compile(t);
+}
+class Gt {
+  _uniformManager = new Vt();
+  _feedbackTracker = new Nt();
+  _externalLayerManager = new Ot();
+  _textmodeSourceManager = new zt();
+  _codeGenerator = new Yt();
   _glslFunctions = /* @__PURE__ */ new Set();
   _mainCode = [];
   _varCounter = 0;
@@ -855,42 +1058,42 @@ class Mt {
     e.charColorSource && (o = this._compileChain(e.charColorSource, "charColor", "vec4(1.0, 1.0, 1.0, 1.0)", "v_uv", "charColor").colorVar);
     let a = "vec4(0.0, 0.0, 0.0, 0.0)";
     e.cellColorSource && (a = this._compileChain(e.cellColorSource, "cellColor", "vec4(0.0, 0.0, 0.0, 0.0)", "v_uv", "cellColor").colorVar);
-    const u = wt(!!r, r ?? "vec4(0.0)", n.colorVar), s = this._feedbackTracker.getUsage();
-    return { fragmentSource: St({ uniforms: this._uniformManager.getUniforms(), glslFunctions: this._glslFunctions, mainCode: this._mainCode, charOutputCode: u, primaryColorVar: o, cellColorVar: a, charMapping: e.charMapping, usesFeedback: s.usesCharColorFeedback, usesCharFeedback: s.usesCharFeedback, usesCellColorFeedback: s.usesCellColorFeedback, usesCharSource: this._usesCharSource, externalLayers: this._externalLayerManager.getExternalLayers() }), uniforms: this._uniformManager.getUniforms(), dynamicUpdaters: this._uniformManager.getDynamicUpdaters(), charMapping: e.charMapping, usesCharColorFeedback: s.usesCharColorFeedback, usesCharFeedback: s.usesCharFeedback, usesCellColorFeedback: s.usesCellColorFeedback, usesCharSource: this._usesCharSource, externalLayers: this._externalLayerManager.getExternalLayers() };
+    const u = qt(!!r, r ?? "vec4(0.0)", n.colorVar), l = this._feedbackTracker.getUsage();
+    return { fragmentSource: jt({ uniforms: this._uniformManager.getUniforms(), glslFunctions: this._glslFunctions, mainCode: this._mainCode, charOutputCode: u, primaryColorVar: o, cellColorVar: a, charMapping: e.charMapping, usesFeedback: l.usesCharColorFeedback, usesCharFeedback: l.usesCharFeedback, usesCellColorFeedback: l.usesCellColorFeedback, usesCharSource: this._usesCharSource, externalLayers: this._externalLayerManager.getExternalLayers(), textmodeSources: this._textmodeSourceManager.getSources() }), uniforms: this._uniformManager.getUniforms(), dynamicUpdaters: this._uniformManager.getDynamicUpdaters(), charMapping: e.charMapping, usesCharColorFeedback: l.usesCharColorFeedback, usesCharFeedback: l.usesCharFeedback, usesCellColorFeedback: l.usesCellColorFeedback, usesCharSource: this._usesCharSource, externalLayers: this._externalLayerManager.getExternalLayers(), textmodeSources: this._textmodeSourceManager.getSources() };
   }
   _reset() {
-    this._varCounter = 0, this._uniformManager.clear(), this._feedbackTracker.reset(), this._externalLayerManager.reset(), this._glslFunctions.clear(), this._mainCode.length = 0, this._currentTarget = "main", this._usesCharSource = !1;
+    this._varCounter = 0, this._uniformManager.clear(), this._feedbackTracker.reset(), this._externalLayerManager.reset(), this._textmodeSourceManager.reset(), this._glslFunctions.clear(), this._mainCode.length = 0, this._currentTarget = "main", this._usesCharSource = !1;
   }
   _compileCharSource(e) {
     this._usesCharSource = !0;
     const n = this._compileChain(e.charSource, "charSrc", "vec4(1.0, 1.0, 1.0, 1.0)", "v_uv", "char"), r = "charFromSource_" + this._varCounter++;
-    return this._mainCode.push("	// Convert charSource color to character index"), this._mainCode.push(`	float charLum_${r} = _luminance(${n.colorVar}.rgb);`), this._mainCode.push(`	int charIdx_${r} = int(charLum_${r} * u_charSourceCount);`), this._mainCode.push(`	vec4 ${r} = _packChar(charIdx_${r});`), r;
+    return this._mainCode.push("	// Convert charSource color to character index"), this._mainCode.push(`	float charLum_${r} = clamp(_luminance(${n.colorVar}.rgb), 0.0, 1.0);`), this._mainCode.push(`	float charCount_${r} = max(u_charSourceCount, 1.0);`), this._mainCode.push(`	int charIdx_${r} = int(min(charLum_${r} * charCount_${r}, charCount_${r} - 1.0));`), this._mainCode.push(`	vec4 ${r} = _packChar(charIdx_${r});`), r;
   }
   _compileChain(e, n, r, o = "v_uv", a = "main") {
     const u = this._currentTarget;
     this._currentTarget = a;
-    const s = `${n}_st`;
-    let c, i, l, p = `${n}_c`;
-    this._mainCode.push(`	vec2 ${s} = ${o};`), this._mainCode.push(`	vec4 ${p} = ${r};`);
-    const f = e.transforms, g = f.map((h) => this._getProcessedTransform(h.name)), v = this._identifyCoordTransforms(g), C = (h) => {
-      const d = f[h], b = g[h];
-      if (!b) return void console.warn(`[SynthCompiler] Unknown transform: ${d.name}`);
-      const x = e.externalLayerRefs.get(h);
-      d.name === "src" && this._trackSrcUsage(x);
-      const m = this._codeGenerator.getContextAwareGlslFunction(b, d.name, this._currentTarget, x, (A) => this._externalLayerManager.getPrefix(A));
-      this._glslFunctions.add(m);
-      const ne = this._processArguments(d.userArgs, b.inputs, `${n}_${h}_${d.name}`), B = e.nestedSources.get(h);
-      let j;
-      B && (b.type === "combine" || b.type === "combineCoord") && (j = this._compileChain(B, `${n}_nested_${h}`, r, s, a).colorVar);
-      const M = this._codeGenerator.generateTransformCode(this._mainCode, b, this._varCounter++, s, p, c, i, l, ne, this._currentTarget, j, x, (A) => this._externalLayerManager.getPrefix(A));
-      p = M.colorVar, M.charVar && (c = M.charVar), M.flagsVar && (i = M.flagsVar), M.rotationVar && (l = M.rotationVar);
+    const l = `${n}_st`;
+    let m, i, s, c = `${n}_c`;
+    this._mainCode.push(`	vec2 ${l} = ${o};`), this._mainCode.push(`	vec4 ${c} = ${r};`);
+    const f = e.transforms, p = f.map((d) => this._getProcessedTransform(d.name)), b = this._identifyCoordTransforms(p), w = (d) => {
+      const g = f[d], v = p[d];
+      if (!v) return void console.warn(`[SynthCompiler] Unknown transform: ${g.name}`);
+      const M = e.externalLayerRefs.get(d), x = e.textmodeSourceRefs.get(d);
+      g.name === "src" ? this._trackSrcUsage(M) : g.name === "srcTexture" && x && this._textmodeSourceManager.trackUsage(x, this._currentTarget);
+      const I = this._codeGenerator.getContextAwareGlslFunction(v, g.name, this._currentTarget, M, x, (F) => this._externalLayerManager.getPrefix(F), (F) => this._textmodeSourceManager.getUniformName(F));
+      this._glslFunctions.add(I);
+      const h = this._processArguments(g.userArgs, v.inputs, `${n}_${d}_${g.name}`), y = e.nestedSources.get(d);
+      let q;
+      y && (v.type === "combine" || v.type === "combineCoord") && (q = this._compileChain(y, `${n}_nested_${d}`, r, l, a).colorVar);
+      const T = this._codeGenerator.generateTransformCode(this._mainCode, v, this._varCounter++, l, c, m, i, s, h, this._currentTarget, q, M, x, (F) => this._externalLayerManager.getPrefix(F), (F) => this._textmodeSourceManager.getUniformName(F));
+      c = T.colorVar, T.charVar && (m = T.charVar), T.flagsVar && (i = T.flagsVar), T.rotationVar && (s = T.rotationVar);
     };
-    for (let h = v.length - 1; h >= 0; h--) C(v[h]);
-    for (let h = 0; h < f.length; h++) {
-      const d = g[h];
-      (!d || d.type !== "coord" && d.type !== "combineCoord") && C(h);
+    for (let d = b.length - 1; d >= 0; d--) w(b[d]);
+    for (let d = 0; d < f.length; d++) {
+      const g = p[d];
+      (!g || g.type !== "coord" && g.type !== "combineCoord") && w(d);
     }
-    return this._currentTarget = u, { coordVar: s, colorVar: p, charVar: c, flagsVar: i, rotationVar: l };
+    return this._currentTarget = u, { coordVar: l, colorVar: c, charVar: m, flagsVar: i, rotationVar: s };
   }
   _identifyCoordTransforms(e) {
     const n = [];
@@ -904,38 +1107,38 @@ class Mt {
     e ? this._externalLayerManager.trackUsage(e, this._currentTarget) : this._feedbackTracker.trackUsage(this._currentTarget);
   }
   _getProcessedTransform(e) {
-    return P.getProcessed(e);
+    return L.getProcessed(e);
   }
   _processArguments(e, n, r) {
     const o = [];
     for (let a = 0; a < n.length; a++) {
-      const u = n[a], s = e[a] ?? u.default, c = this._uniformManager.processArgument(s, u, r);
-      o.push(c.glslValue);
+      const u = n[a], l = e[a] ?? u.default, m = this._uniformManager.processArgument(l, u, r);
+      o.push(m.glslValue);
     }
     return o;
   }
 }
-class L {
+class O {
   static _fontIndexCache = /* @__PURE__ */ new WeakMap();
   _resolvedIndices;
   _lastFont;
   _lastChars = "";
   resolve(e, n) {
     if (this._resolvedIndices && this._lastFont === n && this._lastChars === e) return this._resolvedIndices;
-    let r = L._fontIndexCache.get(n);
+    let r = O._fontIndexCache.get(n);
     if (!r) {
       r = /* @__PURE__ */ new Map();
       const i = n.characters;
-      for (let l = 0; l < i.length; l++) r.set(i[l], l);
-      L._fontIndexCache.set(n, r);
+      for (let s = 0; s < i.length; s++) r.set(i[s], s);
+      O._fontIndexCache.set(n, r);
     }
-    const o = Array.from(e), a = new Int32Array(o.length), u = n.characterMap, s = u.get(" "), c = s && r.has(s) ? r.get(s) : 0;
+    const o = Array.from(e), a = new Int32Array(o.length), u = n.characterMap, l = u.get(" "), m = l && r.has(l) ? r.get(l) : 0;
     for (let i = 0; i < o.length; i++) {
-      const l = o[i], p = u.get(l);
-      if (p) {
-        const f = r.get(p);
-        a[i] = f !== void 0 ? f : c;
-      } else a[i] = c;
+      const s = o[i], c = u.get(s);
+      if (c) {
+        const f = r.get(c);
+        a[i] = f !== void 0 ? f : m;
+      } else a[i] = m;
     }
     return this._resolvedIndices = a, this._lastFont = n, this._lastChars = e, a;
   }
@@ -943,62 +1146,91 @@ class L {
     this._resolvedIndices = void 0, this._lastFont = void 0, this._lastChars = "";
   }
 }
-function ee(t = {}) {
-  return { source: t.source ?? new y(), compiled: t.compiled, shader: t.shader, characterResolver: t.characterResolver ?? new L(), needsCompile: t.needsCompile ?? !1, isCompiling: t.isCompiling ?? !1, pingPongBuffers: t.pingPongBuffers, pingPongDimensions: t.pingPongDimensions, pingPongIndex: t.pingPongIndex ?? 0, externalLayerMap: t.externalLayerMap, bpm: t.bpm, dynamicValues: t.dynamicValues ?? /* @__PURE__ */ new Map(), synthContext: t.synthContext ?? { time: 0, frameCount: 0, width: 0, height: 0, cols: 0, rows: 0, bpm: 0 }, isDisposed: !1 };
+function re(t = {}) {
+  return { source: t.source ?? new _(), sourceFactory: t.sourceFactory, compiled: t.compiled, shader: t.shader, characterResolver: t.characterResolver ?? new O(), needsCompile: t.needsCompile ?? !1, isCompiling: t.isCompiling ?? !1, pingPongBuffers: t.pingPongBuffers, pingPongDimensions: t.pingPongDimensions, pingPongIndex: t.pingPongIndex ?? 0, externalLayerMap: t.externalLayerMap, bpm: t.bpm, dynamicValues: t.dynamicValues ?? /* @__PURE__ */ new Map(), synthContext: t.synthContext ?? { time: 0, frameCount: 0, width: 0, height: 0, cols: 0, rows: 0, bpm: 0 }, isDisposed: !1 };
 }
-function $t(t) {
+function Ht(t) {
   t.extendLayer("synth", function(e) {
     const n = this.grid !== void 0 && this.drawFramebuffer !== void 0;
-    let r = this.getPluginState(_);
-    r ? (r.source = e, r.needsCompile = !0, r.characterResolver.invalidate(), n && (r.compiled = N(e))) : r = ee({ source: e, compiled: n ? N(e) : void 0, needsCompile: !0 }), this.setPluginState(_, r);
+    let r, o;
+    typeof e == "function" ? (o = e, r = new _()) : r = e;
+    let a = this.getPluginState(C);
+    a ? (a.source = r, a.sourceFactory = o, a.needsCompile = !0, a.characterResolver.invalidate(), n && !o && (a.compiled = N(r))) : a = re({ source: r, sourceFactory: o, compiled: n && !o ? N(r) : void 0, needsCompile: !0 }), this.setPluginState(C, a);
   });
 }
-function Tt(t) {
+function Kt(t) {
   t.extendLayer("clearSynth", function() {
-    const e = this.getPluginState(_);
-    e && (e.shader?.dispose && e.shader.dispose(), e.pingPongBuffers && (e.pingPongBuffers[0].dispose?.(), e.pingPongBuffers[1].dispose?.()), this.setPluginState(_, void 0));
+    const e = this.getPluginState(C);
+    e && (e.shader?.dispose && e.shader.dispose(), e.pingPongBuffers && (e.pingPongBuffers[0].dispose?.(), e.pingPongBuffers[1].dispose?.()), this.setPluginState(C, void 0));
   });
 }
-function Ft(t) {
+function Qt(t) {
   t.extendLayer("bpm", function(e) {
-    let n = this.getPluginState(_);
-    n ? n.bpm = e : n = ee({ bpm: e }), this.setPluginState(_, n);
+    let n = this.getPluginState(C);
+    n ? n.bpm = e : n = re({ bpm: e }), this.setPluginState(C, n);
   });
 }
-let te = 60;
-function Pt(t) {
-  te = t;
+let oe = 60;
+function Wt(t) {
+  oe = t;
 }
-function kt() {
-  return te;
+function Jt() {
+  return oe;
 }
-function It(t) {
+function Zt(t) {
   t.bpm = function(e) {
-    return Pt(e), e;
+    return Wt(e), e;
   };
 }
-function T(t) {
+function A(t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const [, n] of t.externalLayerRefs) {
+    const r = typeof n.layer == "function" ? n.layer() : n.layer;
+    r && e.set(n.layerId, r);
+  }
+  for (const [, n] of t.nestedSources) {
+    const r = A(n);
+    for (const [o, a] of r) e.set(o, a);
+  }
+  if (t.charSource) {
+    const n = A(t.charSource);
+    for (const [r, o] of n) e.set(r, o);
+  }
+  if (t.charColorSource) {
+    const n = A(t.charColorSource);
+    for (const [r, o] of n) e.set(r, o);
+  }
+  if (t.cellColorSource) {
+    const n = A(t.cellColorSource);
+    for (const [r, o] of n) e.set(r, o);
+  }
+  return e;
+}
+function P(t) {
   const e = /* @__PURE__ */ new Map();
-  for (const [, n] of t.externalLayerRefs) e.set(n.layerId, n.layer);
+  for (const [, n] of t.textmodeSourceRefs) {
+    const r = typeof n.source == "function" ? n.source() : n.source;
+    r && e.set(n.sourceId, r);
+  }
   for (const [, n] of t.nestedSources) {
-    const r = T(n);
+    const r = P(n);
     for (const [o, a] of r) e.set(o, a);
   }
   if (t.charSource) {
-    const n = T(t.charSource);
+    const n = P(t.charSource);
     for (const [r, o] of n) e.set(r, o);
   }
   if (t.charColorSource) {
-    const n = T(t.charColorSource);
+    const n = P(t.charColorSource);
     for (const [r, o] of n) e.set(r, o);
   }
   if (t.cellColorSource) {
-    const n = T(t.cellColorSource);
+    const n = P(t.cellColorSource);
     for (const [r, o] of n) e.set(r, o);
   }
   return e;
 }
-const Lt = `#version 300 es
+const en = `#version 300 es
 precision highp float;
 
 in vec2 v_uv;
@@ -1017,7 +1249,7 @@ void main() {
 	o_secondaryColor = texture(u_cellColorTex, v_uv);
 }
 `;
-class At {
+class tn {
   _shader = null;
   _isCompiling = !1;
   _isDisposed = !1;
@@ -1025,7 +1257,7 @@ class At {
     if (!(this._shader || this._isCompiling || this._isDisposed)) {
       this._isCompiling = !0;
       try {
-        this._shader = await e.createFilterShader(Lt);
+        this._shader = await e.createFilterShader(en);
       } catch (n) {
         console.warn("[textmode.synth.js] Failed to compile copy shader:", n);
       } finally {
@@ -1046,141 +1278,193 @@ class At {
     this._isDisposed = !1;
   }
 }
-const I = new At();
-async function Rt(t, e) {
-  const n = t.getPluginState(_);
+const D = new tn();
+async function nn(t, e) {
+  const n = t.getPluginState(C);
   if (!n) return;
   const r = t.grid, o = t.drawFramebuffer;
   if (!r || !o) return;
   let a = !1;
-  if (n.compiled || (n.compiled = N(n.source), n.externalLayerMap = T(n.source), a = !0, n.needsCompile = !0), n.needsCompile && n.compiled && !n.isCompiling) {
+  if (n.sourceFactory && n.needsCompile || !n.compiled) {
+    let c = n.source, f = !1;
+    if (n.sourceFactory) try {
+      const p = n.sourceFactory(), b = N(p);
+      n.compiled && b.fragmentSource === n.compiled.fragmentSource || (n.source = p, c = p, n.compiled = b, a = !1, f = !0);
+    } catch (p) {
+      console.warn("[textmode.synth.js] Failed to evaluate synth factory:", p);
+    }
+    (f || !n.compiled || n.needsCompile) && (n.compiled || (n.compiled = N(c)), n.externalLayerMap = A(c), n.textmodeSourceMap = P(c), a = !0, n.needsCompile = !0);
+  }
+  if (n.needsCompile && n.compiled && !n.isCompiling) {
     n.isCompiling = !0;
-    const p = n.compiled;
-    a || (n.externalLayerMap = T(n.source));
+    const c = n.compiled;
+    a || (n.externalLayerMap = A(n.source), n.textmodeSourceMap = P(n.source));
     try {
-      const f = await e.createFilterShader(p.fragmentSource);
+      const f = await e.createFilterShader(c.fragmentSource);
       if (n.isDisposed) return void (f.dispose && f.dispose());
-      n.shader?.dispose && n.shader.dispose(), n.shader = f, n.compiled === p && (n.needsCompile = !1);
+      n.shader?.dispose && n.shader.dispose(), n.shader = f, n.compiled === c && (n.needsCompile = !1);
     } finally {
       n.isCompiling = !1;
     }
   }
   if (!n.shader || !n.compiled || n.isDisposed) return;
-  const u = n.compiled.usesCharColorFeedback, s = n.compiled.usesCharFeedback, c = n.compiled.usesCellColorFeedback, i = u || s || c;
+  const u = n.compiled.usesCharColorFeedback, l = n.compiled.usesCharFeedback, m = n.compiled.usesCellColorFeedback, i = u || l || m;
   if (n.pingPongBuffers) {
-    const p = n.pingPongDimensions, f = !p || p.cols !== r.cols || p.rows !== r.rows;
+    const c = n.pingPongDimensions, f = !c || c.cols !== r.cols || c.rows !== r.rows;
     i && !f || (n.pingPongBuffers[0].dispose(), n.pingPongBuffers[1].dispose(), n.pingPongBuffers = void 0, n.pingPongDimensions = void 0);
   }
   i && !n.pingPongBuffers && (n.pingPongBuffers = [e.createFramebuffer({ width: r.cols, height: r.rows, attachments: 3 }), e.createFramebuffer({ width: r.cols, height: r.rows, attachments: 3 })], n.pingPongDimensions = { cols: r.cols, rows: r.rows }, n.pingPongIndex = 0), n.synthContext || (n.synthContext = { time: 0, frameCount: 0, width: 0, height: 0, cols: 0, rows: 0, bpm: 0 });
-  const l = n.synthContext;
-  l.time = e.secs, l.frameCount = e.frameCount, l.width = r.width, l.height = r.height, l.cols = r.cols, l.rows = r.rows, l.bpm = n.bpm ?? kt(), l.onError = n.onDynamicError, n.dynamicValues.clear();
-  for (const [p, f] of n.compiled.dynamicUpdaters) {
-    const g = f(l);
-    n.dynamicValues.set(p, g);
+  const s = n.synthContext;
+  s.time = e.secs, s.frameCount = e.frameCount, s.width = r.width, s.height = r.height, s.cols = r.cols, s.rows = r.rows, s.bpm = n.bpm ?? Jt(), s.onError = n.onDynamicError, n.dynamicValues.clear();
+  for (const [c, f] of n.compiled.dynamicUpdaters) {
+    const p = f(s);
+    n.dynamicValues.set(c, p);
   }
   if (i && n.pingPongBuffers) {
-    const p = n.pingPongBuffers[n.pingPongIndex], f = n.pingPongBuffers[1 - n.pingPongIndex];
-    f.begin(), e.clear(), e.shader(n.shader), U(t, e, n, l, p), e.rect(r.cols, r.rows), f.end(), o.begin(), e.clear();
-    const g = I.getShader();
-    g ? (e.shader(g), e.setUniform("u_charTex", f.textures[0]), e.setUniform("u_charColorTex", f.textures[1]), e.setUniform("u_cellColorTex", f.textures[2])) : (e.shader(n.shader), U(t, e, n, l, p)), e.rect(r.cols, r.rows), o.end(), n.pingPongIndex = 1 - n.pingPongIndex;
-  } else o.begin(), e.clear(), e.shader(n.shader), U(t, e, n, l, null), e.rect(r.cols, r.rows), o.end();
-}
-function U(t, e, n, r, o) {
-  e.setUniform("time", r.time), e.setUniform("resolution", [r.cols, r.rows]);
-  for (const [c, i] of n.dynamicValues) e.setUniform(c, i);
+    const c = n.pingPongBuffers[n.pingPongIndex], f = n.pingPongBuffers[1 - n.pingPongIndex];
+    f.begin(), e.clear(), e.shader(n.shader), Y(t, e, n, s, c), e.rect(r.cols, r.rows), f.end(), o.begin(), e.clear();
+    const p = D.getShader();
+    p ? (e.shader(p), e.setUniform("u_charTex", f.textures[0]), e.setUniform("u_charColorTex", f.textures[1]), e.setUniform("u_cellColorTex", f.textures[2])) : (e.shader(n.shader), Y(t, e, n, s, c)), e.rect(r.cols, r.rows), o.end(), n.pingPongIndex = 1 - n.pingPongIndex;
+  } else o.begin(), e.clear(), e.shader(n.shader), Y(t, e, n, s, null), e.rect(r.cols, r.rows), o.end();
+  e.resetShader();
+}
+function Y(t, e, n, r, o) {
+  e.setUniform("time", r.time), e.setUniform("u_resolution", [r.cols, r.rows]);
+  for (const [i, s] of n.dynamicValues) e.setUniform(i, s);
   const a = n.compiled, u = n.staticUniformsAppliedTo !== n.shader;
   if (u) {
-    for (const [c, i] of a.uniforms) i.isDynamic || typeof i.value == "function" || e.setUniform(c, i.value);
+    for (const [i, s] of a.uniforms) s.isDynamic || typeof s.value == "function" || e.setUniform(i, s.value);
     n.staticUniformsAppliedTo = n.shader;
   }
   if (a.charMapping) {
-    const c = n.characterResolver.resolve(a.charMapping.chars, t.font);
-    (u || c !== n.lastCharMapIndices) && (e.setUniform("u_charMap", c), e.setUniform("u_charMapSize", c.length), n.lastCharMapIndices = c);
+    const i = n.characterResolver.resolve(a.charMapping.chars, t.font);
+    (u || i !== n.lastCharMapIndices) && (e.setUniform("u_charMap", i), e.setUniform("u_charMapSize", i.length), n.lastCharMapIndices = i);
   }
   if (a.usesCharSource) {
-    const c = a.charMapping ? a.charMapping.chars.length : t.font.characters.length;
-    e.setUniform("u_charSourceCount", c);
-  }
-  o && (a.usesCharColorFeedback && e.setUniform(S.charColor, o.textures[1]), a.usesCharFeedback && e.setUniform(S.char, o.textures[0]), a.usesCellColorFeedback && e.setUniform(S.cellColor, o.textures[2]));
-  const s = a.externalLayers;
-  if (s && s.size > 0 && n.externalLayerMap) for (const [c, i] of s) {
-    const l = n.externalLayerMap.get(c);
-    if (!l) {
-      console.warn(`[textmode.synth.js] External layer not found: ${c}`);
+    const i = a.charMapping ? a.charMapping.chars.length : t.font.characters.length;
+    e.setUniform("u_charSourceCount", i);
+  }
+  o && (a.usesCharColorFeedback && e.setUniform($.charColor, o.textures[1]), a.usesCharFeedback && e.setUniform($.char, o.textures[0]), a.usesCellColorFeedback && e.setUniform($.cellColor, o.textures[2]));
+  const l = a.externalLayers;
+  if (l && l.size > 0 && n.externalLayerMap) for (const [i, s] of l) {
+    const c = n.externalLayerMap.get(i);
+    if (!c) {
+      console.warn(`[textmode.synth.js] External layer not found: ${i}`);
+      continue;
+    }
+    const f = c.getPluginState(C);
+    let p;
+    f?.pingPongBuffers ? p = f.pingPongBuffers[f.pingPongIndex].textures : c.drawFramebuffer && (p = c.drawFramebuffer.textures), p && (s.usesChar && e.setUniform(`${s.uniformPrefix}${R.char}`, p[0]), s.usesCharColor && e.setUniform(`${s.uniformPrefix}${R.charColor}`, p[1]), s.usesCellColor && e.setUniform(`${s.uniformPrefix}${R.cellColor}`, p[2]));
+  }
+  const m = a.textmodeSources;
+  if (m && m.size > 0 && n.textmodeSourceMap) for (const [i, s] of m) {
+    const c = n.textmodeSourceMap.get(i);
+    if (!c) {
+      console.warn(`[textmode.synth.js] TextmodeSource not found: ${i}`);
       continue;
     }
-    const p = l.getPluginState(_);
-    let f;
-    p?.pingPongBuffers ? f = p.pingPongBuffers[p.pingPongIndex].textures : l.drawFramebuffer && (f = l.drawFramebuffer.textures), f && (i.usesChar && e.setUniform(`${i.uniformPrefix}${$.char}`, f[0]), i.usesCharColor && e.setUniform(`${i.uniformPrefix}${$.charColor}`, f[1]), i.usesCellColor && e.setUniform(`${i.uniformPrefix}${$.cellColor}`, f[2]));
+    c.update && c.update();
+    const f = c.width ?? 1, p = c.height ?? 1, b = f > 0 ? f : 1, w = p > 0 ? p : 1;
+    e.setUniform(`${s.uniformName}_dim`, [b, w]), c.texture ? e.setUniform(s.uniformName, c.texture) : console.warn(`[textmode.synth.js] TextmodeSource texture not loaded: ${i}`);
   }
 }
-function Ut(t) {
-  const e = t.getPluginState(_);
+function rn(t) {
+  const e = t.getPluginState(C);
   e && (e.isDisposed = !0, e.shader?.dispose && e.shader.dispose(), e.pingPongBuffers && (e.pingPongBuffers[0].dispose?.(), e.pingPongBuffers[1].dispose?.()));
 }
-const Ot = { name: _, version: "1.0.0", install(t, e) {
-  I.reset(), It(t), $t(e), Ft(e), Tt(e), e.registerPreSetupHook(async () => {
-    await I.initialize(t);
-  }), e.registerLayerPreRenderHook((n) => Rt(n, t)), e.registerLayerDisposedHook(Ut);
+const ln = { name: C, version: "1.0.0", install(t, e) {
+  D.reset(), Zt(t), Ht(e), Qt(e), Kt(e), e.registerPreSetupHook(async () => {
+    await D.initialize(t);
+  }), e.registerLayerPreRenderHook((n) => nn(n, t)), e.registerLayerDisposedHook(rn);
 }, uninstall(t, e) {
   const n = [e.layerManager.base, ...e.layerManager.all];
   for (const r of n) {
-    const o = r.getPluginState(_);
-    o && (o.isDisposed = !0, o.shader?.dispose && o.shader.dispose(), o.pingPongBuffers && (o.pingPongBuffers[0].dispose?.(), o.pingPongBuffers[1].dispose?.()), r.setPluginState(_, void 0));
+    const o = r.getPluginState(C);
+    o && (o.isDisposed = !0, o.shader?.dispose && o.shader.dispose(), o.pingPongBuffers && (o.pingPongBuffers[0].dispose?.(), o.pingPongBuffers[1].dispose?.()), r.setPluginState(C, void 0));
   }
-  delete t.bpm, e.removeLayerExtension("synth"), e.removeLayerExtension("bpm"), e.removeLayerExtension("clearSynth"), I.dispose();
+  delete t.bpm, e.removeLayerExtension("synth"), e.removeLayerExtension("bpm"), e.removeLayerExtension("clearSynth"), D.dispose();
 } };
-function Nt(t, e, n, r) {
-  return new y({ cellColorSource: E(t, e, n, r) });
+function un(t, e, n, r) {
+  return new _({ cellColorSource: j(t, e, n, r) });
 }
-const Vt = (t) => new y({ charSource: t });
-function Et(t, e, n, r) {
-  return new y({ charColorSource: E(t, e, n, r) });
+const fn = (t) => new _({ charSource: t });
+function mn(t, e, n, r) {
+  return new _({ charColorSource: j(t, e, n, r) });
 }
-function Bt(t) {
-  return w.gradient(t ?? null);
+function pn(t) {
+  return S.gradient(t ?? null);
+}
+function dn(t, e) {
+  return S.noise(t ?? null, e ?? null);
 }
-function jt(t, e) {
-  return w.noise(t ?? null, e ?? null);
+function hn(t, e, n, r) {
+  return S.plasma(t ?? null, e ?? null, n ?? null, r ?? null);
 }
-function Yt(t, e, n) {
-  return w.osc(t ?? null, e ?? null, n ?? null);
+function gn(t, e, n, r, o, a) {
+  return S.moire(t ?? null, e ?? null, n ?? null, r ?? null, o ?? null, a ?? null);
 }
-function Xt(t, e, n, r) {
-  const o = E(t, e, n, r);
-  return new y({ charColorSource: o, cellColorSource: o });
+function yn(t, e, n) {
+  return S.osc(t ?? null, e ?? null, n ?? null);
 }
-function Gt(t, e, n) {
-  return w.shape(t ?? null, e ?? null, n ?? null);
+function _n(t, e, n, r) {
+  const o = j(t, e, n, r);
+  return new _({ charColorSource: o, cellColorSource: o });
 }
-function zt(t, e, n, r) {
-  return t !== void 0 && e === void 0 && n === void 0 && r === void 0 && typeof t == "number" ? w.solid(t) : w.solid(t ?? null, e ?? null, n ?? null, r ?? null);
+function vn(t, e, n) {
+  return S.shape(t ?? null, e ?? null, n ?? null);
 }
-const qt = (t) => {
-  const e = w.src;
+function on(t, e, n, r) {
+  return t !== void 0 && e === void 0 && n === void 0 && r === void 0 && typeof t == "number" ? S.solid(t) : S.solid(t ?? null, e ?? null, n ?? null, r ?? null);
+}
+const xn = (t) => {
+  const e = S.src;
   if (!t) return e();
-  const n = new y(), r = t.id ?? `layer_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-  return n.addExternalLayerRef({ layerId: r, layer: t }), n;
+  const n = new _();
+  if (typeof t == "function") {
+    const r = t();
+    if (r && sn(r)) {
+      const o = r.id ?? `layer_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+      n.addExternalLayerRef({ layerId: o, layer: t });
+    } else {
+      const o = `tms_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+      n.addTextmodeSourceRef({ sourceId: o, source: t });
+    }
+  } else if (an(t)) {
+    const r = `tms_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+    n.addTextmodeSourceRef({ sourceId: r, source: t });
+  } else {
+    const r = t, o = r.id ?? `layer_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+    n.addExternalLayerRef({ layerId: o, layer: r });
+  }
+  return n;
 };
-function Ht(t, e, n) {
-  return w.voronoi(t ?? null, e ?? null, n ?? null);
+function an(t) {
+  return t !== null && typeof t == "object" && "texture" in t && "originalWidth" in t && "originalHeight" in t;
+}
+function sn(t) {
+  return t !== null && typeof t == "object" && "grid" in t && "drawFramebuffer" in t;
+}
+function Cn(t, e, n) {
+  return S.voronoi(t ?? null, e ?? null, n ?? null);
 }
-function E(t, e, n, r) {
-  return t instanceof y ? t : zt(t, e, n, r);
+function j(t, e, n, r) {
+  return t instanceof _ ? t : on(t, e, n, r);
 }
 export {
-  Ot as SynthPlugin,
-  y as SynthSource,
-  Nt as cellColor,
-  Vt as char,
-  Et as charColor,
-  Bt as gradient,
-  jt as noise,
-  Yt as osc,
-  Xt as paint,
-  Dt as setGlobalErrorCallback,
-  Gt as shape,
-  zt as solid,
-  qt as src,
-  Ht as voronoi
+  ln as SynthPlugin,
+  _ as SynthSource,
+  un as cellColor,
+  fn as char,
+  mn as charColor,
+  pn as gradient,
+  gn as moire,
+  dn as noise,
+  yn as osc,
+  _n as paint,
+  hn as plasma,
+  cn as setGlobalErrorCallback,
+  vn as shape,
+  on as solid,
+  xn as src,
+  Cn as voronoi
 };