@rosalana/sandbox 0.0.5 → 0.2.0

package/dist/index.es.js

@@ -1,9 +1,9 @@
-var S = Object.defineProperty;
-var L = (o, t, e) => t in o ? S(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
-var r = (o, t, e) => L(o, typeof t != "symbol" ? t + "" : t, e);
-class l {
-  constructor(t, e, i, s) {
-    this.target = t, this.type = e, this.listener = i, this.options = s, this.target.addEventListener(
+var N = Object.defineProperty;
+var G = (u, e, t) => e in u ? N(u, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : u[e] = t;
+var o = (u, e, t) => G(u, typeof e != "symbol" ? e + "" : e, t);
+class b {
+  constructor(e, t, n, i) {
+    this.target = e, this.type = t, this.listener = n, this.options = i, this.target.addEventListener(
       this.type,
       this.listener,
       this.options
@@ -16,99 +16,231 @@ class l {
       this.options
     );
   }
-  static on(t, e, i, s) {
-    return t.addEventListener(e, i, s), () => t.removeEventListener(e, i, s);
+  static on(e, t, n, i) {
+    return e.addEventListener(t, n, i), () => e.removeEventListener(t, n, i);
   }
 }
-class u extends Error {
-  constructor(t, e) {
-    super(t), this.code = e, this.name = "SandboxError";
+class h extends Error {
+  constructor(t, n) {
+    super(t);
+    o(this, "name", "SandboxError");
+    this.code = n;
   }
 }
-class w extends u {
-  constructor(t) {
-    const e = t === "not_supported" ? "WebGL is not supported in this browser." : "Failed to create WebGL context. The GPU may be unavailable.";
+class W extends h {
+  constructor() {
+    super("WebGL is not supported in this browser.", "CONTEXT_ERROR");
+  }
+}
+class ve extends h {
+  constructor() {
     super(
-      e,
-      t === "not_supported" ? "WEBGL_NOT_SUPPORTED" : "CONTEXT_CREATION_FAILED"
-    ), this.name = "SandboxContextError";
+      "Failed to create WebGL context. The GPU may be unavailable.",
+      "CONTEXT_ERROR"
+    );
   }
 }
-class k extends u {
-  constructor(t, e) {
+class z extends h {
+  constructor(e, t) {
     super(
-      `Vertex and fragment shader WebGL versions do not match (${t} vs ${e})`,
-      "SHADER_VERSION_MISMATCH"
-    ), this.vertexVersion = t, this.fragmentVersion = e, this.name = "SandboxShaderVersionMismatchError";
+      `Vertex and fragment shader WebGL versions do not match (${e} vs ${t})`,
+      "VALIDATION_ERROR"
+    ), this.vertexVersion = e, this.fragmentVersion = t;
   }
 }
-class c extends u {
-  constructor(e, i, s) {
-    const n = c.parseErrorLines(s), h = n.length > 0 ? ` at line(s): ${n.join(", ")}` : "";
+class _ extends h {
+  constructor(t, n, i) {
+    const r = _.parseErrorLines(i), s = r.length > 0 ? ` at line(s): ${r.join(", ")}` : "";
     super(
-      `${e} shader compilation failed${h}
+      `${t} shader compilation failed${s}
 
-${s}`,
-      "SHADER_COMPILATION_FAILED"
+${i}`,
+      "SHADER_ERROR"
     );
-    /** Line numbers where errors occurred */
-    r(this, "lines");
-    this.shaderType = e, this.source = i, this.infoLog = s, this.name = "SandboxShaderCompilationError", this.lines = n;
+    o(this, "lines");
+    this.shaderType = t, this.source = n, this.infoLog = i, this.lines = r;
   }
-  /** Parse error log to extract line numbers */
-  static parseErrorLines(e) {
-    const i = [
+  static parseErrorLines(t) {
+    const n = [
       /ERROR:\s*\d*:(\d+)/g,
-      // Chrome/ANGLE: ERROR: 0:15
       /(\d+):(\d+)\(\d+\):/g,
-      // Mesa: 0:15(0):
       /^(\d+):/gm
-      // Simple: 15:
-    ], s = /* @__PURE__ */ new Set();
-    for (const n of i) {
-      let h;
-      for (; (h = n.exec(e)) !== null; ) {
-        const f = parseInt(h[1], 10);
-        f > 0 && s.add(f);
+    ], i = /* @__PURE__ */ new Set();
+    for (const r of n) {
+      let s;
+      for (; (s = r.exec(t)) !== null; ) {
+        const a = parseInt(s[1], 10);
+        a > 0 && i.add(a);
       }
     }
-    return [...s].sort((n, h) => n - h);
+    return [...i].sort((r, s) => r - s);
   }
 }
-class m extends u {
-  constructor(t) {
+class U extends h {
+  constructor(e, t, n, i) {
+    super(
+      `The shader ${e} "${t}" has type "${i}" but expected "${n}"`,
+      "SHADER_ERROR"
+    ), this.requirement = e, this.name = t, this.expectedType = n, this.actualType = i;
+  }
+}
+class H extends h {
+  constructor() {
+    super("Shader source does not contain any function.", "SHADER_ERROR");
+  }
+}
+class q extends h {
+  constructor(e, t) {
+    super(
+      `Syntax error in shader import statement at line ${e}: ${t}`,
+      "SHADER_ERROR"
+    ), this.line = e, this.details = t;
+  }
+}
+class j extends h {
+  constructor(e, t) {
+    super(
+      `Duplicate import name "${e}" found at line ${t}. Each import must have a unique name.`,
+      "SHADER_ERROR"
+    ), this.name = e, this.line = t;
+  }
+}
+class X extends h {
+  constructor(e) {
+    super(
+      `Can not find module '${e}'. Check if it is defined before usage or if the name is correct.`,
+      "MODULE_ERROR"
+    ), this.moduleName = e;
+  }
+}
+class Y extends h {
+  constructor(e, t) {
+    super(
+      `Method '${t}' not found in shader module '${e}'. Check if the method is defined in the module source code or if the name is correct.`,
+      "MODULE_ERROR"
+    ), this.moduleName = e, this.methodName = t;
+  }
+}
+class K extends h {
+  constructor(e) {
+    super(
+      `Importing 'main' function from module '${e}' is forbidden.`,
+      "MODULE_ERROR"
+    ), this.moduleName = e;
+  }
+}
+class Q extends h {
+  constructor(e) {
+    super(
+      `Name 'default' is reserved and cannot be used as a function name in module '${e}'.`,
+      "MODULE_ERROR"
+    ), this.moduleName = e;
+  }
+}
+class J extends h {
+  constructor(e) {
+    super(
+      `Module name '${e}' is not allowed. Module names cannot be 'sandbox' or start with 'sandbox/'.`,
+      "MODULE_ERROR"
+    ), this.moduleName = e;
+  }
+}
+class Z extends h {
+  constructor(e) {
+    super(
+      `Module '${e}' is already defined. Overwriting existing modules is not allowed.`,
+      "MODULE_ERROR"
+    ), this.moduleName = e;
+  }
+}
+class ee extends h {
+  constructor(e, t, n) {
+    super(
+      `Uniform '${n}' mentioned for function '${t}' of module '${e}' was not found among the module's declared uniforms. Check if the uniform is declared in the module source code or if the name is correct.`,
+      "MODULE_ERROR"
+    ), this.moduleName = e, this.functionName = t, this.uniformName = n;
+  }
+}
+class te extends h {
+  constructor(e, t) {
+    super(
+      `Uniform '${t}' mentioned for function '${e}' was not imported from any module. Check if the function is imported from the correct module and if the uniform is declared in that module's source code with the correct name.`,
+      "MODULE_ERROR"
+    ), this.functionName = e, this.uniformName = t;
+  }
+}
+class ne extends h {
+  constructor(e, t) {
+    super(
+      `Mention '${e}' called in function '${t}' could not be replaced with the corresponding uniform reference. There might be an issue with the compilation process because the referenced uniform was not found among the shader requirements. Try use a different name for uniforms you want to mention in functions or check if the uniform is properly declared and mentioned in the module source code.`,
+      "MODULE_ERROR"
+    ), this.mentionName = e, this.calledInFunction = t;
+  }
+}
+class S extends h {
+  constructor(e) {
     super(`Shader program linking failed
 
-${t}`, "PROGRAM_LINK_FAILED"), this.infoLog = t, this.name = "SandboxProgramError";
+${e}`, "PROGRAM_ERROR"), this.infoLog = e;
+  }
+}
+class ge extends h {
+  constructor(t) {
+    super(
+      `Failed to create WebGL texture for "${t}".`,
+      "TEXTURE_ERROR"
+    );
+    o(this, "name", "SandboxTextureCreationError");
+    this.textureName = t;
+  }
+}
+class xe extends h {
+  constructor(t, n) {
+    super(
+      `Cannot bind texture "${t}": all ${n} texture units are in use.`,
+      "TEXTURE_ERROR"
+    );
+    o(this, "name", "SandboxTextureUnitLimitError");
+    this.textureName = t, this.maxUnits = n;
   }
 }
-class R {
+class ie extends h {
+  constructor(e) {
+    super(`Error in onLoad callback: ${e}`, "UNKNOWN_ERROR");
+  }
+}
+class re extends h {
+  constructor(e, t) {
+    super(`Error in onBefore/onAfter hook callback with ID ${e}: ${t}`, "UNKNOWN_ERROR");
+  }
+}
+class se {
   constructor() {
     /** Total elapsed time in seconds */
-    r(this, "time", 0);
+    o(this, "time", 0);
     /** Delta time since last frame in seconds */
-    r(this, "delta", 0);
+    o(this, "delta", 0);
     /** Frame counter */
-    r(this, "frame", 0);
+    o(this, "frame", 0);
     /** Is clock running */
-    r(this, "running", !1);
+    o(this, "running", !1);
     /** Smoothed frames per second */
-    r(this, "fps", 0);
-    r(this, "startTime", 0);
-    r(this, "lastTime", 0);
-    r(this, "rafId", null);
-    r(this, "callback", null);
-    r(this, "maxFps", 0);
+    o(this, "fps", 0);
+    o(this, "startTime", 0);
+    o(this, "lastTime", 0);
+    o(this, "rafId", null);
+    o(this, "callback", null);
+    o(this, "maxFps", 0);
     this.loop = this.loop.bind(this);
   }
   /**
    * Start the animation loop with a render callback.
    */
-  start(t) {
+  start(e) {
     if (this.running) return this;
-    this.callback = t, this.running = !0;
-    const e = performance.now();
-    return this.frame === 0 ? this.startTime = e : this.startTime = e - this.time * 1e3, this.lastTime = e, this.rafId = requestAnimationFrame(this.loop), this;
+    this.callback = e, this.running = !0;
+    const t = performance.now();
+    return this.frame === 0 ? this.startTime = t : this.startTime = t - this.time * 1e3, this.lastTime = t, this.rafId = requestAnimationFrame(this.loop), this;
   }
   /**
    * Stop the animation loop.
@@ -139,14 +271,14 @@ class R {
    * Advance clock by one tick (for single-shot rendering).
    * Useful when autoplay is disabled.
    */
-  tick(t = 0) {
-    return this.delta = t, this.time += t, this.frame++, this.callback && this.callback(this.getState()), this;
+  tick(e = 0) {
+    return this.delta = e, this.time += e, this.frame++, this.callback && this.callback(this.getState()), this;
   }
   /**
    * Set time directly (for deterministic rendering).
    */
-  setTime(t) {
-    return this.time = t, this;
+  setTime(e) {
+    return this.time = e, this;
   }
   /**
    * Cleanup.
@@ -157,46 +289,46 @@ class R {
   /**
    * Set maximum frames per second.
    */
-  setMaxFps(t) {
-    return this.maxFps = t, this;
+  setMaxFps(e) {
+    return this.maxFps = e, this;
   }
   /**
    * Internal animation frame handler.
    */
-  loop(t) {
+  loop(e) {
     if (!this.running) return;
     if (this.maxFps > 0) {
-      const i = 1e3 / this.maxFps;
-      if (t - this.lastTime < i) {
+      const n = 1e3 / this.maxFps;
+      if (e - this.lastTime < n) {
         this.rafId = requestAnimationFrame(this.loop);
         return;
       }
     }
-    this.delta = (t - this.lastTime) / 1e3, this.lastTime = t;
-    const e = this.delta > 0 ? 1 / this.delta : 0;
-    this.fps = this.fps * 0.95 + e * 0.05, this.time = (t - this.startTime) / 1e3, this.frame++, this.callback && this.callback(this.getState()), this.rafId = requestAnimationFrame(this.loop);
+    this.delta = (e - this.lastTime) / 1e3, this.lastTime = e;
+    const t = this.delta > 0 ? 1 / this.delta : 0;
+    this.fps = this.fps * 0.95 + t * 0.05, this.time = (e - this.startTime) / 1e3, this.frame++, this.callback && this.callback(this.getState()), this.rafId = requestAnimationFrame(this.loop);
   }
 }
-class p {
-  constructor(t) {
-    r(this, "gl");
-    r(this, "vao", null);
-    r(this, "vbo", null);
-    r(this, "ibo", null);
-    r(this, "vertexCount", 0);
-    r(this, "indexCount", 0);
-    r(this, "useIndices", !1);
+class k {
+  constructor(e) {
+    o(this, "gl");
+    o(this, "vao", null);
+    o(this, "vbo", null);
+    o(this, "ibo", null);
+    o(this, "vertexCount", 0);
+    o(this, "indexCount", 0);
+    o(this, "useIndices", !1);
     // WebGL1 VAO extension (if available)
-    r(this, "vaoExt", null);
-    r(this, "isWebGL2");
-    this.gl = t, this.isWebGL2 = t instanceof WebGL2RenderingContext, this.isWebGL2 || (this.vaoExt = t.getExtension("OES_vertex_array_object"));
+    o(this, "vaoExt", null);
+    o(this, "isWebGL2");
+    this.gl = e, this.isWebGL2 = e instanceof WebGL2RenderingContext, this.isWebGL2 || (this.vaoExt = e.getExtension("OES_vertex_array_object"));
   }
   /**
    * Create a fullscreen quad geometry.
    * This is the most common use case for shader effects.
    */
-  static fullscreenQuad(t) {
-    const e = new p(t), i = new Float32Array([
+  static fullscreenQuad(e) {
+    const t = new k(e), n = new Float32Array([
       // position    texcoord
       -1,
       -1,
@@ -218,7 +350,7 @@ class p {
       1,
       1
       // top-right
-    ]), s = new Uint16Array([
+    ]), i = new Uint16Array([
       0,
       1,
       2,
@@ -228,33 +360,33 @@ class p {
       3
       // second triangle
     ]);
-    return e.setup(i, s), e;
+    return t.setup(n, i), t;
   }
   /**
    * Setup geometry from vertex and index data.
    */
-  setup(t, e) {
-    const i = this.gl;
-    return this.createVAO(), this.bindVAO(), this.vbo = i.createBuffer(), i.bindBuffer(i.ARRAY_BUFFER, this.vbo), i.bufferData(i.ARRAY_BUFFER, t, i.STATIC_DRAW), this.vertexCount = t.length / 4, e && (this.ibo = i.createBuffer(), i.bindBuffer(i.ELEMENT_ARRAY_BUFFER, this.ibo), i.bufferData(i.ELEMENT_ARRAY_BUFFER, e, i.STATIC_DRAW), this.indexCount = e.length, this.useIndices = !0), this.unbindVAO(), this;
+  setup(e, t) {
+    const n = this.gl;
+    return this.createVAO(), this.bindVAO(), this.vbo = n.createBuffer(), n.bindBuffer(n.ARRAY_BUFFER, this.vbo), n.bufferData(n.ARRAY_BUFFER, e, n.STATIC_DRAW), this.vertexCount = e.length / 4, t && (this.ibo = n.createBuffer(), n.bindBuffer(n.ELEMENT_ARRAY_BUFFER, this.ibo), n.bufferData(n.ELEMENT_ARRAY_BUFFER, t, n.STATIC_DRAW), this.indexCount = t.length, this.useIndices = !0), this.unbindVAO(), this;
   }
   /**
    * Link vertex attributes to shader program.
    * Call this after compiling shaders.
    */
-  linkAttributes(t) {
-    const e = this.gl;
-    this.bindVAO(), e.bindBuffer(e.ARRAY_BUFFER, this.vbo);
-    const i = 4 * Float32Array.BYTES_PER_ELEMENT, s = this.getPositionLocation(t);
-    s >= 0 && (e.enableVertexAttribArray(s), e.vertexAttribPointer(s, 2, e.FLOAT, !1, i, 0));
-    const n = this.getTexcoordLocation(t);
-    return n >= 0 && (e.enableVertexAttribArray(n), e.vertexAttribPointer(
-      n,
+  linkAttributes(e) {
+    const t = this.gl;
+    this.bindVAO(), t.bindBuffer(t.ARRAY_BUFFER, this.vbo);
+    const n = 4 * Float32Array.BYTES_PER_ELEMENT, i = this.getPositionLocation(e);
+    i >= 0 && (t.enableVertexAttribArray(i), t.vertexAttribPointer(i, 2, t.FLOAT, !1, n, 0));
+    const r = this.getTexcoordLocation(e);
+    return r >= 0 && (t.enableVertexAttribArray(r), t.vertexAttribPointer(
+      r,
       2,
-      e.FLOAT,
+      t.FLOAT,
       !1,
-      i,
+      n,
       2 * Float32Array.BYTES_PER_ELEMENT
-    )), this.useIndices && e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, this.ibo), this.unbindVAO(), this;
+    )), this.useIndices && t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, this.ibo), this.unbindVAO(), this;
   }
   /**
    * Bind geometry for rendering.
@@ -272,31 +404,31 @@ class p {
    * Draw the geometry.
    */
   draw() {
-    const t = this.gl;
-    return this.bindVAO(), this.useIndices ? t.drawElements(t.TRIANGLES, this.indexCount, t.UNSIGNED_SHORT, 0) : t.drawArrays(t.TRIANGLE_STRIP, 0, this.vertexCount), this;
+    const e = this.gl;
+    return this.bindVAO(), this.useIndices ? e.drawElements(e.TRIANGLES, this.indexCount, e.UNSIGNED_SHORT, 0) : e.drawArrays(e.TRIANGLE_STRIP, 0, this.vertexCount), this;
   }
   /**
    * Cleanup all GPU resources.
    */
   destroy() {
-    const t = this.gl;
-    this.deleteVAO(), this.vbo && (t.deleteBuffer(this.vbo), this.vbo = null), this.ibo && (t.deleteBuffer(this.ibo), this.ibo = null);
+    const e = this.gl;
+    this.deleteVAO(), this.vbo && (e.deleteBuffer(this.vbo), this.vbo = null), this.ibo && (e.deleteBuffer(this.ibo), this.ibo = null);
   }
   /**
    * Get position attribute location.
    * Tries common naming conventions.
    */
-  getPositionLocation(t) {
-    let e = t.getAttribLocation("a_position");
-    return e >= 0 || (e = t.getAttribLocation("aPosition"), e >= 0) || (e = t.getAttribLocation("position"), e >= 0) ? e : -1;
+  getPositionLocation(e) {
+    let t = e.getAttribLocation("a_position");
+    return t >= 0 || (t = e.getAttribLocation("aPosition"), t >= 0) || (t = e.getAttribLocation("position"), t >= 0) ? t : -1;
   }
   /**
    * Get texcoord attribute location.
    * Tries common naming conventions.
    */
-  getTexcoordLocation(t) {
-    let e = t.getAttribLocation("a_texcoord");
-    return e >= 0 || (e = t.getAttribLocation("aTexCoord"), e >= 0) || (e = t.getAttribLocation("texcoord"), e >= 0) || (e = t.getAttribLocation("a_uv"), e >= 0) ? e : -1;
+  getTexcoordLocation(e) {
+    let t = e.getAttribLocation("a_texcoord");
+    return t >= 0 || (t = e.getAttribLocation("aTexCoord"), t >= 0) || (t = e.getAttribLocation("texcoord"), t >= 0) || (t = e.getAttribLocation("a_uv"), t >= 0) ? t : -1;
   }
   // ============================================================================
   // VAO helpers (handle WebGL1 vs WebGL2 differences)
@@ -314,33 +446,21 @@ class p {
     this.vao && (this.isWebGL2 ? this.gl.deleteVertexArray(this.vao) : this.vaoExt && this.vaoExt.deleteVertexArrayOES(this.vao), this.vao = null);
   }
 }
-class a {
-  constructor(t) {
-    r(this, "gl");
-    r(this, "program", null);
-    r(this, "vertexShader", null);
-    r(this, "fragmentShader", null);
-    r(this, "version", 1);
-    this.gl = t;
-  }
-  /**
-   * Detect WebGL version from shader source.
-   * Looks for "#version 300 es" directive.
-   */
-  static detectVersion(t) {
-    return /^\s*#version\s+300\s+es/m.test(t) ? 2 : 1;
+class oe {
+  constructor(e) {
+    o(this, "gl");
+    o(this, "program", null);
+    o(this, "vertexShader", null);
+    o(this, "fragmentShader", null);
+    this.gl = e;
   }
   /**
    * Compile shaders and link program.
    * @throws ShaderCompilationError if compilation fails
    * @throws ProgramLinkError if linking fails
    */
-  compile(t, e) {
-    this.destroy();
-    const i = a.detectVersion(t), s = a.detectVersion(e);
-    if (i != s)
-      throw new k(i, s);
-    return this.version = Math.max(i, s), this.vertexShader = this.compileShader("vertex", t), this.fragmentShader = this.compileShader("fragment", e), this.linkProgram(), this;
+  compile(e, t) {
+    return this.destroy(), this.vertexShader = this.compileShader("vertex", e), this.fragmentShader = this.compileShader("fragment", t), this.linkProgram(), this;
   }
   /**
    * Bind this program for rendering.
@@ -355,122 +475,1994 @@ class a {
     return this.program;
   }
   /**
-   * Get detected WebGL version.
+   * Get attribute location.
+   */
+  getAttribLocation(e) {
+    return this.program ? this.gl.getAttribLocation(this.program, e) : -1;
+  }
+  /**
+   * Get uniform location.
+   */
+  getUniformLocation(e) {
+    return this.program ? this.gl.getUniformLocation(this.program, e) : null;
+  }
+  /**
+   * Cleanup all GPU resources.
+   */
+  destroy() {
+    const e = this.gl;
+    this.program && (this.vertexShader && e.detachShader(this.program, this.vertexShader), this.fragmentShader && e.detachShader(this.program, this.fragmentShader), e.deleteProgram(this.program), this.program = null), this.vertexShader && (e.deleteShader(this.vertexShader), this.vertexShader = null), this.fragmentShader && (e.deleteShader(this.fragmentShader), this.fragmentShader = null);
+  }
+  /**
+   * Compile a single shader.
+   * @throws ShaderCompilationError if compilation fails
+   */
+  compileShader(e, t) {
+    const n = this.gl, i = e === "vertex" ? n.VERTEX_SHADER : n.FRAGMENT_SHADER, r = n.createShader(i);
+    if (!r)
+      throw new _(
+        e,
+        t,
+        "Failed to create shader object"
+      );
+    if (n.shaderSource(r, t), n.compileShader(r), !n.getShaderParameter(r, n.COMPILE_STATUS)) {
+      const a = n.getShaderInfoLog(r) || "Unknown error";
+      throw n.deleteShader(r), new _(e, t, a);
+    }
+    return r;
+  }
+  /**
+   * Link vertex and fragment shaders into a program.
+   * @throws ProgramLinkError if linking fails
+   */
+  linkProgram() {
+    const e = this.gl;
+    if (!this.vertexShader || !this.fragmentShader)
+      throw new S("Shaders not compiled");
+    const t = e.createProgram();
+    if (!t)
+      throw new S("Failed to create program object");
+    if (e.attachShader(t, this.vertexShader), e.attachShader(t, this.fragmentShader), e.linkProgram(t), !e.getProgramParameter(t, e.LINK_STATUS)) {
+      const i = e.getProgramInfoLog(t) || "Unknown error";
+      throw e.deleteProgram(t), new S(i);
+    }
+    this.program = t;
+  }
+}
+class M {
+  constructor(e, t) {
+    o(this, "name");
+    o(this, "method");
+    o(this, "isArray");
+    o(this, "isMatrix");
+    o(this, "location", null);
+    o(this, "locationResolved", !1);
+    o(this, "value");
+    this.name = e, this.value = t;
+    const n = M.inferMethodInfo(t);
+    this.method = n.method, this.isArray = n.isArray, this.isMatrix = n.isMatrix;
+  }
+  /**
+   * Infer WebGL method and metadata from value type.
+   */
+  static inferMethodInfo(e) {
+    if (typeof e == "boolean")
+      return { method: "uniform1i", isArray: !1, isMatrix: !1 };
+    if (typeof e == "number")
+      return { method: "uniform1f", isArray: !1, isMatrix: !1 };
+    if (!Array.isArray(e))
+      return { method: "uniform1f", isArray: !1, isMatrix: !1 };
+    const t = e.length, n = e[0];
+    if (Array.isArray(n))
+      switch (n.length) {
+        case 2:
+          return { method: "uniform2fv", isArray: !0, isMatrix: !1 };
+        case 3:
+          return { method: "uniform3fv", isArray: !0, isMatrix: !1 };
+        case 4:
+          return { method: "uniform4fv", isArray: !0, isMatrix: !1 };
+        default:
+          return { method: "uniform1fv", isArray: !0, isMatrix: !1 };
+      }
+    switch (t) {
+      case 2:
+        return { method: "uniform2fv", isArray: !1, isMatrix: !1 };
+      case 3:
+        return { method: "uniform3fv", isArray: !1, isMatrix: !1 };
+      case 4:
+        return { method: "uniform4fv", isArray: !1, isMatrix: !1 };
+      case 9:
+        return { method: "uniformMatrix3fv", isArray: !1, isMatrix: !0 };
+      case 16:
+        return { method: "uniformMatrix4fv", isArray: !1, isMatrix: !0 };
+      default:
+        return { method: "uniform1fv", isArray: !0, isMatrix: !1 };
+    }
+  }
+  /**
+   * Resolve and cache uniform location from program.
+   * Returns null if uniform doesn't exist (optimized out by compiler, etc.)
+   */
+  resolveLocation(e, t) {
+    return this.locationResolved || (this.location = e.getUniformLocation(t, this.name), this.locationResolved = !0), this.location;
+  }
+  /**
+   * Invalidate cached location (call when program changes).
+   */
+  invalidateLocation() {
+    this.location = null, this.locationResolved = !1;
+  }
+  /**
+   * Update value (doesn't upload to GPU until upload() is called).
+   */
+  setValue(e) {
+    this.value = e;
+  }
+  /**
+   * Get current value.
+   */
+  getValue() {
+    return this.value;
+  }
+  /**
+   * Upload current value to GPU.
+   * @param gl - WebGL context
+   * @param program - Current WebGL program (for location resolution)
+   */
+  upload(e, t) {
+    const n = this.resolveLocation(e, t);
+    if (n === null)
+      return;
+    const i = this.value;
+    let r;
+    switch (typeof i == "boolean" ? r = i ? 1 : 0 : typeof i == "number" ? r = i : this.isArray && Array.isArray(i[0]) ? r = new Float32Array(
+      i.flat()
+    ) : r = new Float32Array(i), this.method) {
+      case "uniform1f":
+        e.uniform1f(n, r);
+        break;
+      case "uniform1i":
+        e.uniform1i(n, r);
+        break;
+      case "uniform1fv":
+        e.uniform1fv(n, r);
+        break;
+      case "uniform2fv":
+        e.uniform2fv(n, r);
+        break;
+      case "uniform3fv":
+        e.uniform3fv(n, r);
+        break;
+      case "uniform4fv":
+        e.uniform4fv(n, r);
+        break;
+      case "uniformMatrix2fv":
+        e.uniformMatrix2fv(n, !1, r);
+        break;
+      case "uniformMatrix3fv":
+        e.uniformMatrix3fv(n, !1, r);
+        break;
+      case "uniformMatrix4fv":
+        e.uniformMatrix4fv(n, !1, r);
+        break;
+    }
+  }
+}
+class E {
+  constructor(e) {
+    o(this, "parsed", null);
+    this.source = e;
+  }
+  /**
+   * Parse the shader source to extract imports, uniforms, functions, and version.
+   */
+  parse() {
+    if (this.parsed) return this.parsed;
+    const e = this.detectVersion(), t = this.detectImports(), n = this.detectUniforms(), i = this.detectFunctions(n);
+    return this.parsed = {
+      version: e,
+      imports: t,
+      uniforms: n,
+      functions: i
+    };
+  }
+  /**
+   * Check if the shader source has already been parsed
+   */
+  isParsed() {
+    return this.parsed !== null;
+  }
+  /**
+   * Change the shader source and reset the parsed result
+   */
+  setSource(e) {
+    this.source = e, this.parsed = null;
+  }
+  /**
+   * Get the detected GLSL version from the shader source without parsing the entire shader
+   */
+  version() {
+    return this.detectVersion();
+  }
+  detectVersion() {
+    return /^\s*#version\s+300\s+es/m.test(this.source) ? 2 : 1;
+  }
+  detectImports() {
+    const e = /^[ \t]*#import\s+(\w+)(?:\s+as\s+(\w+))?\s+from\s+["'](.+)["']/gm, t = /^[ \t]*[^\w\s]?import\b/gm, n = [], i = /* @__PURE__ */ new Set();
+    let r, s = 1, a = 0;
+    for (; (r = e.exec(this.source)) !== null; ) {
+      s += (this.source.substring(a, r.index).match(/\n/g) || []).length, a = r.index, i.add(s);
+      const f = r[1], c = r[2] || r[1], m = r[3];
+      if (n.some((p) => p.alias === c))
+        throw new j(c, s);
+      n.push({ name: f, alias: c, module: m, line: s });
+    }
+    let l;
+    for (; (l = t.exec(this.source)) !== null; ) {
+      const f = (this.source.substring(0, l.index).match(/\n/g) || []).length + 1;
+      if (i.has(f)) continue;
+      const c = this.source.split(`
+`)[f - 1].trim();
+      throw new q(
+        f,
+        this.diagnoseImport(c)
+      );
+    }
+    return n;
+  }
+  diagnoseImport(e) {
+    const t = e.match(/^([^\w\s])import\b/);
+    if (t && t[1] !== "#")
+      return `Invalid prefix '${t[1]}'. Expected: #import <function> from '<module>'`;
+    if (/^import\b/.test(e))
+      return "Missing '#' prefix. Expected: #import <function> from '<module>'";
+    if (/^#import\s+from\b/.test(e))
+      return "Missing function name. Expected: #import <function> from '<module>'";
+    if (/^#import\s+\w+\s*$/.test(e))
+      return `Missing 'from' clause. Expected: #import ${e.split(/\s+/)[1]} from '<module>'`;
+    if (/^#import\s+\w+\s+as\s*$/.test(e) || /^#import\s+\w+\s+as\s+from\b/.test(e))
+      return `Missing alias name after 'as'. Expected: #import ${e.split(/\s+/)[1]} as <alias> from '<module>'`;
+    if (/^#import\s+\w+\s+as\s+\w+\s*$/.test(e)) {
+      const n = e.split(/\s+/);
+      return `Missing 'from' clause. Expected: #import ${n[1]} as ${n[3]} from '<module>'`;
+    }
+    if (/^#import\s+\w+(?:\s+as\s+\w+)?\s+from\s+\w+/.test(e)) {
+      const n = e.match(/from\s+(\S+)/);
+      return `Module name must be quoted. Expected: from '${n == null ? void 0 : n[1]}'`;
+    }
+    return "Invalid syntax. Expected: #import <function> from '<module>'";
+  }
+  detectUniforms() {
+    const e = /^[ \t]*uniform\s+(?:(?:highp|mediump|lowp)\s+)?(\w+)\s+(\w+)(?:\[(\d+)\])?\s*;/gm, t = [];
+    let n, i = 1, r = 0;
+    for (; (n = e.exec(this.source)) !== null; ) {
+      i += (this.source.substring(r, n.index).match(/\n/g) || []).length, r = n.index;
+      const s = n[1], a = n[2], l = n[3] ? parseInt(n[3], 10) : void 0;
+      t.push({ name: a, type: s, line: i, arrayNum: l });
+    }
+    return t;
+  }
+  detectFunctions(e) {
+    const t = [], n = "void|float|int|uint|bool|vec[234]|ivec[234]|uvec[234]|bvec[234]|mat[234](?:x[234])?|sampler2D|samplerCube|sampler3D|sampler2DArray", i = new RegExp(
+      `^[ \\t]*(${n})\\s+(\\w+)\\s*\\(([^)]*)\\)\\s*\\{`,
+      "gm"
+    );
+    let r;
+    for (; (r = i.exec(this.source)) !== null; ) {
+      const s = r[1], a = r[2], l = r[3].trim(), f = r.index, c = (this.source.substring(0, f).match(/\n/g) || []).length + 1, m = this.source.indexOf("{", f), p = this.findClosingBrace(this.source, m);
+      if (p === -1) continue;
+      const g = this.source.slice(m, p + 1), P = this.parseParams(l), $ = this.findFunctionCalls(g), D = this.findUniformCalls(g, e), B = this.findMentionCalls(g);
+      t.push({
+        name: a,
+        type: s,
+        params: P,
+        body: g,
+        dependencies: [...$, ...D, ...B],
+        line: c
+      });
+    }
+    return t;
+  }
+  parseParams(e) {
+    if (!e.trim()) return [];
+    const t = [], n = e.split(",");
+    for (const i of n) {
+      const r = i.trim();
+      if (!r) continue;
+      const a = r.replace(/\b(in|out|inout|const|highp|mediump|lowp)\b\s*/g, "").trim().match(/^(\w+)\s+(\w+)(?:\[\d*\])?$/);
+      a && t.push({
+        type: a[1],
+        name: a[2]
+      });
+    }
+    return t;
+  }
+  findClosingBrace(e, t) {
+    let n = 0, i = !1, r = !1, s = !1, a = !1;
+    for (let l = t; l < e.length; l++) {
+      const f = e[l], c = e[l + 1], m = e[l - 1];
+      if (!r && !a && f === "/" && c === "/") {
+        s = !0;
+        continue;
+      }
+      if (s && f === `
+`) {
+        s = !1;
+        continue;
+      }
+      if (!r && !s && f === "/" && c === "*") {
+        a = !0, l++;
+        continue;
+      }
+      if (a && f === "*" && c === "/") {
+        a = !1, l++;
+        continue;
+      }
+      if (!(s || a)) {
+        if (f === '"' && m !== "\\") {
+          r = !r;
+          continue;
+        }
+        if (!r) {
+          if (f === "{")
+            n++, i = !0;
+          else if (f === "}" && (n--, i && n === 0))
+            return l;
+        }
+      }
+    }
+    return -1;
+  }
+  findFunctionCalls(e) {
+    const t = [], n = /* @__PURE__ */ new Set([
+      "if",
+      "else",
+      "for",
+      "while",
+      "do",
+      "switch",
+      "case",
+      "return",
+      "break",
+      "continue",
+      "discard"
+    ]), i = /\b([a-zA-Z_]\w*)\s*\(/g;
+    let r;
+    for (; (r = i.exec(e)) !== null; ) {
+      const s = r[1];
+      n.has(s) || t.push({
+        name: s,
+        type: "function",
+        index: r.index
+      });
+    }
+    return t;
+  }
+  findUniformCalls(e, t) {
+    const n = [];
+    for (const i of t) {
+      const r = new RegExp(`\\b${i.name}\\b`, "g");
+      let s;
+      for (; (s = r.exec(e)) !== null; )
+        n.push({
+          name: i.name,
+          type: "uniform",
+          index: s.index
+        });
+    }
+    return n;
+  }
+  findMentionCalls(e) {
+    const t = [], n = /@(\w+)\.([a-zA-Z_]\w*)/g;
+    let i;
+    for (; (i = n.exec(e)) !== null; ) {
+      const r = i[1], s = i[2];
+      t.push({
+        name: `${r}.${s}`,
+        type: "mention",
+        index: i.index
+      });
+    }
+    return t;
+  }
+}
+class F {
+  constructor(e) {
+    /** Flag to track if the shader has been compiled */
+    o(this, "isCompiled", !1);
+    /** Original and compiled shader parsers */
+    o(this, "original");
+    /** Compiled parser will be updated with rewritten source after processing imports */
+    o(this, "compiled");
+    /** Collected requirements from imports */
+    o(this, "requirements", {
+      uniforms: /* @__PURE__ */ new Map(),
+      functions: /* @__PURE__ */ new Map()
+    });
+    this.original = new E(e), this.compiled = new E(e);
+  }
+  /**
+   * Detect WebGL version from shader source
+   */
+  version() {
+    return this.original.version();
+  }
+  /**
+   * Get the original source code of the shader
+   */
+  source() {
+    return this.original.source;
+  }
+  /**
+   * Force recompilation of the shader, reprocessing all imports and rewrites
+   * It's not necessary to call this manually because the state gets lost whenever the shader is switched out and back in.
+   */
+  recompile() {
+    return this.isCompiled = !1, this.compile();
+  }
+  /**
+   * Compile the shader source, resolving all imports
+   */
+  compile() {
+    return this.isCompiled ? this.compiled.source : (this.original.parse().imports.length > 0 && this.processImports(), this.compiled.setSource(this.build()), this.isCompiled = !0, this.compiled.source);
+  }
+  /**
+   * Process all #import directives
+   */
+  processImports() {
+    const e = this.original.parse(), t = e.functions.flatMap((n) => n.dependencies.filter((i) => i.type === "mention").map((i) => ({
+      name: i.name.split(".")[0],
+      uniform: i.name.split(".")[1]
+    })));
+    for (const n of e.imports) {
+      const i = w.resolve(n.module), r = i.extract(n.name);
+      let s = t.filter(
+        (l) => l.name === r.function.name
+      );
+      if (s.length > 0) {
+        const l = i.getDefinition().uniforms;
+        if (s = s.filter((f) => {
+          const c = l.find(
+            (m) => m.name === `u_${f.uniform}` || m.name === f.uniform
+          );
+          if (c) {
+            r.dependencies.uniforms.some(
+              (p) => p.name === c.name
+            ) || r.dependencies.uniforms.push(c);
+            const m = t.indexOf(f);
+            return m > -1 && t.splice(m, 1), !1;
+          }
+          return !0;
+        }), s.length > 0)
+          throw new ee(
+            n.module,
+            r.function.name,
+            s[0].uniform
+          );
+      }
+      const a = i.copy();
+      this.processExtraction(r, n.alias, a.options), y.merge(n.module, a);
+    }
+    if (t.length > 0)
+      throw new te(
+        t[0].name,
+        t[0].uniform
+      );
+  }
+  /**
+   * Process an extraction: rewrite names and collect as requirements
+   */
+  processExtraction(e, t, n = {}) {
+    const i = e.function, r = Math.random().toString(36).substring(2, 8), s = `${t}_${r}`;
+    for (let l = e.dependencies.functions.length - 1; l >= 0; l--) {
+      const f = e.dependencies.functions[l], c = this.rewriteFunction(f, t, {
+        uniforms: e.dependencies.uniforms,
+        functions: e.dependencies.functions,
+        unique: s
+      });
+      this.requirements.functions.set(c.name, c);
+    }
+    const a = this.rewriteFunction(i, t, {
+      uniforms: e.dependencies.uniforms,
+      functions: e.dependencies.functions,
+      rename: !0,
+      unique: s
+    });
+    this.requirements.functions.set(a.name, a);
+    for (const l of e.dependencies.uniforms) {
+      if (R.has(l.name)) continue;
+      const f = {
+        ...l,
+        name: `${s}_${l.name}${l.arrayNum ? `[${l.arrayNum}]` : ""}`
+      };
+      if (n[i.name]) {
+        const c = Object.entries(n[i.name]).find(
+          ([m, p]) => p.uniform === l.name
+        );
+        c && (c[1].uniform = `${s}_${l.name}`);
+      }
+      this.requirements.uniforms.set(f.name, f);
+    }
+    n[i.name] && t !== i.name && (n[t] = n[i.name], delete n[i.name]);
+  }
+  /**
+   * Rewrite a function: namespace all uniform and helper function references
+   */
+  rewriteFunction(e, t, n = { rename: !1, uniforms: [], functions: [], unique: "" }) {
+    const i = new Set(n.uniforms.map((c) => c.name)), r = new Set(n.functions.map((c) => c.name)), s = [], a = n.unique ? n.unique : t;
+    for (const c of e.dependencies)
+      if (c.index !== void 0)
+        if (c.type === "uniform" && i.has(c.name)) {
+          if (R.has(c.name)) continue;
+          s.push({
+            index: c.index,
+            oldText: c.name,
+            newText: `${a}_${c.name}`
+          });
+        } else c.type === "function" && r.has(c.name) && s.push({
+          index: c.index,
+          oldText: c.name,
+          newText: `${a}_${c.name}`
+        });
+    const l = this.applyRewrites(e.body, s), f = n.rename ? t : `${a}_${e.name}`;
+    return {
+      ...e,
+      name: f,
+      body: l
+    };
+  }
+  /**
+   * Apply rewrite operations to a string, processing from end to start
+   */
+  applyRewrites(e, t) {
+    const n = [...t].sort((r, s) => s.index - r.index);
+    let i = e;
+    for (const r of n)
+      i = i.slice(0, r.index) + r.newText + i.slice(r.index + r.oldText.length);
+    return i;
+  }
+  /**
+   * Build the final compiled shader
+   */
+  build() {
+    const e = this.original.parse();
+    let t = this.original.source;
+    t = this.removeImportLines(t, e);
+    const n = this.findInsertionPointForUniforms(t), i = this.generateUniformsCode();
+    i && (t = t.slice(0, n) + i + `
+` + t.slice(n));
+    const r = this.findInsertionPointForFunctions(t), s = this.generateFunctionCode();
+    return s && (t = t.slice(0, r) + s + t.slice(r)), t = t.replace(/\n{3,}/g, `
+
+`), t = this.replaceMentions(t, e), t;
+  }
+  replaceMentions(e, t) {
+    let n = e;
+    const i = t.functions.filter(
+      (r) => r.dependencies.some((s) => s.type === "mention")
+    );
+    for (const r of i) {
+      const s = r.dependencies.filter((a) => a.type === "mention");
+      for (const a of s) {
+        const l = a.name.split("."), f = new RegExp(`\\b${l[0]}_(\\w+)_${l[1]}\\b`, "g"), c = this.requirements.uniforms.keys().find((p) => {
+          var g;
+          return ((g = p.match(f)) == null ? void 0 : g[0]) === p;
+        });
+        if (!c)
+          throw new ne(
+            a.name,
+            r.name
+          );
+        const m = new RegExp(`@\\b${a.name}\\b`, "g");
+        n = n.replace(m, c);
+      }
+    }
+    return n;
+  }
+  /**
+   * Remove #import lines from shader source
+   */
+  removeImportLines(e, t) {
+    const n = e.split(`
+`), i = new Set(t.imports.map((r) => r.line));
+    return n.filter((r, s) => {
+      const a = i.has(s + 1);
+      if (!a && r.trim() === "" && s > 0) {
+        const l = s - 1;
+        if (i.has(l + 1))
+          return !1;
+      }
+      return !a;
+    }).join(`
+`);
+  }
+  /**
+   * Find insertion point for uniforms (after existing uniforms)
+   */
+  findInsertionPointForUniforms(e) {
+    const t = new E(e).parse(), n = t.uniforms.find(
+      (a) => a.line === Math.max(...t.uniforms.map((l) => l.line ?? 0))
+    ), i = e.split(`
+`);
+    let r = 0;
+    if (n && n.line)
+      r = n.line;
+    else
+      for (let a = 0; a < i.length; a++) {
+        const l = i[a].trim();
+        if (l.startsWith("#version")) {
+          r = a + 1;
+          continue;
+        }
+        if (l.startsWith("precision ")) {
+          r = a + 1;
+          continue;
+        }
+        if (l === "" || l.startsWith("//")) {
+          r === a && (r = a + 1);
+          continue;
+        }
+        break;
+      }
+    let s = 0;
+    for (let a = 0; a < r; a++)
+      s += i[a].length + 1;
+    return s;
+  }
+  findInsertionPointForFunctions(e) {
+    const t = new E(e).parse(), n = t.functions.find(
+      (a) => a.line === Math.min(...t.functions.map((l) => l.line ?? 1 / 0))
+    ), i = e.split(`
+`);
+    let r = 0;
+    if (n && n.line)
+      r = n.line - 2;
+    else
+      throw new H();
+    let s = 0;
+    for (let a = 0; a < r; a++)
+      s += i[a].length + 1;
+    return s;
+  }
+  /**
+   * Generate GLSL code for uniforms
+   */
+  generateUniformsCode() {
+    const e = [];
+    if (this.requirements.uniforms.size > 0)
+      for (const t of this.checkUniformsPresence())
+        e.push(`uniform ${t.type} ${t.name};`);
+    return e.length === 0 ? "" : e.join(`
+`) + `
+`;
+  }
+  /**
+   * Generate GLSL code for functions
+   */
+  generateFunctionCode() {
+    const e = [];
+    if (this.requirements.functions.size > 0)
+      for (const t of this.checkFunctionsPresence()) {
+        const n = t.params.map((i) => `${i.type} ${i.name}`).join(", ");
+        e.push(`
+${t.type} ${t.name}(${n}) ${t.body}`);
+      }
+    return e.length === 0 ? "" : e.join(`
+`) + `
+`;
+  }
+  /**
+   * Check which required uniforms are missing from the original shader
+   */
+  checkUniformsPresence() {
+    const e = this.original.parse(), t = [], n = this.requirements.uniforms;
+    for (const [i, r] of n) {
+      const s = e.uniforms.find((a) => a.name === i);
+      if (!s) {
+        t.push(r);
+        continue;
+      }
+      if (s.type !== r.type)
+        throw new U(
+          "uniform",
+          i,
+          r.type,
+          s.type
+        );
+    }
+    return t;
+  }
+  /**
+   * Check which required functions are missing from the original shader
+   */
+  checkFunctionsPresence() {
+    const e = this.original.parse(), t = [], n = this.requirements.functions;
+    for (const [i, r] of n) {
+      const s = e.functions.find((a) => a.name === i);
+      if (!s) {
+        t.push(r);
+        continue;
+      }
+      if (s.type !== r.type)
+        throw new U(
+          "function",
+          i,
+          r.type,
+          s.type
+        );
+    }
+    return t;
+  }
+}
+class v extends F {
+  constructor(t, n, i = {}) {
+    super(n);
+    o(this, "name");
+    o(this, "options", {});
+    this.name = t, this.options = this.resolveOptions(i);
+  }
+  resolveOptions(t) {
+    if (!(t != null && t.default)) return t || {};
+    const n = this.original.parse(), i = t.default;
+    for (const r of n.functions)
+      if (!(r.name === "main" || r.name === "default"))
+        if (t[r.name]) {
+          const s = t[r.name];
+          for (const a in i)
+            a in s || (s[a] = i[a]);
+        } else
+          t[r.name] = { ...i };
+    return delete t.default, t || {};
+  }
+  /**
+   * Define a module with given name and source, and register it
+   */
+  static define(t) {
+    const { name: n, source: i, options: r } = t;
+    if (n === "sandbox" || n.startsWith("sandbox/"))
+      throw new J(n);
+    const s = new v(n, i, r);
+    if (w.has(n))
+      throw new Z(n);
+    return w.register(n, s), s;
+  }
+  /**
+   * Resolve a module by name from the registry, throwing an error if not found
+   */
+  static resolve(t) {
+    return w.resolve(t);
+  }
+  /**
+   * Create a copy of the module. To unplug references to the original object.
+   * Used when copying module to the runtime registry to allow independent runtime changes to options without affecting the original module definition.
+   */
+  copy(t = "original") {
+    return new v(
+      this.name,
+      this[t].source,
+      JSON.parse(JSON.stringify(this.options))
+    );
+  }
+  /**
+   * Merge options from another module into this one, without affecting the original module definition.
+   * Used when merging imported modules into the runtime registry.
+   */
+  merge(t) {
+    this.options = this.options || {};
+    const n = this.getDefinition().uniforms.map((i) => i.name);
+    for (const [i, r] of Object.entries(t.options ?? {}))
+      if (!this.options[i]) this.options[i] = r;
+      else
+        for (const [s, a] of Object.entries(r))
+          n.includes(a.uniform) || (this.options[i][s] = a);
+  }
+  /**
+   * Get the module definition
+   */
+  getDefinition() {
+    return this.compile(), {
+      name: this.name,
+      methods: this.compiled.parse().functions.map((t) => t.name).filter((t) => t !== "main" && t !== "default"),
+      uniforms: this.compiled.parse().uniforms.map((t) => ({ name: t.name, type: t.type })),
+      options: this.options
+    };
+  }
+  /**
+   * Extract a method with all its dependencies
+   */
+  extract(t) {
+    if (this.compile(), t === "main")
+      throw new K(this.name);
+    if (t === "default")
+      throw new Q(this.name);
+    const n = this.compiled.parse(), i = n.functions.find((a) => a.name === t);
+    if (!i)
+      throw new Y(this.name, t);
+    const r = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+    return this.collectDependencies({
+      current: i,
+      scope: {
+        functions: n.functions,
+        uniforms: n.uniforms
+      },
+      collected: {
+        functions: r,
+        uniforms: s
+      },
+      visited: /* @__PURE__ */ new Set([t])
+    }), {
+      function: i,
+      dependencies: {
+        functions: Array.from(r.values()),
+        uniforms: Array.from(s.values())
+      }
+    };
+  }
+  /**
+   * Recursively collect all function and uniform dependencies
+   */
+  collectDependencies(t) {
+    for (const n of t.current.dependencies)
+      if (n.type === "function") {
+        if (t.visited.has(n.name)) continue;
+        const i = t.scope.functions.find((r) => r.name === n.name);
+        i && (t.visited.add(n.name), t.collected.functions.set(n.name, i), this.collectDependencies({
+          current: i,
+          scope: {
+            functions: t.scope.functions,
+            uniforms: t.scope.uniforms
+          },
+          collected: {
+            functions: t.collected.functions,
+            uniforms: t.collected.uniforms
+          },
+          visited: t.visited
+        }));
+      } else if (n.type === "uniform") {
+        const i = t.scope.uniforms.find(
+          (r) => r.name === n.name
+        );
+        i && !t.collected.uniforms.has(n.name) && t.collected.uniforms.set(n.name, i);
+      }
+  }
+}
+class V {
+  constructor(e = []) {
+    o(this, "modules", /* @__PURE__ */ new Map());
+    e.forEach((t) => {
+      this.register(t.name, t);
+    });
+  }
+  /**
+   * Compile all registered modules.
+   */
+  compile() {
+    this.modules.forEach((e) => {
+      e.compile();
+    });
+  }
+  /**
+   * Get the list of available shader modules.
+   */
+  available() {
+    return Array.from(this.modules.values()).map(
+      (e) => e.getDefinition()
+    );
+  }
+  /**
+   * Get the list of uniforms required by the currently registered modules.
+   * This is used to automatically set up the uniforms in the shader based on the modules in use.
+   */
+  defaults() {
+    const e = {};
+    return this.modules.forEach((t) => {
+      const n = t.getDefinition();
+      if (n.options)
+        for (const i in n.options) {
+          const r = n.options[i];
+          for (const s in r) {
+            const a = r[s];
+            a.default !== void 0 && !n.uniforms.map((l) => l.name).includes(a.uniform) && (e[a.uniform] = a.default);
+          }
+        }
+    }), e;
+  }
+  /**
+   * Resolve the options from the module definitions for a given function name.
+   */
+  resolveOptions(e) {
+    for (const t of this.modules.values())
+      if (t.options && t.options[e])
+        return t.options[e];
+    return null;
+  }
+  /**
+   * Register a new module in the registry.
+   */
+  register(e, t) {
+    this.modules.set(e, t);
+  }
+  /**
+   * Merge a module into the registry. If a module with the same name already exists, options will be merged together.
+   */
+  merge(e, t) {
+    if (!this.modules.has(e)) return this.register(e, t);
+    const n = this.modules.get(e);
+    n.merge(t), this.modules.set(e, n);
+  }
+  /**
+   * Resolve a module by name. Throws an error if the module is not found.
+   */
+  resolve(e) {
+    const t = this.modules.get(e);
+    if (!t)
+      throw new X(e);
+    return t;
+  }
+  /**
+   * Check if a module exists in the registry by name.
+   */
+  has(e) {
+    return this.modules.has(e);
+  }
+  /**
+   * Check if the registry is empty (no modules registered).
+   */
+  isEmpty() {
+    return this.modules.size === 0;
+  }
+  /**
+   * Remove a module from the registry by name.
+   */
+  remove(e) {
+    this.modules.delete(e);
+  }
+  /**
+   * Load multiple modules into the registry at once.
+   */
+  load(e) {
+    e.forEach((t) => {
+      this.register(t.name, t);
+    });
+  }
+  /**
+   * Clear all registered modules from the registry.
+   */
+  clear() {
+    this.modules.clear();
+  }
+}
+const ae = `// ─── Constants ──────────────────────────────────────────────
+
+const float PI = 3.14159265359;
+const float TAU = 6.28318530718;
+
+// ─── UV Transforms ──────────────────────────────────────────
+
+/**
+ * Center UV coordinates — remap to range where (0,0) is canvas center.
+ * Aspect-ratio corrected using resolution length.
+ * @uv-modifier
+ */
+vec2 center(vec2 uv) {
+    return (uv - 0.5 * u_resolution) / length(u_resolution);
+}
+
+/**
+ * Translate UV coordinates by offset.
+ * @uv-modifier
+ */
+vec2 translate(vec2 uv, vec2 offset) {
+    return uv - offset;
+}
+
+/**
+ * Scale UV coordinates by factor around origin.
+ * @uv-modifier
+ */
+vec2 scale(vec2 uv, float factor) {
+    return uv * factor;
+}
+
+/**
+ * Zoom — scale UV with aspect ratio correction.
+ * Expects centered UV (use center() first).
+ * Pushes UV outward/inward from origin.
+ * factor = zoom factor (>1 = zoom in, <1 = zoom out)
+ * @uv-modifier
+ */
+vec2 zoom(vec2 uv, float factor) {
+    return uv / max(factor, 0.001);
+}
+
+/**
+ * Normalize UV to range -1 to 1 with aspect ratio correction.
+ * @uv-modifier
+ */
+vec2 norm(vec2 uv) {
+    uv *= min(u_resolution.x, u_resolution.y) / length(u_resolution);
+    return uv;
+}
+
+/**
+ * Rotate UV coordinates around origin by angle (radians).
+ * @uv-modifier
+ */
+vec2 rotate(vec2 uv, float angle) {
+    float c = cos(angle);
+    float s = sin(angle);
+    return vec2(uv.x * c - uv.y * s, uv.x * s + uv.y * c);
+}
+
+/**
+ * Tile — repeat coordinates in a grid of given size.
+ * @uv-modifier
+ */
+vec2 tile(vec2 uv, float size) {
+    return fract(uv / size) * size;
+}
+
+/**
+ * Cartesian to polar coordinates.
+ * Returns vec2(angle, radius) where angle is -PI to PI.
+ */
+vec2 polar(vec2 uv) {
+    return vec2(atan(uv.y, uv.x), length(uv));
+}
+
+/**
+ * Aspect ratio correction — makes UV square regardless of canvas shape.
+ * @uv-modifier
+ */
+vec2 aspect(vec2 uv) {
+    return uv * vec2(u_resolution.x / u_resolution.y, 1.0);
+}
+
+// ─── Math Utilities ─────────────────────────────────────────
+
+/**
+ * Remap a value from one range to another.
+ * map(0.5, 0.0, 1.0, -1.0, 1.0) → 0.0
+ */
+float map(float value, float inMin, float inMax, float outMin, float outMax) {
+    return outMin + (value - inMin) * (outMax - outMin) / (inMax - inMin);
+}
+
+// ─── Noise & Random ─────────────────────────────────────────
+
+/**
+ * Pseudo-random hash from 2D coordinates.
+ * Returns float in 0–1 range.
+ */
+float hash(vec2 p) {
+    return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453123);
+}
+
+/**
+ * 2D pseudo-random hash.
+ * Returns vec2 in 0–1 range — used for point scattering (worley etc).
+ */
+vec2 hash2(vec2 p) {
+    p = vec2(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)));
+    return fract(sin(p) * 43758.5453123);
+}
+
+/**
+ * Smooth value noise — interpolated hash grid.
+ */
+float noise(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    vec2 u = f * f * (3.0 - 2.0 * f);
+
+    return mix(
+        mix(hash(i), hash(i + vec2(1.0, 0.0)), u.x),
+        mix(hash(i + vec2(0.0, 1.0)), hash(i + vec2(1.0, 1.0)), u.x),
+        u.y
+    );
+}
+
+/**
+ * Fractal Brownian Motion — 6 octaves of layered noise.
+ * Returns ~0–1 range. Great for clouds, terrain, organic textures.
+ */
+float fbm(vec2 p) {
+    float value = 0.0;
+    float amplitude = 0.5;
+
+    for (int i = 0; i < 6; i++) {
+        value += amplitude * noise(p);
+        p *= 2.0;
+        amplitude *= 0.5;
+    }
+
+    return value;
+}
+
+/**
+ * Worley (cellular / voronoi) noise.
+ * Returns distance to nearest random cell point.
+ * Great for cells, cracks, organic patterns.
+ */
+float worley(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    float minDist = 1.0;
+
+    for (int y = -1; y <= 1; y++) {
+        for (int x = -1; x <= 1; x++) {
+            vec2 neighbor = vec2(float(x), float(y));
+            vec2 point = hash2(i + neighbor);
+            float dist = length(neighbor + point - f);
+            minDist = min(minDist, dist);
+        }
+    }
+
+    return minDist;
+}
+
+/**
+ * Waves — layered sine wave interference pattern.
+ * Creates clean, regular wave lines like fabric or moiré.
+ * frequency = wave density (5.0 = fabric, 10.0 = fine lines)
+ * Returns 0–1 range.
+ */
+float waves(vec2 p, float frequency) {
+    return 0.6 + 0.4 * sin(
+        frequency * (p.x + p.y + cos(3.0 * p.x + 5.0 * p.y)) +
+        sin(frequency * 4.0 * (p.x + p.y))
+    );
+}
+
+/**
+ * Voronoi cell lookup — returns the position of the nearest cell point.
+ * Same algorithm as worley, but returns the point instead of distance.
+ * Great for UV snapping, cell-based effects.
+ */
+vec2 voronoi(vec2 p) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    float minDist = 10.0;
+    vec2 nearest = vec2(0.0);
+
+    for (int y = -1; y <= 1; y++) {
+        for (int x = -1; x <= 1; x++) {
+            vec2 neighbor = vec2(float(x), float(y));
+            vec2 point = hash2(i + neighbor);
+            float dist = length(neighbor + point - f);
+            if (dist < minDist) {
+                minDist = dist;
+                nearest = i + neighbor + point;
+            }
+        }
+    }
+
+    return nearest;
+}
+
+void main() {}
+`, le = `/**
+ * Hex integer to RGB.
+ * Usage: hex(0xFF6600) → orange
+ */
+vec3 hex(int value) {
+    float v = float(value);
+    float r = floor(v / 65536.0);
+    float g = floor((v - r * 65536.0) / 256.0);
+    float b = v - r * 65536.0 - g * 256.0;
+    return vec3(r, g, b) / 255.0;
+}
+
+/**
+ * RGB 0–255 to normalized RGB 0–1.
+ * Usage: rgb255(255.0, 128.0, 0.0) → orange
+ */
+vec3 rgb255(float r, float g, float b) {
+    return vec3(r, g, b) / 255.0;
+}
+
+/**
+ * HSV to RGB.
+ * Input: vec3(hue 0–1, saturation 0–1, value 0–1)
+ */
+vec3 hsv(vec3 c) {
+    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+/**
+ * HSL to RGB.
+ * Input: vec3(hue 0–1, saturation 0–1, lightness 0–1)
+ */
+vec3 hsl(vec3 c) {
+    vec3 rgb = clamp(abs(mod(c.x * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0);
+    return c.z + c.y * (rgb - 0.5) * (1.0 - abs(2.0 * c.z - 1.0));
+}
+
+/**
+ * Linear gradient between two colors.
+ * t is clamped to 0–1.
+ */
+vec3 gradient(vec3 a, vec3 b, float t) {
+    return mix(a, b, clamp(t, 0.0, 1.0));
+}
+
+/**
+ * 3-stop gradient.
+ * t=0 → a, t=0.5 → b, t=1 → c
+ */
+vec3 gradient3(vec3 a, vec3 b, vec3 c, float t) {
+    t = clamp(t, 0.0, 1.0);
+    return t < 0.5
+        ? mix(a, b, t * 2.0)
+        : mix(b, c, (t - 0.5) * 2.0);
+}
+
+/**
+ * Cosine palette — Inigo Quilez formula.
+ * color = a + b * cos(2π(c·t + d))
+ * Generates infinite smooth color ramps from 4 vec3 params.
+ */
+vec3 palette(vec3 a, vec3 b, vec3 c, vec3 d, float t) {
+    return a + b * cos(6.28318 * (c * t + d));
+}
+
+/**
+ * Banded gradient — 3-zone color mapping with sharp transitions.
+ * Uses tent functions instead of linear interpolation.
+ * t=0 → b (center), t=1 → a (middle), t=2 → c (outer).
+ * sharpness = transition width (2.0 = sharp, 1.0 = soft).
+ */
+vec3 bands(vec3 a, vec3 b, vec3 c, float t, float sharpness) {
+    float w1 = max(0.0, 1.0 - sharpness * abs(1.0 - t));
+    float w2 = max(0.0, 1.0 - sharpness * abs(t));
+    float w3 = 1.0 - min(1.0, w1 + w2);
+    return a * w1 + b * w2 + c * w3;
+}
+
+/**
+ * Iridescent — iterative interference color pattern.
+ * Generates rainbow-like colors from UV through trigonometric iteration.
+ * Creates shimmering, oil-slick-like color fields.
+ * time = animation time (pass u_time), speed = animation speed
+ */
+vec3 iridescent(vec2 uv, float time, float speed) {
+    float d = -time * 0.5 * speed;
+    float a = 0.0;
+    for (int i = 0; i < 8; i++) {
+        a += cos(float(i) - d - a * uv.x);
+        d += sin(uv.y * float(i) + a);
+    }
+    d += time * 0.5 * speed;
+    vec3 col = vec3(cos(uv * vec2(d, a)) * 0.6 + 0.4, cos(a + d) * 0.5 + 0.5);
+    return cos(col * cos(vec3(d, a, 2.5)) * 0.5 + 0.5);
+}
+
+void main() {}
+`, ce = `// ─── Time Shapers ──────────────────────────────────────────
+// Convert raw time (u_time) to normalized 0–1 range.
+// Output feeds directly into easing functions.
+
+/**
+ * Loop — repeating sawtooth 0→1→0→1...
+ * duration = cycle length in seconds
+ */
+float loop(float t, float duration) {
+    return fract(t / duration);
+}
+
+/**
+ * Pingpong — triangle wave 0→1→0→1...
+ * duration = half-cycle length (0→1 takes \`duration\` seconds)
+ */
+float pingpong(float t, float duration) {
+    float m = mod(t, duration * 2.0);
+    return m < duration ? m / duration : 2.0 - m / duration;
+}
+
+/**
+ * Once — single play 0→1, then stays at 1.
+ * duration = animation length in seconds
+ * Use with delay: once(u_time - 2.0, 3.0) starts at 2s, takes 3s.
+ */
+float once(float t, float duration) {
+    return clamp(t / duration, 0.0, 1.0);
+}
+
+/**
+ * Reverse — flip animation direction.
+ * Turns 0→1 into 1→0. Works with any easing or shaper.
+ * Usage: reverse(spring(loop(u_time, 2.0))) for spring zoom-in.
+ */
+float reverse(float t) {
+    return 1.0 - t;
+}
+
+// ─── Easing Curves ─────────────────────────────────────────
+// All take t (0–1) and return shaped t (0–1).
+// Compose with time shapers: ease_in(loop(u_time, 2.0))
+
+/**
+ * Ease in — cubic acceleration. Slow start, fast end.
+ */
+float ease_in(float t) {
+    return t * t * t;
+}
+
+/**
+ * Ease out — cubic deceleration. Fast start, slow end.
+ */
+float ease_out(float t) {
+    float f = 1.0 - t;
+    return 1.0 - f * f * f;
+}
+
+/**
+ * Ease in-out — cubic smooth both ends.
+ */
+float ease_in_out(float t) {
+    return t < 0.5
+        ? 4.0 * t * t * t
+        : 1.0 - pow(-2.0 * t + 2.0, 3.0) * 0.5;
+}
+
+/**
+ * Spring — damped oscillation. Overshoots then settles at 1.
+ */
+float spring(float t) {
+    return 1.0 - exp(-6.0 * t) * cos(12.0 * t);
+}
+
+/**
+ * Bounce — bouncing ball landing. Multiple bounces settling at 1.
+ */
+float bounce(float t) {
+    if (t < 1.0 / 2.75) {
+        return 7.5625 * t * t;
+    } else if (t < 2.0 / 2.75) {
+        t -= 1.5 / 2.75;
+        return 7.5625 * t * t + 0.75;
+    } else if (t < 2.5 / 2.75) {
+        t -= 2.25 / 2.75;
+        return 7.5625 * t * t + 0.9375;
+    } else {
+        t -= 2.625 / 2.75;
+        return 7.5625 * t * t + 0.984375;
+    }
+}
+
+/**
+ * Elastic — springy overshoot with oscillation.
+ */
+float elastic(float t) {
+    return sin(13.0 * 3.14159 * 0.5 * t) * pow(2.0, -10.0 * t) + 1.0;
+}
+
+/**
+ * Overshoot — goes past 1, then pulls back. Slight rubber-band feel.
+ */
+float overshoot(float t) {
+    float s = 1.70158;
+    float f = 1.0 - t;
+    return 1.0 - f * f * (f * (s + 1.0) - s);
+}
+
+/**
+ * Teleport — barely creeps, then near-instant jump with spring settle.
+ * Duration mostly = wait time. Jump happens at ~85% of t.
+ * Tiny slow drift → snap → spring overshoot → settle at 1.
+ */
+float teleport(float t) {
+    float jump = smoothstep(0.8, 0.85, t);
+    float creep = pow(t / 0.8, 4.0) * 0.1 * (1.0 - jump);
+    float s = max(t - 0.85, 0.0) * 6.667;
+    float settle = exp(-5.0 * s) * sin(s * 15.0) * 0.15;
+    return creep + jump + settle;
+}
+
+void main() {}
+`, ue = `#import hash from 'sandbox'
+#import noise from 'sandbox'
+#import fbm from 'sandbox'
+#import voronoi from 'sandbox'
+#import worley from 'sandbox'
+
+uniform float u_intensity;
+
+// ─── UV Effects ─────────────────────────────────────────────
+// Each function takes UV and returns modified UV.
+// All use u_intensity uniform for configuration.
+
+/**
+ * Pixelate — blocky mosaic effect.
+ * Snaps UV to a grid. Higher intensity = larger pixels.
+ * intensity = pixel count along shortest axis (default: 20)
+ * @uv-modifier
+ */
+vec2 pixelate(vec2 uv, float intensity) {
+    float size = length(u_resolution) / (max(intensity, 1.0) * 10.0);
+    return floor(uv / size) * size;
+}
+
+/**
+ * Twist — spiral distortion from center outward.
+ * Expects centered UV (use center() first).
+ * intensity = twist strength (0.4 = subtle, 1.0 = full spiral)
+ * @uv-modifier
+ */
+vec2 twist(vec2 uv, float intensity) {
+    float dist = length(uv);
+    float angle = atan(uv.y, uv.x) - intensity * 20.0 * dist;
+    return vec2(cos(angle), sin(angle)) * dist;
+}
+
+/**
+ * Ripple — concentric wave distortion from center.
+ * Expects centered UV (use center() first).
+ * Creates water-drop-like rings.
+ * intensity = wave amplitude (0.5 = gentle, 2.0 = strong)
+ * @uv-modifier
+ */
+vec2 ripple(vec2 uv, float intensity) {
+    float dist = length(uv);
+    float wave = sin(dist * 40.0 - u_time * 3.0) * intensity * 0.02;
+    return uv + normalize(uv + 0.001) * wave;
+}
+
+/**
+ * Fisheye — barrel distortion from center.
+ * Expects centered UV (use center() first).
+ * Bends space outward like a fisheye lens.
+ * intensity = distortion power (0.5 = subtle, 2.0 = extreme)
+ * @uv-modifier
+ */
+vec2 fisheye(vec2 uv, float intensity) {
+    float dist = length(uv);
+    float power = pow(dist, intensity) / dist;
+    return uv * power;
+}
+
+/**
+ * Wobble — animated sine wave displacement.
+ * Creates a jelly-like horizontal wobble.
+ * intensity = wobble amount (1.0 = gentle, 5.0 = wild)
+ * @uv-modifier
+ */
+vec2 wobble(vec2 uv, float intensity) {
+    uv.x += sin(uv.y * 10.0 + u_time * 2.0) * intensity * 0.01;
+    uv.y += cos(uv.x * 10.0 + u_time * 2.0) * intensity * 0.01;
+    return uv;
+}
+
+/**
+ * Organic — iterative fluid morph distortion.
+ * Creates marble-like flowing patterns.
+ * intensity = animation speed (3.0 = default)
+ * @uv-modifier
+ */
+vec2 organic(vec2 uv, float intensity) {
+    float speed = u_time * intensity;
+    vec2 acc = vec2(uv.x + uv.y);
+
+    for (int i = 0; i < 5; i++) {
+        acc += sin(max(uv.x, uv.y)) + uv;
+        uv += 0.5 * vec2(
+            cos(5.1123314 + 0.353 * acc.y + speed * 0.131121),
+            sin(acc.x - 0.113 * speed)
+        );
+        uv -= cos(uv.x + uv.y) - sin(uv.x * 0.711 - uv.y);
+    }
+
+    return uv;
+}
+
+/**
+ * Glitch — random horizontal line displacement.
+ * Creates digital glitch artifact bands.
+ * intensity = glitch strength (0.5 = subtle, 3.0 = heavy)
+ * @uv-modifier
+ */
+vec2 glitch(vec2 uv, float intensity) {
+    float line = floor(uv.y * 50.0);
+    float shift = hash(vec2(line, floor(u_time * 8.0)));
+    shift = step(0.9, shift) * (shift - 0.9) * 10.0;
+    uv.x += shift * intensity * 0.1 * u_resolution.x;
+    return uv;
+}
+
+/**
+ * Mirror — reflect UV across a chosen axis.
+ * Creates bilateral symmetry.
+ * intensity = 0 for horizontal mirror, 1 for vertical mirror
+ * @uv-modifier
+ */
+vec2 mirror(vec2 uv, float intensity) {
+    if (intensity < 0.5) {
+        uv.x = abs(uv.x);
+    } else {
+        uv.y = abs(uv.y);
+    }
+    return uv;
+}
+
+/**
+ * Kaleidoscope — repeating angular symmetry.
+ * Expects centered UV (use center() first).
+ * Creates mandala-like radial repeats.
+ * intensity = number of segments (4 = quad, 6 = hex, 8 = octa)
+ * @uv-modifier
+ */
+vec2 kaleidoscope(vec2 uv, float intensity) {
+    float segments = max(intensity, 1.0);
+    float angle = atan(uv.y, uv.x);
+    float segment_angle = 6.28318 / segments;
+    angle = mod(angle, segment_angle);
+    angle = abs(angle - segment_angle * 0.5);
+    float r = length(uv);
+    return vec2(cos(angle), sin(angle)) * r;
+}
+
+/**
+ * Warp — domain warping using fractal noise.
+ * Displaces UV by layered fbm noise for smoke/cloud-like distortion.
+ * Animated over time.
+ * intensity = warp strength (0.5 = subtle haze, 3.0 = heavy distortion)
+ * @uv-modifier
+ */
+vec2 warp(vec2 uv, float intensity) {
+    vec2 offset = vec2(
+        fbm(uv + u_time * 0.3),
+        fbm(uv + vec2(5.2, 1.3) + u_time * 0.3)
+    );
+    return uv + offset * intensity * 0.1;
+}
+
+/**
+ * Displace — noise-based UV displacement.
+ * Shifts UV using smooth value noise for a wavy, heat-haze look.
+ * Animated over time.
+ * intensity = displacement amount (1.0 = gentle, 5.0 = strong)
+ * @uv-modifier
+ */
+vec2 displace(vec2 uv, float intensity) {
+    float nx = noise(uv * 5.0 + u_time);
+    float ny = noise(uv * 5.0 + vec2(3.7, 7.1) + u_time);
+    return uv + (vec2(nx, ny) - 0.5) * intensity * 0.05;
+}
+
+/**
+ * Shatter — voronoi cell-based UV snapping.
+ * Snaps UV to nearest cell point, creating a broken-glass look.
+ * intensity = cell density (5.0 = large shards, 20.0 = fine fragments)
+ * @uv-modifier
+ */
+vec2 shatter(vec2 uv, float intensity) {
+    return voronoi(uv * intensity) / intensity;
+}
+
+/**
+ * Cells — cellular distortion using Worley distance.
+ * Displaces UV outward from cell edges, like looking through textured glass.
+ * intensity = cell scale (3.0 = large bubbles, 15.0 = fine texture)
+ * @uv-modifier
+ */
+vec2 cells(vec2 uv, float intensity) {
+    float dist = worley(uv * intensity);
+    vec2 grad = vec2(
+        worley(uv * intensity + vec2(0.01, 0.0)) - dist,
+        worley(uv * intensity + vec2(0.0, 0.01)) - dist
+    );
+    return uv + grad * dist * 2.0;
+}
+
+void main() {}
+`, fe = `#import hash from 'sandbox'
+
+uniform float u_intensity;
+
+// ─── Color Filters ──────────────────────────────────────────
+// Each function takes a color and returns modified color.
+// All use u_intensity uniform for configuration.
+
+/**
+ * Contrast — adjust contrast around mid-gray.
+ * intensity: 1.0 = original, >1 = more contrast, <1 = flatter
+ * @color-modifier
+ */
+vec3 contrast(vec3 color, float intensity) {
+    return (color - 0.5) * intensity + 0.5;
+}
+
+/**
+ * Brightness — multiply overall brightness.
+ * intensity: 1.0 = original, >1 = brighter, <1 = darker
+ * @color-modifier
+ */
+vec3 brightness(vec3 color, float intensity) {
+    return color * intensity;
+}
+
+/**
+ * Saturate — adjust color saturation.
+ * intensity: 0 = grayscale, 1.0 = original, >1 = oversaturated
+ * @color-modifier
+ */
+vec3 saturate(vec3 color, float intensity) {
+    float gray = dot(color, vec3(0.299, 0.587, 0.114));
+    return mix(vec3(gray), color, intensity);
+}
+
+/**
+ * Posterize — reduce color to N discrete levels per channel.
+ * intensity = number of levels (4 = retro, 16 = subtle, 256 = nearly smooth)
+ * @color-modifier
+ */
+vec3 posterize(vec3 color, float intensity) {
+    float levels = max(intensity, 1.0);
+    return floor(color * levels + 0.5) / levels;
+}
+
+/**
+ * Threshold — convert to black and white based on cutoff.
+ * intensity = cutoff point (0.5 = balanced, lower = more white)
+ * @color-modifier
+ */
+vec3 threshold(vec3 color, float intensity) {
+    float avg = dot(color, vec3(0.299, 0.587, 0.114));
+    return avg > intensity ? vec3(1.0) : vec3(0.0);
+}
+
+/**
+ * Invert — flip all color channels.
+ * intensity: 0.0 = original, 1.0 = fully inverted, 0.5 = mid-gray
+ * @color-modifier
+ */
+vec3 invert(vec3 color, float intensity) {
+    return mix(color, 1.0 - color, intensity);
+}
+
+/**
+ * Glow — luminance-based bloom, bright areas get amplified.
+ * intensity = glow strength (0.5 = subtle, 2.0 = intense)
+ * @color-modifier
+ */
+vec3 glow(vec3 color, float intensity) {
+    float luminance = dot(color, vec3(0.299, 0.587, 0.114));
+    return color + color * luminance * intensity;
+}
+
+/**
+ * Grain — animated film noise overlay.
+ * intensity = noise strength (0.1 = subtle, 0.5 = heavy)
+ * @color-modifier
+ */
+vec3 grain(vec3 color, vec2 uv, float intensity) {
+    float n = (hash(uv * 1000.0 + u_time) - 0.5) * intensity;
+    return color + n;
+}
+
+/**
+ * Vignette — darken canvas edges.
+ * Applies circular falloff from center.
+ * intensity = darkness strength (1.0 = subtle, 2.0 = strong)
+ * @color-modifier
+ */
+vec3 vignette(vec3 color, vec2 uv, float intensity) {
+    vec2 centered = uv / u_resolution - 0.5;
+    float dist = length(centered);
+    float falloff = 1.0 - smoothstep(0.3, 0.7, dist * intensity);
+    return color * falloff;
+}
+
+/**
+ * Sepia — warm brownish tint like old photographs.
+ * intensity: 0.0 = original, 1.0 = full sepia
+ * @color-modifier
+ */
+vec3 sepia(vec3 color, float intensity) {
+    vec3 s;
+    s.r = dot(color, vec3(0.393, 0.769, 0.189));
+    s.g = dot(color, vec3(0.349, 0.686, 0.168));
+    s.b = dot(color, vec3(0.272, 0.534, 0.131));
+    return mix(color, s, intensity);
+}
+
+/**
+ * Gamma — apply gamma correction curve.
+ * intensity = gamma value (1.0 = linear, 2.2 = standard sRGB, <1 = brighten darks)
+ * @color-modifier
+ */
+vec3 gamma(vec3 color, float intensity) {
+    return pow(max(color, 0.0), vec3(1.0 / max(intensity, 0.001)));
+}
+
+/**
+ * Tint — blend color toward a target tint.
+ * intensity: 0.0 = original, 1.0 = fully tinted
+ * @color-modifier
+ */
+vec3 tint(vec3 color, vec3 tintColor, float intensity) {
+    return mix(color, color * tintColor, intensity);
+}
+
+/**
+ * Highlights — add white light to bright areas.
+ * Uses max channel brightness so even saturated colors trigger highlights.
+ * intensity = highlight strength (0.2 = subtle sheen, 1.0 = strong gloss)
+ * @color-modifier
+ */
+vec3 highlights(vec3 color, float intensity) {
+    float bright = max(color.r, max(color.g, color.b + 0.3));
+    return color + max(bright * 5.5 - 4.0, 0.0) * intensity;
+}
+
+/**
+ * Bayer 8×8 threshold matrix — computed mathematically.
+ * Returns threshold value 0–1 for ordered dithering.
+ */
+float bayer8(vec2 p) {
+    p = mod(floor(p), 8.0);
+    float value = 0.0;
+    float divisor = 1.0;
+    float multiplier = 16.0;
+
+    for (int i = 0; i < 3; i++) {
+        vec2 q = mod(floor(p / divisor), 2.0);
+        value += (q.x * 2.0 + q.y * 3.0 - q.x * q.y * 4.0) * multiplier;
+        divisor *= 2.0;
+        multiplier *= 0.25;
+    }
+
+    return value / 64.0;
+}
+
+/**
+ * Dither — ordered Bayer 8×8 dithering.
+ * Reduces color to discrete levels with a threshold pattern.
+ * Use pixelate() on UV before coloring for blocky dither cells.
+ * intensity = number of color levels (2 = 1-bit, 4 = retro, 8 = subtle)
+ * @color-modifier
+ */
+vec3 dither(vec3 color, vec2 uv, float intensity) {
+    float levels = max(intensity, 2.0);
+    float threshold = bayer8(uv) - 0.5;
+    float stepSize = 1.0 / (levels - 1.0);
+    color += threshold * stepSize;
+    return clamp(floor(color * (levels - 1.0) + 0.5) / (levels - 1.0), 0.0, 1.0);
+}
+
+/**
+ * Arcade — pixelated Bayer dithering.
+ * Combines pixelation and ordered dither for retro 8-bit look.
+ * intensity = number of color levels (2 = 1-bit, 4 = retro, 8 = subtle)
+ * @color-modifier
+ */
+vec3 arcade(vec3 color, vec2 uv, float intensity) {
+    vec2 grid = uv * u_resolution * 0.5;
+    return dither(color, grid, intensity);
+}
+
+void main() {}
+`, w = new V([
+  new v("sandbox", ae),
+  new v("sandbox/colors", le),
+  new v("sandbox/time", ce),
+  new v("sandbox/effects", ue, {
+    default: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    },
+    pixelate: {
+      intensity: { uniform: "u_intensity", default: 20 }
+    },
+    twist: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    },
+    ripple: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    },
+    fisheye: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    },
+    wobble: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    },
+    organic: {
+      intensity: { uniform: "u_intensity", default: 3 }
+    },
+    glitch: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    },
+    mirror: {
+      intensity: { uniform: "u_intensity", default: 0 }
+    },
+    kaleidoscope: {
+      intensity: { uniform: "u_intensity", default: 6 }
+    },
+    zoom: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    },
+    warp: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    },
+    displace: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    },
+    shatter: {
+      intensity: { uniform: "u_intensity", default: 10 }
+    },
+    cells: {
+      intensity: { uniform: "u_intensity", default: 8 }
+    },
+    glass: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    }
+  }),
+  new v("sandbox/filters", fe, {
+    default: {
+      intensity: { uniform: "u_intensity", default: 1 }
+    },
+    posterize: {
+      intensity: { uniform: "u_intensity", default: 8 }
+    },
+    threshold: {
+      intensity: { uniform: "u_intensity", default: 0.5 }
+    },
+    grain: {
+      intensity: { uniform: "u_intensity", default: 0.1 }
+    },
+    vignette: {
+      intensity: { uniform: "u_intensity", default: 1.4 }
+    },
+    glow: {
+      intensity: { uniform: "u_intensity", default: 0.5 }
+    },
+    gamma: {
+      intensity: { uniform: "u_intensity", default: 2.2 }
+    },
+    dither: {
+      intensity: { uniform: "u_intensity", default: 4 }
+    },
+    highlights: {
+      intensity: { uniform: "u_intensity", default: 0.5 }
+    }
+  })
+]), y = new V(), R = /* @__PURE__ */ new Map([
+  ["u_resolution", "vec2"],
+  ["u_time", "float"],
+  ["u_delta", "float"],
+  ["u_mouse", "vec2"],
+  ["u_frame", "int"]
+]);
+class he {
+  constructor(e) {
+    o(this, "gl");
+    o(this, "program", null);
+    o(this, "uniforms", /* @__PURE__ */ new Map());
+    this.gl = e;
+  }
+  /**
+   * Attach to a WebGL program.
+   * Invalidates all cached locations since they're program-specific.
+   */
+  attachProgram(e) {
+    this.program = e;
+    for (const t of this.uniforms.values())
+      t.invalidateLocation();
+    return this;
+  }
+  /**
+   * Set a uniform value.
+   * Creates the uniform if it doesn't exist, updates if it does.
+   */
+  set(e, t) {
+    const n = this.uniforms.get(e);
+    return n ? n.setValue(t) : this.uniforms.set(e, new M(e, t)), this;
+  }
+  /**
+   * Set multiple uniforms at once.
+   */
+  setMany(e) {
+    for (const [t, n] of Object.entries(e))
+      this.set(t, n);
+    return this;
+  }
+  /**
+   * Get current uniform value.
+   */
+  get(e) {
+    var t;
+    return (t = this.uniforms.get(e)) == null ? void 0 : t.getValue();
+  }
+  /**
+   * Check if uniform exists.
+   */
+  has(e) {
+    return this.uniforms.has(e);
+  }
+  /**
+   * Remove a uniform.
+   */
+  delete(e) {
+    return this.uniforms.delete(e);
+  }
+  /**
+   * Upload all uniforms to GPU.
+   * Requires a program to be attached.
    */
-  getVersion() {
-    return this.version;
+  uploadAll() {
+    if (!this.program)
+      return this;
+    for (const e of this.uniforms.values())
+      e.upload(this.gl, this.program);
+    return this;
   }
   /**
-   * Get attribute location.
+   * Upload only built-in uniforms (u_resolution, u_time, u_delta, u_mouse, u_frame).
+   * Call this every frame with current values.
    */
-  getAttribLocation(t) {
-    return this.program ? this.gl.getAttribLocation(this.program, t) : -1;
+  uploadBuiltIns(e, t, n) {
+    if (this.set("u_resolution", t), this.set("u_time", e.time), this.set("u_delta", e.delta), this.set("u_mouse", n), this.set("u_frame", e.frame), !this.program)
+      return this;
+    for (const i of R.keys()) {
+      const r = this.uniforms.get(i);
+      r && r.upload(this.gl, this.program);
+    }
+    return this;
   }
   /**
-   * Get uniform location.
+   * Clear all uniforms.
    */
-  getUniformLocation(t) {
-    return this.program ? this.gl.getUniformLocation(this.program, t) : null;
+  clear() {
+    this.uniforms.clear();
   }
   /**
-   * Cleanup all GPU resources.
+   * Cleanup.
    */
   destroy() {
-    const t = this.gl;
-    this.program && (this.vertexShader && t.detachShader(this.program, this.vertexShader), this.fragmentShader && t.detachShader(this.program, this.fragmentShader), t.deleteProgram(this.program), this.program = null), this.vertexShader && (t.deleteShader(this.vertexShader), this.vertexShader = null), this.fragmentShader && (t.deleteShader(this.fragmentShader), this.fragmentShader = null);
+    this.uniforms.clear(), this.program = null;
   }
   /**
-   * Compile a single shader.
-   * @throws ShaderCompilationError if compilation fails
+   * Get all uniform names.
    */
-  compileShader(t, e) {
-    const i = this.gl, s = t === "vertex" ? i.VERTEX_SHADER : i.FRAGMENT_SHADER, n = i.createShader(s);
-    if (!n)
-      throw new c(
-        t,
-        e,
-        "Failed to create shader object"
-      );
-    if (i.shaderSource(n, e), i.compileShader(n), !i.getShaderParameter(n, i.COMPILE_STATUS)) {
-      const f = i.getShaderInfoLog(n) || "Unknown error";
-      throw i.deleteShader(n), new c(t, e, f);
-    }
-    return n;
+  keys() {
+    return this.uniforms.keys();
   }
   /**
-   * Link vertex and fragment shaders into a program.
-   * @throws ProgramLinkError if linking fails
+   * Get uniform count.
    */
-  linkProgram() {
-    const t = this.gl;
-    if (!this.vertexShader || !this.fragmentShader)
-      throw new m("Shaders not compiled");
-    const e = t.createProgram();
-    if (!e)
-      throw new m("Failed to create program object");
-    if (t.attachShader(e, this.vertexShader), t.attachShader(e, this.fragmentShader), t.linkProgram(e), !t.getProgramParameter(e, t.LINK_STATUS)) {
-      const s = t.getProgramInfoLog(e) || "Unknown error";
-      throw t.deleteProgram(e), new m(s);
-    }
-    this.program = e;
+  get size() {
+    return this.uniforms.size;
   }
 }
 class x {
-  constructor(t, e) {
-    r(this, "name");
-    r(this, "method");
-    r(this, "isArray");
-    r(this, "isMatrix");
-    r(this, "location", null);
-    r(this, "locationResolved", !1);
-    r(this, "value");
-    this.name = t, this.value = e;
-    const i = x.inferMethodInfo(e);
-    this.method = i.method, this.isArray = i.isArray, this.isMatrix = i.isMatrix;
+  constructor(e, t, n, i) {
+    o(this, "name");
+    o(this, "gl");
+    o(this, "texture", null);
+    o(this, "location", null);
+    o(this, "locationResolved", !1);
+    o(this, "source");
+    o(this, "options");
+    o(this, "dynamicOverride");
+    o(this, "needsUpload", !0);
+    o(this, "needsReupload", !1);
+    this.gl = e, this.name = t, this.source = n, this.dynamicOverride = i == null ? void 0 : i.dynamic, this.options = x.resolveOptions(n, i), this.needsReupload = this.options.dynamic;
   }
   /**
-   * Infer WebGL method and metadata from value type.
+   * Update the texture source.
+   * Marks texture for re-upload on next bind.
+   * Respects the original `dynamic` option if explicitly set, otherwise re-infers from source type.
    */
-  static inferMethodInfo(t) {
-    if (typeof t == "boolean")
-      return { method: "uniform1i", isArray: !1, isMatrix: !1 };
-    if (typeof t == "number")
-      return { method: "uniform1f", isArray: !1, isMatrix: !1 };
-    if (!Array.isArray(t))
-      return { method: "uniform1f", isArray: !1, isMatrix: !1 };
-    const e = t.length, i = t[0];
-    if (Array.isArray(i))
-      switch (i.length) {
-        case 2:
-          return { method: "uniform2fv", isArray: !0, isMatrix: !1 };
-        case 3:
-          return { method: "uniform3fv", isArray: !0, isMatrix: !1 };
-        case 4:
-          return { method: "uniform4fv", isArray: !0, isMatrix: !1 };
-        default:
-          return { method: "uniform1fv", isArray: !0, isMatrix: !1 };
-      }
-    switch (e) {
-      case 2:
-        return { method: "uniform2fv", isArray: !1, isMatrix: !1 };
-      case 3:
-        return { method: "uniform3fv", isArray: !1, isMatrix: !1 };
-      case 4:
-        return { method: "uniform4fv", isArray: !1, isMatrix: !1 };
-      case 9:
-        return { method: "uniformMatrix3fv", isArray: !1, isMatrix: !0 };
-      case 16:
-        return { method: "uniformMatrix4fv", isArray: !1, isMatrix: !0 };
-      default:
-        return { method: "uniform1fv", isArray: !0, isMatrix: !1 };
-    }
+  setSource(e) {
+    this.source = e, this.needsUpload = !0, this.needsReupload = this.dynamicOverride ?? x.isDynamicSource(e);
   }
   /**
    * Resolve and cache uniform location from program.
-   * Returns null if uniform doesn't exist (optimized out by compiler, etc.)
+   * Returns null if the sampler uniform doesn't exist in the shader.
    */
-  resolveLocation(t, e) {
-    return this.locationResolved || (this.location = t.getUniformLocation(e, this.name), this.locationResolved = !0), this.location;
+  resolveLocation(e, t) {
+    return this.locationResolved || (this.location = e.getUniformLocation(t, this.name), this.locationResolved = !0), this.location;
   }
   /**
    * Invalidate cached location (call when program changes).
@@ -479,219 +2471,226 @@ class x {
     this.location = null, this.locationResolved = !1;
   }
   /**
-   * Update value (doesn't upload to GPU until upload() is called).
-   */
-  setValue(t) {
-    this.value = t;
+   * Bind texture to a texture unit and set the sampler uniform.
+   * @param program - Current WebGL program (for location resolution)
+   * @param unit - Texture unit index (0, 1, 2, ...)
+   */
+  upload(e, t) {
+    const n = this.gl, i = this.resolveLocation(n, e);
+    if (i !== null) {
+      if (!this.texture) {
+        if (this.texture = n.createTexture(), !this.texture) return;
+        this.needsUpload = !0;
+      }
+      n.activeTexture(n.TEXTURE0 + t), n.bindTexture(n.TEXTURE_2D, this.texture), (this.needsUpload || this.needsReupload) && (this.uploadPixels(), this.needsUpload = !1), n.uniform1i(i, t);
+    }
   }
   /**
-   * Get current value.
+   * Cleanup WebGL texture resource.
    */
-  getValue() {
-    return this.value;
+  destroy() {
+    this.texture && (this.gl.deleteTexture(this.texture), this.texture = null), this.location = null, this.locationResolved = !1;
   }
   /**
-   * Upload current value to GPU.
-   * @param gl - WebGL context
-   * @param program - Current WebGL program (for location resolution)
+   * Upload pixel data from source and apply texture parameters.
    */
-  upload(t, e) {
-    const i = this.resolveLocation(t, e);
-    if (i === null)
-      return;
-    const s = this.value;
-    let n;
-    switch (typeof s == "boolean" ? n = s ? 1 : 0 : typeof s == "number" ? n = s : this.isArray && Array.isArray(s[0]) ? n = new Float32Array(
-      s.flat()
-    ) : n = new Float32Array(s), this.method) {
-      case "uniform1f":
-        t.uniform1f(i, n);
-        break;
-      case "uniform1i":
-        t.uniform1i(i, n);
-        break;
-      case "uniform1fv":
-        t.uniform1fv(i, n);
-        break;
-      case "uniform2fv":
-        t.uniform2fv(i, n);
-        break;
-      case "uniform3fv":
-        t.uniform3fv(i, n);
-        break;
-      case "uniform4fv":
-        t.uniform4fv(i, n);
-        break;
-      case "uniformMatrix2fv":
-        t.uniformMatrix2fv(i, !1, n);
-        break;
-      case "uniformMatrix3fv":
-        t.uniformMatrix3fv(i, !1, n);
-        break;
-      case "uniformMatrix4fv":
-        t.uniformMatrix4fv(i, !1, n);
-        break;
-    }
-  }
-}
-const d = class d {
-  constructor(t) {
-    r(this, "gl");
-    r(this, "program", null);
-    r(this, "uniforms", /* @__PURE__ */ new Map());
-    this.gl = t;
+  uploadPixels() {
+    const e = this.gl;
+    e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL, this.options.flipY), e.texImage2D(
+      e.TEXTURE_2D,
+      0,
+      e.RGBA,
+      e.RGBA,
+      e.UNSIGNED_BYTE,
+      this.source
+    ), this.applyParameters();
   }
   /**
-   * Attach to a WebGL program.
-   * Invalidates all cached locations since they're program-specific.
+   * Apply texture wrap and filter parameters.
    */
-  attachProgram(t) {
-    this.program = t;
-    for (const e of this.uniforms.values())
-      e.invalidateLocation();
-    return this;
+  applyParameters() {
+    const e = this.gl;
+    e.texParameteri(
+      e.TEXTURE_2D,
+      e.TEXTURE_WRAP_S,
+      x.resolveWrap(e, this.options.wrapS)
+    ), e.texParameteri(
+      e.TEXTURE_2D,
+      e.TEXTURE_WRAP_T,
+      x.resolveWrap(e, this.options.wrapT)
+    ), e.texParameteri(
+      e.TEXTURE_2D,
+      e.TEXTURE_MIN_FILTER,
+      this.options.minFilter === "nearest" ? e.NEAREST : e.LINEAR
+    ), e.texParameteri(
+      e.TEXTURE_2D,
+      e.TEXTURE_MAG_FILTER,
+      this.options.magFilter === "nearest" ? e.NEAREST : e.LINEAR
+    );
   }
   /**
-   * Set a uniform value.
-   * Creates the uniform if it doesn't exist, updates if it does.
+   * Resolve wrap mode string to WebGL constant.
    */
-  set(t, e) {
-    const i = this.uniforms.get(t);
-    return i ? i.setValue(e) : this.uniforms.set(t, new x(t, e)), this;
+  static resolveWrap(e, t) {
+    switch (t) {
+      case "repeat":
+        return e.REPEAT;
+      case "mirror":
+        return e.MIRRORED_REPEAT;
+      case "clamp":
+      default:
+        return e.CLAMP_TO_EDGE;
+    }
   }
   /**
-   * Set multiple uniforms at once.
+   * Resolve texture options with defaults.
    */
-  setMany(t) {
-    for (const [e, i] of Object.entries(t))
-      this.set(e, i);
-    return this;
+  static resolveOptions(e, t) {
+    const n = (t == null ? void 0 : t.wrap) ?? "clamp";
+    return {
+      wrap: n,
+      wrapS: (t == null ? void 0 : t.wrapS) ?? n,
+      wrapT: (t == null ? void 0 : t.wrapT) ?? n,
+      minFilter: (t == null ? void 0 : t.minFilter) ?? "linear",
+      magFilter: (t == null ? void 0 : t.magFilter) ?? "linear",
+      flipY: (t == null ? void 0 : t.flipY) ?? !0,
+      dynamic: (t == null ? void 0 : t.dynamic) ?? x.isDynamicSource(e)
+    };
   }
   /**
-   * Get current uniform value.
+   * Check if a source is dynamic (needs re-upload every frame).
    */
-  get(t) {
-    var e;
-    return (e = this.uniforms.get(t)) == null ? void 0 : e.getValue();
+  static isDynamicSource(e) {
+    return e instanceof HTMLVideoElement;
+  }
+}
+class me {
+  constructor(e) {
+    o(this, "gl");
+    o(this, "program", null);
+    o(this, "textures", /* @__PURE__ */ new Map());
+    this.gl = e;
   }
   /**
-   * Check if uniform exists.
+   * Attach to a WebGL program.
+   * Invalidates all cached locations since they're program-specific.
    */
-  has(t) {
-    return this.uniforms.has(t);
+  attachProgram(e) {
+    this.program = e;
+    for (const t of this.textures.values())
+      t.invalidateLocation();
+    return this;
   }
   /**
-   * Remove a uniform.
+   * Set a texture.
+   * Creates the texture entry if it doesn't exist, updates source if it does.
    */
-  delete(t) {
-    return this.uniforms.delete(t);
+  set(e, t, n) {
+    const i = this.textures.get(e);
+    return i ? i.setSource(t) : this.textures.set(e, new x(this.gl, e, t, n)), this;
   }
   /**
-   * Upload all uniforms to GPU.
-   * Requires a program to be attached.
+   * Get a texture by name.
    */
-  uploadAll() {
-    if (!this.program)
-      return this;
-    for (const t of this.uniforms.values())
-      t.upload(this.gl, this.program);
-    return this;
+  get(e) {
+    return this.textures.get(e);
   }
   /**
-   * Upload only built-in uniforms (u_resolution, u_time, u_delta, u_mouse, u_frame).
-   * Call this every frame with current values.
+   * Check if a texture exists.
    */
-  uploadBuiltIns(t, e, i) {
-    if (this.set("u_resolution", e), this.set("u_time", t.time), this.set("u_delta", t.delta), this.set("u_mouse", i), this.set("u_frame", t.frame), !this.program)
-      return this;
-    for (const s of d.BUILT_INS) {
-      const n = this.uniforms.get(s);
-      n && n.upload(this.gl, this.program);
-    }
-    return this;
+  has(e) {
+    return this.textures.has(e);
   }
   /**
-   * Clear all uniforms.
+   * Remove a texture and free its GPU resources.
    */
-  clear() {
-    this.uniforms.clear();
+  delete(e) {
+    const t = this.textures.get(e);
+    return t ? (t.destroy(), this.textures.delete(e)) : !1;
   }
   /**
-   * Cleanup.
+   * Upload all textures to their respective texture units.
+   * Units are assigned sequentially (0, 1, 2, ...).
    */
-  destroy() {
-    this.uniforms.clear(), this.program = null;
+  uploadAll() {
+    if (!this.program)
+      return this;
+    let e = 0;
+    for (const t of this.textures.values())
+      t.upload(this.program, e), e++;
+    return this;
   }
   /**
-   * Get all uniform names.
+   * Get texture count.
    */
-  keys() {
-    return this.uniforms.keys();
+  get size() {
+    return this.textures.size;
   }
   /**
-   * Get uniform count.
+   * Cleanup all textures.
    */
-  get size() {
-    return this.uniforms.size;
+  destroy() {
+    for (const e of this.textures.values())
+      e.destroy();
+    this.textures.clear(), this.program = null;
   }
-};
-/** Built-in uniform names that are handled automatically */
-r(d, "BUILT_INS", /* @__PURE__ */ new Set([
-  "u_resolution",
-  "u_time",
-  "u_delta",
-  "u_mouse",
-  "u_frame"
-]));
-let v = d;
-class b {
+}
+class L {
   constructor() {
-    r(this, "hooks", /* @__PURE__ */ new Map());
+    o(this, "hooks", /* @__PURE__ */ new Map());
   }
   id() {
     return Math.random().toString(36).substring(2, 10);
   }
   /** Add a new hook, returns a removal function */
-  add(t) {
-    const e = this.id();
-    return this.hooks.set(e, t), () => this.remove(e);
+  add(e) {
+    const t = this.id();
+    return this.hooks.set(t, e), () => this.remove(t);
   }
   /** Remove a hook by its ID */
-  remove(t) {
-    this.hooks.delete(t);
+  remove(e) {
+    this.hooks.delete(e);
   }
   /** Run all hooks with the given state */
-  run(t) {
-    for (const [e, i] of this.hooks)
-      i(t) === !1 && this.remove(e);
+  run(e) {
+    for (const [t, n] of this.hooks)
+      try {
+        n(e) === !1 && this.remove(t);
+      } catch (i) {
+        throw new re(
+          t,
+          i instanceof Error ? i.message : String(i)
+        );
+      }
   }
   destroy() {
     this.hooks.clear();
   }
 }
-class _ {
-  constructor(t, e) {
-    r(this, "canvas");
-    r(this, "gl");
-    r(this, "options");
-    r(this, "onBeforeHooks", new b());
-    r(this, "onAfterHooks", new b());
-    r(this, "_program");
-    r(this, "_geometry");
-    r(this, "_uniforms");
-    r(this, "_clock");
-    r(this, "_resolution", [1, 1]);
-    r(this, "_mouse", [0, 0]);
-    r(this, "_version", 1);
-    r(this, "playing", !1);
-    this.canvas = t, this.options = e, this.gl = this.initContext(), this.enableExtensions(), this._program = new a(this.gl), this._geometry = p.fullscreenQuad(this.gl), this._uniforms = new v(this.gl), this._clock = new R(), this.options.fps && this._clock.setMaxFps(this.options.fps), this.options.onBeforeRender && this.onBeforeHooks.add(this.options.onBeforeRender), this.options.onAfterRender && this.onAfterHooks.add(this.options.onAfterRender), this.onRender = this.onRender.bind(this);
+class T {
+  constructor(e, t) {
+    o(this, "canvas");
+    o(this, "gl");
+    o(this, "options");
+    o(this, "onBeforeHooks", new L());
+    o(this, "onAfterHooks", new L());
+    o(this, "_program");
+    o(this, "_geometry");
+    o(this, "_uniforms");
+    o(this, "_textures");
+    o(this, "_clock");
+    o(this, "_resolution", [1, 1]);
+    o(this, "_mouse", [0, 0]);
+    o(this, "_version", 1);
+    o(this, "playing", !1);
+    this.canvas = e, this.options = t, this.gl = this.initContext(), this.enableExtensions(), this._program = new oe(this.gl), this._geometry = k.fullscreenQuad(this.gl), this._uniforms = new he(this.gl), this._textures = new me(this.gl), this._clock = new se(), this.options.fps && this._clock.setMaxFps(this.options.fps), this.options.onBeforeRender && this.onBeforeHooks.add(this.options.onBeforeRender), this.options.onAfterRender && this.onAfterHooks.add(this.options.onAfterRender), this.onRender = this.onRender.bind(this);
   }
   /**
    * Factory method to create and setup WebGL instance.
    */
-  static setup(t, e) {
-    const i = new _(t, e);
-    return e.vertex && e.fragment && i.shader(e.vertex, e.fragment), e.uniforms && i._uniforms.setMany(e.uniforms), i;
+  static setup(e, t) {
+    const n = new T(e, t);
+    return t.vertex && t.fragment && n.shader(t.vertex, t.fragment), t.uniforms && n._uniforms.setMany(t.uniforms), t.textures && n.texturesFromSchema(t.textures), y.isEmpty() || n._uniforms.setMany(y.defaults()), n;
   }
   /**
    * Initialize WebGL context.
@@ -699,20 +2698,20 @@ class _ {
    * Context errors are fatal but still reported via onError.
    */
   initContext() {
-    const t = {
+    const e = {
       antialias: this.options.antialias,
       preserveDrawingBuffer: this.options.preserveDrawingBuffer,
       alpha: !0,
       depth: !1,
       stencil: !1
-    }, e = this.canvas.getContext("webgl2", t);
-    if (e)
-      return this._version = 2, e;
-    const i = this.canvas.getContext("webgl", t);
-    if (i)
-      return this._version = 1, i;
-    const s = new w("not_supported");
-    throw this.options.onError(s), s;
+    }, t = this.canvas.getContext("webgl2", e);
+    if (t)
+      return this._version = 2, t;
+    const n = this.canvas.getContext("webgl", e);
+    if (n)
+      return this._version = 1, n;
+    const i = new W();
+    throw this.options.onError(i), i;
   }
   /**
    * Enable useful WebGL extensions.
@@ -723,50 +2722,87 @@ class _ {
   /**
    * Set viewport dimensions.
    */
-  viewport(t, e, i, s) {
-    return this.canvas.width = i, this.canvas.height = s, this.gl.viewport(t, e, i, s), this._resolution = [i, s], this;
+  viewport(e, t, n, i) {
+    return this.canvas.width = n, this.canvas.height = i, this.gl.viewport(e, t, n, i), this._resolution = [n, i], this;
   }
   /**
    * Set the clock time
    */
-  clock(t) {
-    return this._clock.setTime(t), this;
+  clock(e) {
+    return this._clock.setTime(e), this;
   }
   /**
    * Update mouse position.
    */
-  mouse(t, e) {
-    return this._mouse = [t, e], this;
+  mouse(e, t) {
+    return this._mouse = [e, t], this;
   }
   /**
    * Set a uniform value.
    */
-  uniform(t, e) {
-    return this._uniforms.set(t, e), this;
+  uniform(e, t) {
+    return this._uniforms.set(e, t), this;
   }
   /**
    * Set multiple uniforms.
    */
-  uniforms(t) {
-    return this._uniforms.setMany(t), this;
+  uniforms(e) {
+    return this._uniforms.setMany(e), this;
   }
   /**
    * Get current uniform value.
    */
-  getUniform(t) {
-    return this._uniforms.get(t);
+  getUniform(e) {
+    return this._uniforms.get(e);
+  }
+  /**
+   * Set a texture.
+   */
+  texture(e, t, n) {
+    return this._textures.set(e, t, n), this;
+  }
+  /**
+   * Set multiple textures from a schema.
+   */
+  texturesFromSchema(e) {
+    for (const [t, n] of Object.entries(e))
+      if (n instanceof HTMLImageElement || n instanceof HTMLCanvasElement || n instanceof HTMLVideoElement || n instanceof ImageBitmap || n instanceof ImageData || n instanceof OffscreenCanvas)
+        this._textures.set(t, n);
+      else {
+        const { source: i, ...r } = n;
+        this._textures.set(t, i, r);
+      }
+    return this;
+  }
+  /**
+   * Remove a texture.
+   */
+  removeTexture(e) {
+    return this._textures.delete(e), this;
   }
   /**
    * Compile and link shaders.
    * Errors are handled via onError callback, never thrown.
    */
-  shader(t, e) {
+  shader(e, t) {
     try {
-      this._program.compile(t, e), this._version = this._program.getVersion(), this._geometry.linkAttributes(this._program);
-      const i = this._program.getProgram();
-      i && this._uniforms.attachProgram(i), this.options.onLoad();
-    } catch (i) {
-      i instanceof u && this.options.onError(i);
+      if (y.clear(), e.version() !== t.version())
+        throw new z(
+          e.version(),
+          t.version()
+        );
+      this._program.compile(e.source(), t.compile()), this._version = t.version(), this._geometry.linkAttributes(this._program);
+      const n = this._program.getProgram();
+      n && (this._uniforms.attachProgram(n), this._textures.attachProgram(n));
+      try {
+        this.options.onLoad();
+      } catch (i) {
+        throw new ie(
+          i instanceof Error ? i.message : String(i)
+        );
+      }
+    } catch (n) {
+      n instanceof h && this.options.onError(n);
     }
     return this;
   }
@@ -781,8 +2817,19 @@ class _ {
    */
   pause() {
     if (!this.playing) return this;
-    const t = this._clock.getState();
-    return this.onBeforeHooks.run(t), this.playing = !1, this._clock.stop(), this.onAfterHooks.run(t), this;
+    const e = this._clock.getState();
+    try {
+      this.onBeforeHooks.run(e);
+    } catch (t) {
+      t instanceof h && this.options.onError(t);
+    }
+    this.playing = !1, this._clock.stop();
+    try {
+      this.onAfterHooks.run(e);
+    } catch (t) {
+      t instanceof h && this.options.onError(t);
+    }
+    return this;
   }
   /**
    * Render a single frame.
@@ -812,17 +2859,34 @@ class _ {
    * Cleanup all resources.
    */
   destroy() {
-    this.pause(), this._clock.destroy(), this._geometry.destroy(), this._program.destroy(), this._uniforms.destroy(), this.onAfterHooks.destroy(), this.onBeforeHooks.destroy();
+    this.pause(), this._clock.destroy(), this._geometry.destroy(), this._program.destroy(), this._uniforms.destroy(), this._textures.destroy(), this.onAfterHooks.destroy(), this.onBeforeHooks.destroy(), y.clear();
   }
   /**
    * Internal render callback.
    */
-  onRender(t) {
-    const e = this.gl;
-    this.onBeforeHooks.run(t), e.clearColor(0, 0, 0, 0), e.clear(e.COLOR_BUFFER_BIT), this._program.use(), this._uniforms.uploadBuiltIns(t, this._resolution, this._mouse), this._uniforms.uploadAll(), this._geometry.bind(), this._geometry.draw(), this.onAfterHooks.run(t);
+  onRender(e) {
+    const t = this.gl;
+    try {
+      this.onBeforeHooks.run(e);
+    } catch (n) {
+      n instanceof h && this.options.onError(n);
+    }
+    t.clearColor(0, 0, 0, 0), t.clear(t.COLOR_BUFFER_BIT), this._program.use(), this._uniforms.uploadBuiltIns(e, this._resolution, this._mouse), this._uniforms.uploadAll(), this._textures.uploadAll(), this._geometry.bind(), this._geometry.draw();
+    try {
+      this.onAfterHooks.run(e);
+    } catch (n) {
+      n instanceof h && this.options.onError(n);
+    }
   }
 }
-const g = `#ifdef GL_ES
+class d extends F {
+  constructor(e) {
+    super(e), R.forEach((t, n) => {
+      this.requirements.uniforms.set(n, { name: n, type: t, line: 0 });
+    });
+  }
+}
+const A = `#ifdef GL_ES
 precision mediump float;
 #endif
 
@@ -835,7 +2899,7 @@ void main() {
   v_texcoord = a_texcoord;
   gl_Position = vec4(a_position, 0.0, 1.0);
 }
-`, A = `#ifdef GL_ES
+`, O = `#ifdef GL_ES
 precision mediump float;
 #endif
 
@@ -849,7 +2913,7 @@ void main() {
   vec3 color = vec3(uv.x, uv.y, 0.5 + 0.5 * sin(u_time));
   gl_FragColor = vec4(color, 1.0);
 }
-`, E = `#version 300 es
+`, C = `#version 300 es
 
 in vec2 a_position;
 in vec2 a_texcoord;
@@ -859,7 +2923,7 @@ out vec2 v_texcoord;
 void main() {
     v_texcoord = a_texcoord;
     gl_Position = vec4(a_position, 0.0, 1.0);
-}`, V = `#version 300 es
+}`, de = `#version 300 es
 precision highp float;
 
 uniform vec2 u_resolution;
@@ -874,19 +2938,22 @@ void main() {
     vec3 color = vec3(uv.x, uv.y, 0.5 + 0.5 * sin(u_time));
     fragColor = vec4(color, 1.0);
 }`;
-class y {
-  constructor(t, e) {
+class I {
+  constructor(e, t) {
     /** Active event listeners */
-    r(this, "listeners", []);
+    o(this, "listeners", []);
     /** HTML canvas element */
-    r(this, "canvasEl");
+    o(this, "canvasEl");
     /** Resolved options */
-    r(this, "options");
+    o(this, "options");
     /** WebGL engine */
-    r(this, "engine");
+    o(this, "engine");
     /** User sets custom vertex shader */
-    r(this, "usingCustomVertex", !1);
-    this.canvasEl = t, this.options = this.resolveOptions(e), this.engine = _.setup(this.canvasEl, this.options), this.setupListeners(), this.setViewport(), this.options.autoplay && this.play();
+    o(this, "usingCustomVertex", !1);
+    if (this.canvasEl = e, this.options = this.resolveOptions(t), this.engine = T.setup(this.canvasEl, this.options), this.setupListeners(), this.setViewport(), this.options.modules)
+      for (const [n, i] of Object.entries(this.options.modules))
+        this.module(n, i);
+    this.options.autoplay && this.play();
   }
   /**
    * Sandbox - A lightweight WebGL wrapper for shader effects.
@@ -906,23 +2973,49 @@ class y {
    *   autoplay: true,
    * });
    */
-  static create(t, e) {
-    return new y(t, e);
+  static create(e, t) {
+    return new I(e, t);
   }
-  resolveOptions(t) {
-    const e = {
-      vertex: g,
-      fragment: A,
+  /**
+   * Define a shader module that can be imported in shader source with `#import <function> from "module_name"`.
+   * @example
+   * Sandbox.defineModule("my_module", source, { options });
+   * // Then in shader:
+   * // #import myFunc from "my_module"
+   * // void main() {
+   * //   myFunc();
+   * // }
+   */
+  static defineModule(e, t, n = {}) {
+    v.define({ name: e, source: t, options: n });
+  }
+  /**
+   * Get the list of available shader modules that can be used with `#import` in shader source.
+   */
+  static availableModules() {
+    return w.available();
+  }
+  /**
+   * Compile a shader source with Sandbox's shader preprocessor and return the final GLSL code.
+   * This is useful for debugging shader code or precompiling shaders for production use.
+   */
+  static compile(e) {
+    return new d(e).compile();
+  }
+  resolveOptions(e) {
+    const t = {
+      vertex: new d(A),
+      fragment: new d(O),
       autoplay: !0,
       pauseWhenHidden: !0,
       dpr: "auto",
       fps: 0,
       preserveDrawingBuffer: !1,
       antialias: !0,
-      onError: (i) => {
+      onError: (s) => {
         console.error(
           "Oops!",
-          i,
+          s,
           `
 You can handle errors programmatically by providing an onError callback to suppress this log and implement custom fallback behavior.`
         );
@@ -931,64 +3024,70 @@ You can handle errors programmatically by providing an onError callback to suppr
       },
       onBeforeRender: null,
       onAfterRender: null,
-      uniforms: {}
+      uniforms: {},
+      modules: {},
+      textures: {}
     };
-    if (t != null && t.vertex && (this.usingCustomVertex = !0), t != null && t.vertex && !(t != null && t.fragment)) {
-      const i = a.detectVersion(t.vertex);
-      e.vertex = t.vertex, e.fragment = i === 2 ? V : A;
+    if (e != null && e.vertex && (this.usingCustomVertex = !0), e != null && e.vertex && !(e != null && e.fragment)) {
+      t.vertex = new d(e.vertex);
+      const s = t.vertex.version();
+      t.fragment = new d(s === 2 ? de : O);
     }
-    if (t != null && t.fragment && !(t != null && t.vertex)) {
-      const i = a.detectVersion(t.fragment);
-      e.fragment = t.fragment, e.vertex = i === 2 ? E : g;
+    if (e != null && e.fragment && !(e != null && e.vertex)) {
+      t.fragment = new d(e.fragment);
+      const s = t.fragment.version();
+      t.vertex = new d(s === 2 ? C : A);
     }
-    return { ...e, ...t };
+    e != null && e.vertex && (e != null && e.fragment) && (t.vertex = new d(e.vertex), t.fragment = new d(e.fragment));
+    const { vertex: n, fragment: i, ...r } = e || {};
+    return { ...t, ...r };
   }
   setupListeners() {
     this.listeners.push(
       // Window resize
-      l.on(window, "resize", () => {
+      b.on(window, "resize", () => {
         this.setViewport();
       }),
       // Canvas resize
-      l.on(this.canvasEl, "resize", () => {
+      b.on(this.canvasEl, "resize", () => {
         this.setViewport();
       }),
       // Visibility check on scroll
       (() => {
-        let t = !1;
-        return l.on(document, "scroll", (e) => {
-          this.options.pauseWhenHidden && (this.isInViewport() ? t && !this.isPlaying() && (this.play(), t = !1) : this.isPlaying() && (this.pause(), t = !0));
+        let e = !1;
+        return b.on(document, "scroll", (t) => {
+          this.options.pauseWhenHidden && (this.isInViewport() ? e && !this.isPlaying() && (this.play(), e = !1) : this.isPlaying() && (this.pause(), e = !0));
         });
       })(),
       // Mouse tracking
-      l.on(document, "mousemove", (t) => {
-        this.setMouse(t.clientX || t.pageX, t.clientY || t.pageY);
+      b.on(document, "mousemove", (e) => {
+        this.setMouse(e.clientX || e.pageX, e.clientY || e.pageY);
       }),
       // Touch tracking
-      l.on(document, "touchmove", (t) => {
-        t.touches.length > 0 && this.setMouse(t.touches[0].clientX, t.touches[0].clientY);
+      b.on(document, "touchmove", (e) => {
+        e.touches.length > 0 && this.setMouse(e.touches[0].clientX, e.touches[0].clientY);
       })
     );
   }
   destroyListeners() {
-    this.listeners.forEach((t) => t()), this.listeners = [];
+    this.listeners.forEach((e) => e()), this.listeners = [];
   }
   setViewport() {
-    const t = this.options.dpr === "auto" ? Math.min(2, window.devicePixelRatio || 1) : this.options.dpr, e = this.canvasEl.clientWidth || this.canvasEl.width || 1, i = this.canvasEl.clientHeight || this.canvasEl.height || 1;
+    const e = this.options.dpr === "auto" ? Math.min(2, window.devicePixelRatio || 1) : this.options.dpr, t = this.canvasEl.clientWidth || this.canvasEl.width || 1, n = this.canvasEl.clientHeight || this.canvasEl.height || 1;
     this.engine.viewport(
       0,
       0,
-      Math.max(1, Math.floor(e * t)),
-      Math.max(1, Math.floor(i * t))
+      Math.max(1, Math.floor(t * e)),
+      Math.max(1, Math.floor(n * e))
     );
   }
   isInViewport() {
-    const t = this.canvasEl.getBoundingClientRect();
-    return t.bottom >= 0 && t.right >= 0 && t.top <= (window.innerHeight || document.documentElement.clientHeight) && t.left <= (window.innerWidth || document.documentElement.clientWidth);
+    const e = this.canvasEl.getBoundingClientRect();
+    return e.bottom >= 0 && e.right >= 0 && e.top <= (window.innerHeight || document.documentElement.clientHeight) && e.left <= (window.innerWidth || document.documentElement.clientWidth);
   }
-  setMouse(t, e) {
-    const i = this.canvasEl.getBoundingClientRect();
-    t >= i.left && t <= i.right && e >= i.top && e <= i.bottom && this.engine.mouse(t - i.left, e - i.top);
+  setMouse(e, t) {
+    const n = this.canvasEl.getBoundingClientRect();
+    e >= n.left && e <= n.right && t >= n.top && t <= n.bottom && this.engine.mouse(e - n.left, t - n.top);
   }
   /**
    * Set a single uniform value with type checking.
@@ -997,8 +3096,8 @@ You can handle errors programmatically by providing an onError callback to suppr
    * sandbox.setUniform<number>("u_time", 1.5);
    * sandbox.setUniform<Vec3[]>("u_colors", [[1, 0, 0], [0, 1, 0]]);
    */
-  setUniform(t, e) {
-    return this.engine.uniform(t, e), this;
+  setUniform(e, t) {
+    return this.engine.uniform(e, t), this;
   }
   /**
    * Set multiple uniforms at once with type checking.
@@ -1014,47 +3113,112 @@ You can handle errors programmatically by providing an onError callback to suppr
    *   u_colors: [[1, 0, 0], [0, 1, 0]],
    * });
    */
-  setUniforms(t) {
-    return this.engine.uniforms(t), this;
+  setUniforms(e) {
+    return this.engine.uniforms(e), this;
   }
   /**
    * Get current uniform value.
    */
-  getUniform(t) {
-    return this.engine.getUniform(t);
+  getUniform(e) {
+    return this.engine.getUniform(e);
+  }
+  /**
+   * Set a texture for a sampler2D uniform.
+   * @example
+   * sandbox.setTexture("u_texture", imageElement);
+   * sandbox.setTexture("u_texture", imageElement, { wrap: "repeat" });
+   */
+  setTexture(e, t, n) {
+    return this.engine.texture(e, t, n), this;
+  }
+  /**
+   * Set multiple textures at once.
+   * @example
+   * sandbox.setTextures({
+   *   u_texture: imageElement,
+   *   u_detail: { source: detailImg, wrap: "repeat" },
+   * });
+   */
+  setTextures(e) {
+    return this.engine.texturesFromSchema(e), this;
+  }
+  /**
+   * Remove a texture and free its GPU resources.
+   * @example
+   * sandbox.removeTexture("u_texture");
+   */
+  removeTexture(e) {
+    return this.engine.removeTexture(e), this;
   }
   /**
    * Update shaders.
    * @example
    * sandbox.setShader(vertexSource, fragmentSource);
    */
-  setShader(t, e) {
-    return this.options.vertex = t, this.options.fragment = e, this.usingCustomVertex = !0, this.engine.shader(this.options.vertex, this.options.fragment), this;
+  setShader(e, t) {
+    return this.options.vertex = new d(e), this.options.fragment = new d(t), this.usingCustomVertex = !0, this.engine.shader(this.options.vertex, this.options.fragment), this;
   }
   /**
    * Update only fragment shader (uses default vertex).
    * @example
    * sandbox.setFragment(fragmentSource);
    */
-  setFragment(t) {
-    const e = a.detectVersion(t), i = a.detectVersion(this.options.vertex);
-    return this.options.fragment = t, e !== i && (this.usingCustomVertex || (this.options.vertex = e === 2 ? E : g)), this.engine.shader(this.options.vertex, this.options.fragment), this;
+  setFragment(e) {
+    const t = new d(e), n = t.version(), i = this.options.vertex.version();
+    return this.options.fragment = t, n !== i && (this.usingCustomVertex || (this.options.vertex = new d(
+      n === 2 ? C : A
+    ))), this.engine.shader(this.options.vertex, this.options.fragment), this;
+  }
+  /**
+   * Get current fragment shader source.
+   */
+  getFragment() {
+    return this.options.fragment.source();
+  }
+  /**
+   * Get current vertex shader source.
+   */
+  getVertex() {
+    return this.options.vertex.source();
   }
   /**
    * Set the max frame rate runtime
-   * 
+   *
    * @example
    * sandbox.setFps(30); // Limit to 30 FPS
    * sandbox.setFps(0);  // Unlimited FPS
    */
-  setFps(t) {
-    return this.engine.getClock().setMaxFps(t), this;
+  setFps(e) {
+    return this.engine.getClock().setMaxFps(e), this;
   }
   /**
    * Add a runtime render hook.
    */
-  hook(t, e = "before") {
-    return e === "before" ? this.engine.onBeforeHooks.add(t) : this.engine.onAfterHooks.add(t);
+  hook(e, t = "before") {
+    return t === "before" ? this.engine.onBeforeHooks.add(e) : this.engine.onAfterHooks.add(e);
+  }
+  /**
+   * Runtime configure the module behavior
+   * @example
+   * sandbox.module("my_module", { intensity: 0.5 });
+   */
+  module(e, t) {
+    const n = y.resolveOptions(e);
+    if (!n)
+      return console.warn(
+        `Sandbox: Counld not find options for '${e}' function. Make sure you used the correct imported name and the module is currently in use by the shader.`
+      ), this;
+    for (const [i, r] of Object.entries(t)) {
+      const s = n[i];
+      if (!s) {
+        console.warn(
+          `Sandbox: Option '${i}' not found for function '${e}'. Make sure to check available options with Sandbox.availableModules() and provide the correct option name.`
+        );
+        continue;
+      }
+      this.setUniform(s.uniform, r);
+    }
+    return this;
   }
   /**
    * Start animation loop.
@@ -1065,8 +3229,8 @@ You can handle errors programmatically by providing an onError callback to suppr
   /**
    * Start animation loop at specific time (in seconds).
    */
-  playAt(t) {
-    return this.engine.clock(t), this.engine.play(), this;
+  playAt(e) {
+    return this.engine.clock(e), this.engine.play(), this;
   }
   /**
    * Stop animation loop.
@@ -1077,9 +3241,9 @@ You can handle errors programmatically by providing an onError callback to suppr
   /**
    * Pause animation loop at specific time (in seconds).
    */
-  pauseAt(t) {
-    const e = this.hook((i) => {
-      i.time >= t && (e(), this.pause());
+  pauseAt(e) {
+    const t = this.hook((n) => {
+      n.time >= e && (t(), this.pause());
     }, "after");
     return this;
   }
@@ -1092,8 +3256,8 @@ You can handle errors programmatically by providing an onError callback to suppr
   /**
    * Set current time (in seconds).
    */
-  time(t) {
-    return this.engine.clock(t), this;
+  time(e) {
+    return this.engine.clock(e), this;
   }
   /**
    * Render a single frame (for static rendering).
@@ -1108,8 +3272,8 @@ You can handle errors programmatically by providing an onError callback to suppr
    * @example
    * sandbox.renderAt(2.5); // Render as if 2.5 seconds elapsed
    */
-  renderAt(t) {
-    return this.engine.clock(t), this.engine.render(), this;
+  renderAt(e) {
+    return this.engine.clock(e), this.engine.render(), this;
   }
   /**
    * Check if currently playing.
@@ -1129,6 +3293,57 @@ You can handle errors programmatically by providing an onError callback to suppr
   get canvas() {
     return this.canvasEl;
   }
+  /**
+   * Export current frame as a data URL string.
+   * Requires `preserveDrawingBuffer: true` if called while playing.
+   * @example
+   * const url = sandbox.renderAt(1.5).exportAsURL("image/png");
+   */
+  exportAsURL(e = "image/png", t) {
+    return this.canvas.toDataURL(e, t);
+  }
+  /**
+   * Export current frame as a Blob.
+   * Requires `preserveDrawingBuffer: true` if called while playing.
+   * @example
+   * const blob = await sandbox.renderAt(1.5).exportAsBlob("image/png");
+   */
+  exportAsBlob(e = "image/png", t) {
+    return new Promise((n, i) => {
+      this.canvas.toBlob(
+        (r) => {
+          r ? n(r) : i(new Error("Failed to create blob from canvas."));
+        },
+        e,
+        t
+      );
+    });
+  }
+  /**
+   * Export current frame as an HTMLImageElement.
+   * Requires `preserveDrawingBuffer: true` if called while playing.
+   * @example
+   * const img = sandbox.renderAt(1.5).exportAsImage("image/png");
+   * img.onload = () => document.body.appendChild(img);
+   */
+  exportAsImage(e = "image/png", t) {
+    const n = new Image();
+    return n.src = this.exportAsURL(e, t), n;
+  }
+  /**
+   * Capture the canvas as a MediaStream for video calls or recording.
+   * @example
+   * // WebRTC video call
+   * const stream = sandbox.stream(30);
+   * peerConnection.addTrack(stream.getVideoTracks()[0], stream);
+   *
+   * @example
+   * // Record to video file
+   * const recorder = new MediaRecorder(sandbox.stream(30));
+   */
+  stream(e) {
+    return this.canvasEl.captureStream(e);
+  }
   /**
    * Destroy sandbox and release all resources.
    * @example
@@ -1141,10 +3356,28 @@ You can handle errors programmatically by providing an onError callback to suppr
   }
 }
 export {
-  y as Sandbox,
-  w as SandboxContextError,
-  u as SandboxError,
-  m as SandboxProgramError,
-  c as SandboxShaderCompilationError,
-  k as SandboxShaderVersionMismatchError
+  I as Sandbox,
+  Q as SandboxAttemptedToImportDefaultFunctionError,
+  K as SandboxAttemptedToImportMainFunctionError,
+  ve as SandboxContextCreationError,
+  h as SandboxError,
+  J as SandboxForbiddenModuleNameError,
+  _ as SandboxGLSLShaderCompilationError,
+  ne as SandboxMentionCouldNotBeReplacedError,
+  te as SandboxMentionFunctionNotFoundError,
+  ee as SandboxMentionUniformNotFoundError,
+  Y as SandboxModuleMethodNotFoundError,
+  X as SandboxModuleNotFoundError,
+  re as SandboxOnHookCallbackError,
+  ie as SandboxOnLoadCallbackError,
+  Z as SandboxOverwriteModuleError,
+  S as SandboxProgramError,
+  j as SandboxShaderDuplicateImportNameError,
+  q as SandboxShaderImportSyntaxError,
+  U as SandboxShaderRequirementMismatchError,
+  z as SandboxShaderVersionMismatchError,
+  H as SandboxShaderWithoutFunctionError,
+  ge as SandboxTextureCreationError,
+  xe as SandboxTextureUnitLimitError,
+  W as SandboxWebGLNotSupportedError
 };