@viji-dev/core 0.2.10 → 0.2.12

package/dist/assets/{viji.worker-kGDstU5X.js → viji.worker-DHpeQQ14.js}

@@ -1527,6 +1527,1280 @@ class VideoSystem {
     return this.cvSystem.getStats();
   }
 }
+class P5WorkerAdapter {
+  constructor(offscreenCanvas, _vijiAPI, sceneCode) {
+    this.offscreenCanvas = offscreenCanvas;
+    this.setupFn = sceneCode.setup || null;
+    this.renderFn = sceneCode.render;
+    this.installMinimalShims();
+  }
+  p5Instance = null;
+  setupFn = null;
+  renderFn = null;
+  p5InternalSetupComplete = false;
+  artistSetupComplete = false;
+  p5Class = null;
+  // Cache for converted P5.Image objects
+  imageParameterCache = /* @__PURE__ */ new Map();
+  // Track if P5.js's main canvas has been created
+  mainCanvasCreated = false;
+  /**
+   * Initialize P5 instance after P5.js library is loaded
+   * This must be called after the P5 class is available
+   */
+  async init() {
+    try {
+      const p5Module = await import("https://esm.sh/p5@1.9.4");
+      this.p5Class = p5Module.default || p5Module;
+      const setupPromise = new Promise((resolve) => {
+        new this.p5Class((p) => {
+          this.p5Instance = p;
+          p.setup = () => {
+            p.createCanvas(this.offscreenCanvas.width, this.offscreenCanvas.height);
+            p.noLoop();
+            this.p5InternalSetupComplete = true;
+            resolve();
+          };
+          p.draw = () => {
+          };
+          setTimeout(() => {
+            if (p.setup && typeof p.setup === "function") {
+              try {
+                p.setup();
+              } catch (setupError) {
+                console.error("P5 setup failed:", setupError);
+                resolve();
+              }
+            }
+          }, 0);
+        });
+      });
+      await setupPromise;
+    } catch (error) {
+      console.error("Failed to initialize P5.js:", error);
+      throw error;
+    }
+  }
+  /**
+   * Install minimal DOM shims that P5.js needs for rendering
+   */
+  installMinimalShims() {
+    const self2 = globalThis;
+    if (typeof self2.document === "undefined") {
+      const createStyleProxy = () => new Proxy({}, {
+        get: () => "",
+        set: () => true
+      });
+      const bodyElement = {
+        style: createStyleProxy(),
+        appendChild: () => {
+        },
+        removeChild: () => {
+        },
+        children: [],
+        childNodes: [],
+        firstChild: null,
+        lastChild: null,
+        parentNode: null,
+        ownerDocument: void 0,
+        // Will be set after document is created
+        setAttribute: () => {
+        },
+        getAttribute: () => null,
+        addEventListener: () => {
+        },
+        removeEventListener: () => {
+        },
+        tagName: "BODY"
+      };
+      self2.document = {
+        createElement: (tag) => {
+          if (tag === "canvas") {
+            let canvas;
+            if (!this.mainCanvasCreated) {
+              canvas = this.offscreenCanvas;
+              this.mainCanvasCreated = true;
+            } else {
+              canvas = new OffscreenCanvas(300, 300);
+            }
+            canvas.style = createStyleProxy();
+            canvas.dataset = new Proxy({}, {
+              get: () => void 0,
+              set: () => true
+            });
+            canvas.classList = {
+              add: () => {
+              },
+              remove: () => {
+              },
+              contains: () => false,
+              toggle: () => false
+            };
+            canvas.getBoundingClientRect = () => ({
+              left: 0,
+              top: 0,
+              width: canvas.width,
+              height: canvas.height
+            });
+            return canvas;
+          }
+          return {
+            style: createStyleProxy(),
+            appendChild: () => {
+            },
+            removeChild: () => {
+            },
+            setAttribute: () => {
+            },
+            getAttribute: () => null,
+            tagName: tag.toUpperCase(),
+            addEventListener: () => {
+            },
+            removeEventListener: () => {
+            }
+          };
+        },
+        createElementNS: (_ns, tag) => {
+          return self2.document.createElement(tag);
+        },
+        body: bodyElement,
+        documentElement: {
+          style: createStyleProxy(),
+          children: [],
+          childNodes: []
+        },
+        getElementById: () => null,
+        querySelector: () => null,
+        querySelectorAll: () => [],
+        getElementsByTagName: (tagName) => {
+          if (tagName.toLowerCase() === "main") {
+            return [bodyElement];
+          }
+          return [];
+        },
+        addEventListener: () => {
+        },
+        removeEventListener: () => {
+        },
+        hasFocus: () => true
+        // P5.js checks this for accessibility features
+      };
+      bodyElement.ownerDocument = self2.document;
+    }
+    if (typeof self2.window === "undefined") {
+      self2.window = {
+        devicePixelRatio: 1,
+        innerWidth: this.offscreenCanvas.width,
+        innerHeight: this.offscreenCanvas.height,
+        addEventListener: () => {
+        },
+        removeEventListener: () => {
+        },
+        requestAnimationFrame: (_callback) => {
+          return 0;
+        },
+        cancelAnimationFrame: () => {
+        },
+        setTimeout: self2.setTimeout.bind(self2),
+        clearTimeout: self2.clearTimeout.bind(self2),
+        setInterval: self2.setInterval.bind(self2),
+        clearInterval: self2.clearInterval.bind(self2),
+        performance: self2.performance,
+        console: self2.console,
+        Math: self2.Math,
+        Date: self2.Date,
+        Array: self2.Array,
+        Object: self2.Object
+      };
+    }
+    if (typeof self2.navigator === "undefined") {
+      self2.navigator = {
+        userAgent: "Viji-Worker-P5",
+        platform: "Worker",
+        language: "en-US"
+      };
+    }
+    if (typeof self2.screen === "undefined") {
+      self2.screen = {
+        width: this.offscreenCanvas.width,
+        height: this.offscreenCanvas.height,
+        availWidth: this.offscreenCanvas.width,
+        availHeight: this.offscreenCanvas.height,
+        colorDepth: 24,
+        pixelDepth: 24
+      };
+    }
+    if (typeof self2.HTMLCanvasElement === "undefined") {
+      self2.HTMLCanvasElement = function() {
+      };
+      Object.setPrototypeOf(OffscreenCanvas.prototype, self2.HTMLCanvasElement.prototype);
+    }
+  }
+  /**
+   * Convert ImageBitmap to a P5.js-compatible image object (with caching)
+   * Returns an object that mimics P5.Image structure for P5.js's image() function
+   */
+  getOrCreateP5Image(cacheKey, source) {
+    if (!this.p5Instance) return null;
+    const cached = this.imageParameterCache.get(cacheKey);
+    if (cached && cached.source === source) {
+      return cached.p5Image;
+    }
+    try {
+      const offscreenCanvas = new OffscreenCanvas(source.width, source.height);
+      const ctx = offscreenCanvas.getContext("2d");
+      if (!ctx) {
+        throw new Error("Failed to get 2d context from OffscreenCanvas");
+      }
+      ctx.drawImage(source, 0, 0);
+      const p5ImageWrapper = {
+        canvas: offscreenCanvas,
+        // P5.js looks for img.canvas || img.elt
+        elt: offscreenCanvas,
+        // Fallback for compatibility
+        width: source.width,
+        // Logical width
+        height: source.height
+        // Logical height
+      };
+      this.imageParameterCache.set(cacheKey, { source, p5Image: p5ImageWrapper });
+      return p5ImageWrapper;
+    } catch (error) {
+      console.warn("Failed to convert image to P5-compatible object:", error);
+      return null;
+    }
+  }
+  /**
+   * Add .p5 property to image parameters for P5.js-specific rendering
+   * This allows artists to use p5.image() while keeping .value for native canvas API
+   * @param parameterObjects Map of parameter name to parameter object from ParameterSystem
+   */
+  addP5PropertyToImageParameters(parameterObjects) {
+    if (!this.p5Instance) return;
+    const isImageLike = (value) => {
+      return value instanceof ImageBitmap || value instanceof OffscreenCanvas || value && typeof value === "object" && "width" in value && "height" in value;
+    };
+    for (const [name, param] of parameterObjects) {
+      try {
+        if (param && typeof param === "object" && "value" in param) {
+          const value = param.value;
+          if (value && isImageLike(value) && !("p5" in param)) {
+            Object.defineProperty(param, "p5", {
+              get: () => this.getOrCreateP5Image(name, param.value),
+              enumerable: true,
+              configurable: true
+            });
+          }
+        }
+      } catch (error) {
+        console.warn(`Failed to add .p5 property to parameter '${name}':`, error);
+        continue;
+      }
+    }
+  }
+  /**
+   * Execute one frame of the P5 scene
+   * Called by Viji's render loop
+   * @param vijiAPI The Viji API object passed to artist code
+   * @param parameterObjects Map of parameter objects from ParameterSystem
+   */
+  tick(vijiAPI, parameterObjects) {
+    if (!this.p5Instance || !this.p5InternalSetupComplete) {
+      return;
+    }
+    try {
+      this.addP5PropertyToImageParameters(parameterObjects);
+      if (!this.artistSetupComplete && this.setupFn) {
+        this.setupFn(vijiAPI, this.p5Instance);
+        this.artistSetupComplete = true;
+      }
+      if (this.p5Instance._setProperty) {
+        this.p5Instance._setProperty("frameCount", this.p5Instance.frameCount + 1);
+      }
+      if (this.renderFn) {
+        this.renderFn(vijiAPI, this.p5Instance);
+      }
+    } catch (error) {
+      console.error("P5 render error:", error);
+      throw error;
+    }
+  }
+  /**
+   * Handle canvas resize
+   */
+  resize(width, height) {
+    if (!this.p5Instance) return;
+    this.p5Instance._setProperty("width", width);
+    this.p5Instance._setProperty("height", height);
+    this.p5Instance._setProperty("_width", width);
+    this.p5Instance._setProperty("_height", height);
+    if (this.p5Instance._renderer) {
+      this.p5Instance._renderer.width = width;
+      this.p5Instance._renderer.height = height;
+    }
+    if (typeof this.p5Instance.resizeCanvas === "function") {
+      try {
+        this.p5Instance.resizeCanvas(width, height, true);
+      } catch (error) {
+        console.warn("P5 resize warning:", error);
+      }
+    }
+  }
+  /**
+   * Cleanup P5 instance
+   */
+  destroy() {
+    if (this.p5Instance) {
+      try {
+        if (typeof this.p5Instance.remove === "function") {
+          this.p5Instance.remove();
+        }
+      } catch (error) {
+        console.warn("P5 cleanup warning:", error);
+      }
+      this.p5Instance = null;
+    }
+    this.setupFn = null;
+    this.renderFn = null;
+    this.p5InternalSetupComplete = false;
+    this.artistSetupComplete = false;
+  }
+}
+class ShaderParameterParser {
+  /**
+   * Parse all parameter declarations from shader code
+   */
+  static parseParameters(shaderCode) {
+    const parameters = [];
+    const lines = shaderCode.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      const match = trimmed.match(/\/\/\s*@viji-(\w+):(\w+)\s+(.+)/);
+      if (match) {
+        const [, type, uniformName, configStr] = match;
+        try {
+          const config = this.parseKeyValuePairs(configStr);
+          const param = {
+            type,
+            uniformName,
+            label: config.label || uniformName,
+            default: config.default,
+            config
+          };
+          this.validateParameter(param);
+          parameters.push(param);
+        } catch (error) {
+          console.warn(`Failed to parse shader parameter: ${line}`, error);
+        }
+      }
+    }
+    return parameters;
+  }
+  /**
+   * Parse key:value pairs from configuration string
+   */
+  static parseKeyValuePairs(configStr) {
+    const config = {};
+    const keyValueRegex = /(\w+):((?:"[^"]*"|\[[^\]]*\]|#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3}|[^\s]+))/g;
+    let match;
+    while ((match = keyValueRegex.exec(configStr)) !== null) {
+      const [, key, value] = match;
+      config[key] = this.parseValue(value);
+    }
+    return config;
+  }
+  /**
+   * Parse individual value from string
+   */
+  static parseValue(value) {
+    if (value.startsWith('"') && value.endsWith('"')) {
+      return value.slice(1, -1);
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+      try {
+        return JSON.parse(value);
+      } catch {
+        const items = value.slice(1, -1).split(",").map((s) => s.trim());
+        return items.map((item) => {
+          if (item.startsWith('"') && item.endsWith('"')) {
+            return item.slice(1, -1);
+          }
+          const num2 = parseFloat(item);
+          return isNaN(num2) ? item : num2;
+        });
+      }
+    }
+    if (value.startsWith("#")) {
+      return value;
+    }
+    if (value === "true") return true;
+    if (value === "false") return false;
+    const num = parseFloat(value);
+    if (!isNaN(num)) return num;
+    return value;
+  }
+  /**
+   * Validate parameter definition
+   */
+  static validateParameter(param) {
+    if (!param.type) {
+      throw new Error("Parameter type is required");
+    }
+    if (!param.uniformName) {
+      throw new Error("Parameter uniformName is required");
+    }
+    if (!param.config.label) {
+      throw new Error(`Parameter ${param.uniformName} missing required 'label' key`);
+    }
+    switch (param.type) {
+      case "slider":
+      case "number":
+        if (param.config.default === void 0) {
+          throw new Error(`Parameter ${param.uniformName} of type ${param.type} missing required 'default' key`);
+        }
+        break;
+      case "color":
+        if (param.config.default === void 0) {
+          throw new Error(`Parameter ${param.uniformName} of type 'color' missing required 'default' key`);
+        }
+        if (!param.config.default.startsWith("#")) {
+          throw new Error(`Parameter ${param.uniformName} of type 'color' default must be hex color (e.g., #ff0000)`);
+        }
+        break;
+      case "toggle":
+        if (param.config.default === void 0) {
+          throw new Error(`Parameter ${param.uniformName} of type 'toggle' missing required 'default' key`);
+        }
+        if (typeof param.config.default !== "boolean") {
+          throw new Error(`Parameter ${param.uniformName} of type 'toggle' default must be boolean (true or false)`);
+        }
+        break;
+      case "select":
+        if (param.config.default === void 0) {
+          throw new Error(`Parameter ${param.uniformName} of type 'select' missing required 'default' key`);
+        }
+        if (!param.config.options || !Array.isArray(param.config.options)) {
+          throw new Error(`Parameter ${param.uniformName} of type 'select' missing required 'options' key (array)`);
+        }
+        break;
+      case "image":
+        break;
+      default:
+        console.warn(`Unknown parameter type: ${param.type}`);
+    }
+    if (param.uniformName.startsWith("u_")) {
+      console.warn(`Parameter name "${param.uniformName}" uses reserved prefix "u_". Consider renaming to avoid conflicts with built-in uniforms.`);
+    }
+  }
+  /**
+   * Generate uniform declaration for a parameter
+   */
+  static generateUniformDeclaration(param) {
+    switch (param.type) {
+      case "slider":
+      case "number":
+        return `uniform float ${param.uniformName};`;
+      case "color":
+        return `uniform vec3 ${param.uniformName};`;
+      case "toggle":
+        return `uniform bool ${param.uniformName};`;
+      case "select":
+        return `uniform int ${param.uniformName};`;
+      case "image":
+        return `uniform sampler2D ${param.uniformName};`;
+      default:
+        return `// Unknown parameter type: ${param.type}`;
+    }
+  }
+}
+class ShaderWorkerAdapter {
+  constructor(offscreenCanvas, _vijiAPI, shaderCode) {
+    this.shaderCode = shaderCode;
+    this.glslVersion = this.detectGLSLVersion(shaderCode);
+    this.backbufferEnabled = shaderCode.includes("backbuffer");
+    if (this.glslVersion === "glsl300") {
+      const gl = offscreenCanvas.getContext("webgl2");
+      if (!gl) {
+        throw new Error("WebGL 2 not supported. Use GLSL ES 1.00 syntax instead.");
+      }
+      this.gl = gl;
+    } else {
+      const gl = offscreenCanvas.getContext("webgl");
+      if (!gl) {
+        throw new Error("WebGL not supported");
+      }
+      this.gl = gl;
+    }
+  }
+  gl;
+  program = null;
+  uniformLocations = /* @__PURE__ */ new Map();
+  textureUnits = /* @__PURE__ */ new Map();
+  nextTextureUnit = 0;
+  textures = /* @__PURE__ */ new Map();
+  // Fullscreen quad
+  quadBuffer = null;
+  // Parameter definitions
+  parameters = [];
+  // GLSL version detection
+  glslVersion = "glsl100";
+  // Audio FFT texture
+  audioFFTTexture = null;
+  videoTexture = null;
+  segmentationTexture = null;
+  // Backbuffer support (ping-pong framebuffers)
+  backbufferFramebuffer = null;
+  backbufferTexture = null;
+  currentFramebuffer = null;
+  currentTexture = null;
+  backbufferEnabled = false;
+  /**
+   * Initialize the shader adapter
+   */
+  async init() {
+    try {
+      this.parameters = ShaderParameterParser.parseParameters(this.shaderCode);
+      this.createFullscreenQuad();
+      const processedCode = this.injectUniforms(this.shaderCode);
+      this.compileAndLinkShader(processedCode);
+      this.cacheUniformLocations();
+      this.reserveTextureUnits();
+      if (this.backbufferEnabled) {
+        this.createBackbufferFramebuffers();
+      }
+    } catch (error) {
+      console.error("Failed to initialize ShaderWorkerAdapter:", error);
+      throw error;
+    }
+  }
+  /**
+   * Detect GLSL version from shader code
+   */
+  detectGLSLVersion(code) {
+    return code.includes("#version 300") ? "glsl300" : "glsl100";
+  }
+  /**
+   * Create fullscreen quad geometry
+   */
+  createFullscreenQuad() {
+    const vertices = new Float32Array([
+      -1,
+      -1,
+      // Bottom-left
+      1,
+      -1,
+      // Bottom-right
+      -1,
+      1,
+      // Top-left
+      1,
+      1
+      // Top-right
+    ]);
+    this.quadBuffer = this.gl.createBuffer();
+    this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.quadBuffer);
+    this.gl.bufferData(this.gl.ARRAY_BUFFER, vertices, this.gl.STATIC_DRAW);
+  }
+  /**
+   * Inject built-in and parameter uniforms into shader code
+   */
+  injectUniforms(artistCode) {
+    let versionLine = "";
+    let codeWithoutVersion = artistCode;
+    const lines = artistCode.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const trimmed = lines[i].trim();
+      if (trimmed.startsWith("#version")) {
+        versionLine = trimmed;
+        lines[i] = "";
+        codeWithoutVersion = lines.join("\n");
+        break;
+      }
+    }
+    const injectionPoint = this.findInjectionPoint(codeWithoutVersion);
+    const builtInUniforms = this.getBuiltInUniforms();
+    const parameterUniforms = this.parameters.map((p) => ShaderParameterParser.generateUniformDeclaration(p)).join("\n");
+    const usesFwidth = artistCode.includes("fwidth");
+    if (usesFwidth && this.glslVersion === "glsl100") {
+      const ext = this.gl.getExtension("OES_standard_derivatives");
+      if (!ext) {
+        console.warn("Shader uses fwidth() but OES_standard_derivatives extension is not supported. Shader may not compile.");
+      }
+    }
+    const parts = [];
+    if (usesFwidth && this.glslVersion === "glsl100") {
+      parts.push("#extension GL_OES_standard_derivatives : enable");
+    }
+    if (this.glslVersion === "glsl100") {
+      parts.push("");
+      parts.push("#ifdef GL_ES");
+      parts.push("precision mediump float;");
+      parts.push("#endif");
+    } else {
+      parts.push("");
+      parts.push("precision mediump float;");
+    }
+    parts.push("");
+    parts.push("// ===== VIJI AUTO-INJECTED UNIFORMS =====");
+    parts.push("// Built-in uniforms (auto-provided)");
+    parts.push(builtInUniforms);
+    parts.push("");
+    parts.push("// Parameter uniforms (from @viji-* declarations)");
+    parts.push(parameterUniforms);
+    parts.push("");
+    parts.push("// ===== ARTIST CODE =====");
+    const uniformBlock = parts.join("\n");
+    const codeWithUniforms = codeWithoutVersion.slice(0, injectionPoint) + "\n" + uniformBlock + "\n" + codeWithoutVersion.slice(injectionPoint);
+    const finalCode = versionLine ? versionLine + "\n" + codeWithUniforms : codeWithUniforms;
+    console.log("=== INJECTED SHADER CODE (first 50 lines) ===");
+    console.log(finalCode.split("\n").slice(0, 50).join("\n"));
+    console.log("=== END INJECTED CODE ===");
+    return finalCode;
+  }
+  /**
+   * Find where to inject extensions and uniforms
+   * Extensions must come after #version but before any code
+   * 
+   * Strategy: 
+   * 1. If #version exists, inject right after it
+   * 2. Otherwise, skip ALL comments (single and multi-line) and inject before first code
+   */
+  findInjectionPoint(code) {
+    const lines = code.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("#version")) {
+        return this.getLineEndPosition(code, i);
+      }
+    }
+    let inMultiLineComment = false;
+    let firstCodeLine = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.includes("/*")) {
+        inMultiLineComment = true;
+      }
+      if (line.includes("*/")) {
+        inMultiLineComment = false;
+        firstCodeLine = i + 1;
+        continue;
+      }
+      if (inMultiLineComment) {
+        continue;
+      }
+      if (line === "" || line.startsWith("//")) {
+        firstCodeLine = i + 1;
+        continue;
+      }
+      break;
+    }
+    if (firstCodeLine > 0 && firstCodeLine < lines.length) {
+      return this.getLineEndPosition(code, firstCodeLine - 1);
+    }
+    return 0;
+  }
+  /**
+   * Get byte position of end of line N
+   */
+  getLineEndPosition(code, lineNumber) {
+    const lines = code.split("\n");
+    let position = 0;
+    for (let i = 0; i <= lineNumber && i < lines.length; i++) {
+      position += lines[i].length + 1;
+    }
+    return position;
+  }
+  /**
+   * Get built-in uniform declarations
+   */
+  getBuiltInUniforms() {
+    return `// Core - Canvas & Timing
+uniform vec2 u_resolution;
+uniform float u_time;
+uniform float u_deltaTime;
+uniform int u_frame;
+uniform float u_pixelRatio;
+uniform float u_fps;
+
+// Mouse API
+uniform vec2 u_mouse;
+uniform bool u_mouseInCanvas;
+uniform bool u_mousePressed;
+uniform bool u_mouseLeft;
+uniform bool u_mouseRight;
+uniform bool u_mouseMiddle;
+uniform vec2 u_mouseVelocity;
+
+// Keyboard API - Common keys
+uniform bool u_keySpace;
+uniform bool u_keyShift;
+uniform bool u_keyCtrl;
+uniform bool u_keyAlt;
+uniform bool u_keyW;
+uniform bool u_keyA;
+uniform bool u_keyS;
+uniform bool u_keyD;
+uniform bool u_keyUp;
+uniform bool u_keyDown;
+uniform bool u_keyLeft;
+uniform bool u_keyRight;
+
+// Touch API
+uniform int u_touchCount;
+uniform vec2 u_touch0;
+uniform vec2 u_touch1;
+uniform vec2 u_touch2;
+uniform vec2 u_touch3;
+uniform vec2 u_touch4;
+
+// Audio
+uniform float u_audioVolume;
+uniform float u_audioPeak;
+uniform float u_audioBass;
+uniform float u_audioMid;
+uniform float u_audioTreble;
+uniform float u_audioSubBass;
+uniform float u_audioLowMid;
+uniform float u_audioHighMid;
+uniform float u_audioPresence;
+uniform float u_audioBrilliance;
+uniform sampler2D u_audioFFT;
+
+// Video
+uniform sampler2D u_video;
+uniform vec2 u_videoResolution;
+uniform float u_videoFrameRate;
+
+// CV - Face Detection
+uniform int u_faceCount;
+uniform vec4 u_face0Bounds;
+uniform vec3 u_face0HeadPose;
+uniform float u_face0Confidence;
+uniform float u_face0Happy;
+uniform float u_face0Sad;
+uniform float u_face0Angry;
+uniform float u_face0Surprised;
+
+// CV - Hand Tracking
+uniform int u_handCount;
+uniform vec3 u_leftHandPalm;
+uniform vec3 u_rightHandPalm;
+uniform float u_leftHandFist;
+uniform float u_leftHandOpen;
+uniform float u_rightHandFist;
+uniform float u_rightHandOpen;
+
+// CV - Pose Detection
+uniform bool u_poseDetected;
+uniform vec2 u_nosePosition;
+uniform vec2 u_leftWristPosition;
+uniform vec2 u_rightWristPosition;
+uniform vec2 u_leftAnklePosition;
+uniform vec2 u_rightAnklePosition;
+
+// CV - Segmentation
+uniform sampler2D u_segmentationMask;
+uniform vec2 u_segmentationRes;
+
+// Backbuffer (previous frame feedback)
+${this.backbufferEnabled ? "uniform sampler2D backbuffer;" : "// backbuffer not enabled"}
+`;
+  }
+  /**
+   * Compile and link shader program
+   */
+  compileAndLinkShader(fragmentShaderCode) {
+    const gl = this.gl;
+    const vertexShaderCode = this.glslVersion === "glsl300" ? `#version 300 es
+         precision mediump float;
+         in vec2 a_position;
+         void main() {
+           gl_Position = vec4(a_position, 0.0, 1.0);
+         }` : `attribute vec2 a_position;
+         void main() {
+           gl_Position = vec4(a_position, 0.0, 1.0);
+         }`;
+    const vertexShader = this.compileShader(gl.VERTEX_SHADER, vertexShaderCode);
+    const fragmentShader = this.compileShader(gl.FRAGMENT_SHADER, fragmentShaderCode);
+    const program = gl.createProgram();
+    if (!program) {
+      throw new Error("Failed to create WebGL program");
+    }
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.linkProgram(program);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+      const error = gl.getProgramInfoLog(program);
+      throw new Error(`Shader program link failed: ${error}`);
+    }
+    this.program = program;
+    gl.useProgram(program);
+    gl.deleteShader(vertexShader);
+    gl.deleteShader(fragmentShader);
+  }
+  /**
+   * Compile a shader
+   */
+  compileShader(type, source) {
+    const gl = this.gl;
+    const shader = gl.createShader(type);
+    if (!shader) {
+      throw new Error("Failed to create shader");
+    }
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+      const error = gl.getShaderInfoLog(shader);
+      const shaderType = type === gl.VERTEX_SHADER ? "vertex" : "fragment";
+      throw new Error(`${shaderType} shader compilation failed:
+${error}`);
+    }
+    return shader;
+  }
+  /**
+   * Cache uniform locations for fast access
+   */
+  cacheUniformLocations() {
+    if (!this.program) return;
+    const gl = this.gl;
+    const numUniforms = gl.getProgramParameter(this.program, gl.ACTIVE_UNIFORMS);
+    for (let i = 0; i < numUniforms; i++) {
+      const info = gl.getActiveUniform(this.program, i);
+      if (info) {
+        const location = gl.getUniformLocation(this.program, info.name);
+        this.uniformLocations.set(info.name, location);
+      }
+    }
+  }
+  /**
+   * Reserve texture units for special textures
+   */
+  reserveTextureUnits() {
+    this.textureUnits.set("u_audioFFT", this.nextTextureUnit++);
+    this.textureUnits.set("u_video", this.nextTextureUnit++);
+    this.textureUnits.set("u_segmentationMask", this.nextTextureUnit++);
+    if (this.backbufferEnabled) {
+      this.textureUnits.set("backbuffer", this.nextTextureUnit++);
+    }
+  }
+  /**
+   * Create ping-pong framebuffers for backbuffer support
+   */
+  createBackbufferFramebuffers() {
+    const gl = this.gl;
+    const width = gl.canvas.width;
+    const height = gl.canvas.height;
+    const createFBOTexture = () => {
+      const texture = gl.createTexture();
+      gl.bindTexture(gl.TEXTURE_2D, texture);
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+      const framebuffer = gl.createFramebuffer();
+      gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+      return { framebuffer, texture };
+    };
+    const fbo1 = createFBOTexture();
+    const fbo2 = createFBOTexture();
+    this.backbufferFramebuffer = fbo1.framebuffer;
+    this.backbufferTexture = fbo1.texture;
+    this.currentFramebuffer = fbo2.framebuffer;
+    this.currentTexture = fbo2.texture;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+  }
+  /**
+   * Main render method
+   */
+  render(viji, parameterObjects) {
+    const gl = this.gl;
+    if (!this.program || !this.quadBuffer) {
+      console.warn("Shader not initialized");
+      return;
+    }
+    gl.useProgram(this.program);
+    this.updateBuiltInUniforms(viji);
+    this.updateParameterUniforms(parameterObjects);
+    if (this.backbufferEnabled && this.backbufferTexture) {
+      const backbufferUnit = this.textureUnits.get("backbuffer");
+      if (backbufferUnit !== void 0) {
+        gl.activeTexture(gl.TEXTURE0 + backbufferUnit);
+        gl.bindTexture(gl.TEXTURE_2D, this.backbufferTexture);
+        this.setUniform("backbuffer", "sampler2D", backbufferUnit);
+      }
+      gl.bindFramebuffer(gl.FRAMEBUFFER, this.currentFramebuffer);
+    }
+    const positionLocation = gl.getAttribLocation(this.program, "a_position");
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.quadBuffer);
+    gl.enableVertexAttribArray(positionLocation);
+    gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 0, 0);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+    if (this.backbufferEnabled) {
+      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+      gl.activeTexture(gl.TEXTURE0);
+      gl.bindTexture(gl.TEXTURE_2D, this.currentTexture);
+      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+      const tempFB = this.backbufferFramebuffer;
+      const tempTex = this.backbufferTexture;
+      this.backbufferFramebuffer = this.currentFramebuffer;
+      this.backbufferTexture = this.currentTexture;
+      this.currentFramebuffer = tempFB;
+      this.currentTexture = tempTex;
+    }
+  }
+  /**
+   * Update built-in uniforms from viji object
+   */
+  updateBuiltInUniforms(viji) {
+    this.setUniform("u_resolution", "vec2", [viji.width, viji.height]);
+    this.setUniform("u_time", "float", viji.time);
+    this.setUniform("u_deltaTime", "float", viji.deltaTime);
+    this.setUniform("u_frame", "int", viji.frameCount);
+    this.setUniform("u_pixelRatio", "float", viji.pixelRatio);
+    this.setUniform("u_fps", "float", viji.fps);
+    this.setUniform("u_mouse", "vec2", [viji.mouse.x, viji.height - viji.mouse.y]);
+    this.setUniform("u_mouseInCanvas", "bool", viji.mouse.isInCanvas);
+    this.setUniform("u_mousePressed", "bool", viji.mouse.isPressed);
+    this.setUniform("u_mouseLeft", "bool", viji.mouse.leftButton);
+    this.setUniform("u_mouseRight", "bool", viji.mouse.rightButton);
+    this.setUniform("u_mouseMiddle", "bool", viji.mouse.middleButton);
+    this.setUniform("u_mouseVelocity", "vec2", [viji.mouse.velocity.x, -viji.mouse.velocity.y]);
+    this.setUniform("u_keySpace", "bool", viji.keyboard.isPressed(" ") || viji.keyboard.isPressed("space"));
+    this.setUniform("u_keyShift", "bool", viji.keyboard.shift);
+    this.setUniform("u_keyCtrl", "bool", viji.keyboard.ctrl);
+    this.setUniform("u_keyAlt", "bool", viji.keyboard.alt);
+    this.setUniform("u_keyW", "bool", viji.keyboard.isPressed("w") || viji.keyboard.isPressed("W"));
+    this.setUniform("u_keyA", "bool", viji.keyboard.isPressed("a") || viji.keyboard.isPressed("A"));
+    this.setUniform("u_keyS", "bool", viji.keyboard.isPressed("s") || viji.keyboard.isPressed("S"));
+    this.setUniform("u_keyD", "bool", viji.keyboard.isPressed("d") || viji.keyboard.isPressed("D"));
+    this.setUniform("u_keyUp", "bool", viji.keyboard.isPressed("ArrowUp"));
+    this.setUniform("u_keyDown", "bool", viji.keyboard.isPressed("ArrowDown"));
+    this.setUniform("u_keyLeft", "bool", viji.keyboard.isPressed("ArrowLeft"));
+    this.setUniform("u_keyRight", "bool", viji.keyboard.isPressed("ArrowRight"));
+    this.setUniform("u_touchCount", "int", viji.touches.count);
+    for (let i = 0; i < 5; i++) {
+      const touch = viji.touches.points[i];
+      if (touch) {
+        this.setUniform(`u_touch${i}`, "vec2", [touch.x, viji.height - touch.y]);
+      } else {
+        this.setUniform(`u_touch${i}`, "vec2", [0, 0]);
+      }
+    }
+    const audio = viji.audio;
+    this.setUniform("u_audioVolume", "float", audio.volume?.rms || 0);
+    this.setUniform("u_audioPeak", "float", audio.volume?.peak || 0);
+    this.setUniform("u_audioBass", "float", audio.bands?.bass || 0);
+    this.setUniform("u_audioMid", "float", audio.bands?.mid || 0);
+    this.setUniform("u_audioTreble", "float", audio.bands?.treble || 0);
+    this.setUniform("u_audioSubBass", "float", audio.bands?.subBass || 0);
+    this.setUniform("u_audioLowMid", "float", audio.bands?.lowMid || 0);
+    this.setUniform("u_audioHighMid", "float", audio.bands?.highMid || 0);
+    this.setUniform("u_audioPresence", "float", audio.bands?.presence || 0);
+    this.setUniform("u_audioBrilliance", "float", audio.bands?.brilliance || 0);
+    if (audio.isConnected) {
+      this.updateAudioFFTTexture(audio.getFrequencyData());
+    }
+    const video = viji.video;
+    if (video.isConnected && video.currentFrame) {
+      this.updateVideoTexture(video.currentFrame);
+      this.setUniform("u_videoResolution", "vec2", [video.frameWidth, video.frameHeight]);
+      this.setUniform("u_videoFrameRate", "float", video.frameRate);
+    } else {
+      this.setUniform("u_videoResolution", "vec2", [0, 0]);
+      this.setUniform("u_videoFrameRate", "float", 0);
+    }
+    const faces = video.faces || [];
+    this.setUniform("u_faceCount", "int", faces.length);
+    if (faces.length > 0) {
+      const face = faces[0];
+      this.setUniform("u_face0Bounds", "vec4", [face.bounds.x, face.bounds.y, face.bounds.width, face.bounds.height]);
+      this.setUniform("u_face0HeadPose", "vec3", [face.headPose.pitch, face.headPose.yaw, face.headPose.roll]);
+      this.setUniform("u_face0Confidence", "float", face.confidence);
+      this.setUniform("u_face0Happy", "float", face.expressions.happy);
+      this.setUniform("u_face0Sad", "float", face.expressions.sad);
+      this.setUniform("u_face0Angry", "float", face.expressions.angry);
+      this.setUniform("u_face0Surprised", "float", face.expressions.surprised);
+    } else {
+      this.setUniform("u_face0Bounds", "vec4", [0, 0, 0, 0]);
+      this.setUniform("u_face0HeadPose", "vec3", [0, 0, 0]);
+      this.setUniform("u_face0Confidence", "float", 0);
+      this.setUniform("u_face0Happy", "float", 0);
+      this.setUniform("u_face0Sad", "float", 0);
+      this.setUniform("u_face0Angry", "float", 0);
+      this.setUniform("u_face0Surprised", "float", 0);
+    }
+    const hands = video.hands || [];
+    this.setUniform("u_handCount", "int", hands.length);
+    const leftHand = hands.find((h) => h.handedness === "left");
+    const rightHand = hands.find((h) => h.handedness === "right");
+    if (leftHand) {
+      this.setUniform("u_leftHandPalm", "vec3", [leftHand.palm.x, leftHand.palm.y, leftHand.palm.z]);
+      this.setUniform("u_leftHandFist", "float", leftHand.gestures?.fist || 0);
+      this.setUniform("u_leftHandOpen", "float", leftHand.gestures?.openPalm || 0);
+    } else {
+      this.setUniform("u_leftHandPalm", "vec3", [0, 0, 0]);
+      this.setUniform("u_leftHandFist", "float", 0);
+      this.setUniform("u_leftHandOpen", "float", 0);
+    }
+    if (rightHand) {
+      this.setUniform("u_rightHandPalm", "vec3", [rightHand.palm.x, rightHand.palm.y, rightHand.palm.z]);
+      this.setUniform("u_rightHandFist", "float", rightHand.gestures?.fist || 0);
+      this.setUniform("u_rightHandOpen", "float", rightHand.gestures?.openPalm || 0);
+    } else {
+      this.setUniform("u_rightHandPalm", "vec3", [0, 0, 0]);
+      this.setUniform("u_rightHandFist", "float", 0);
+      this.setUniform("u_rightHandOpen", "float", 0);
+    }
+    const pose = video.pose;
+    this.setUniform("u_poseDetected", "bool", pose !== null);
+    if (pose) {
+      const nose = pose.landmarks[0];
+      const leftWrist = pose.landmarks[15];
+      const rightWrist = pose.landmarks[16];
+      const leftAnkle = pose.landmarks[27];
+      const rightAnkle = pose.landmarks[28];
+      this.setUniform("u_nosePosition", "vec2", [nose?.x || 0, nose?.y || 0]);
+      this.setUniform("u_leftWristPosition", "vec2", [leftWrist?.x || 0, leftWrist?.y || 0]);
+      this.setUniform("u_rightWristPosition", "vec2", [rightWrist?.x || 0, rightWrist?.y || 0]);
+      this.setUniform("u_leftAnklePosition", "vec2", [leftAnkle?.x || 0, leftAnkle?.y || 0]);
+      this.setUniform("u_rightAnklePosition", "vec2", [rightAnkle?.x || 0, rightAnkle?.y || 0]);
+    } else {
+      this.setUniform("u_nosePosition", "vec2", [0, 0]);
+      this.setUniform("u_leftWristPosition", "vec2", [0, 0]);
+      this.setUniform("u_rightWristPosition", "vec2", [0, 0]);
+      this.setUniform("u_leftAnklePosition", "vec2", [0, 0]);
+      this.setUniform("u_rightAnklePosition", "vec2", [0, 0]);
+    }
+    const segmentation = video.segmentation;
+    if (segmentation) {
+      this.updateSegmentationTexture(segmentation.mask, segmentation.width, segmentation.height);
+      this.setUniform("u_segmentationRes", "vec2", [segmentation.width, segmentation.height]);
+    } else {
+      this.setUniform("u_segmentationRes", "vec2", [0, 0]);
+    }
+  }
+  /**
+   * Update parameter uniforms from parameter objects
+   */
+  updateParameterUniforms(parameterObjects) {
+    for (const param of this.parameters) {
+      const paramObj = parameterObjects.get(param.uniformName);
+      if (!paramObj) continue;
+      const value = paramObj.value;
+      switch (param.type) {
+        case "slider":
+        case "number":
+          this.setUniform(param.uniformName, "float", value);
+          break;
+        case "color":
+          const rgb = this.hexToRgb(value);
+          this.setUniform(param.uniformName, "vec3", rgb);
+          break;
+        case "toggle":
+          this.setUniform(param.uniformName, "bool", value);
+          break;
+        case "select":
+          const index = param.config.options?.indexOf(value) || 0;
+          this.setUniform(param.uniformName, "int", index);
+          break;
+        case "image":
+          if (value) {
+            this.updateImageTexture(param.uniformName, value);
+          }
+          break;
+      }
+    }
+  }
+  /**
+   * Set uniform value
+   */
+  setUniform(name, type, value) {
+    const location = this.uniformLocations.get(name);
+    if (location === null || location === void 0) {
+      return;
+    }
+    const gl = this.gl;
+    switch (type) {
+      case "float":
+        gl.uniform1f(location, value);
+        break;
+      case "int":
+        gl.uniform1i(location, value);
+        break;
+      case "bool":
+        gl.uniform1i(location, value ? 1 : 0);
+        break;
+      case "vec2":
+        gl.uniform2f(location, value[0], value[1]);
+        break;
+      case "vec3":
+        gl.uniform3f(location, value[0], value[1], value[2]);
+        break;
+      case "vec4":
+        gl.uniform4f(location, value[0], value[1], value[2], value[3]);
+        break;
+    }
+  }
+  /**
+   * Convert hex color to RGB [0-1]
+   */
+  hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    if (result) {
+      return [
+        parseInt(result[1], 16) / 255,
+        parseInt(result[2], 16) / 255,
+        parseInt(result[3], 16) / 255
+      ];
+    }
+    return [0, 0, 0];
+  }
+  /**
+   * Update audio FFT texture
+   */
+  updateAudioFFTTexture(frequencyData) {
+    const gl = this.gl;
+    const unit = this.textureUnits.get("u_audioFFT");
+    if (!this.audioFFTTexture) {
+      this.audioFFTTexture = gl.createTexture();
+    }
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    gl.bindTexture(gl.TEXTURE_2D, this.audioFFTTexture);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.LUMINANCE,
+      frequencyData.length,
+      1,
+      0,
+      gl.LUMINANCE,
+      gl.UNSIGNED_BYTE,
+      frequencyData
+    );
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    const location = this.uniformLocations.get("u_audioFFT");
+    if (location) {
+      gl.uniform1i(location, unit);
+    }
+  }
+  /**
+   * Update video texture
+   */
+  updateVideoTexture(videoFrame) {
+    const gl = this.gl;
+    const unit = this.textureUnits.get("u_video");
+    if (!this.videoTexture) {
+      this.videoTexture = gl.createTexture();
+    }
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    gl.bindTexture(gl.TEXTURE_2D, this.videoTexture);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      videoFrame
+    );
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    const location = this.uniformLocations.get("u_video");
+    if (location) {
+      gl.uniform1i(location, unit);
+    }
+  }
+  /**
+   * Update segmentation mask texture
+   */
+  updateSegmentationTexture(mask, width, height) {
+    const gl = this.gl;
+    const unit = this.textureUnits.get("u_segmentationMask");
+    if (!this.segmentationTexture) {
+      this.segmentationTexture = gl.createTexture();
+    }
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    gl.bindTexture(gl.TEXTURE_2D, this.segmentationTexture);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.LUMINANCE,
+      width,
+      height,
+      0,
+      gl.LUMINANCE,
+      gl.UNSIGNED_BYTE,
+      mask
+    );
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    const location = this.uniformLocations.get("u_segmentationMask");
+    if (location) {
+      gl.uniform1i(location, unit);
+    }
+  }
+  /**
+   * Update image parameter texture
+   */
+  updateImageTexture(name, imageBitmap) {
+    const gl = this.gl;
+    if (!this.textureUnits.has(name)) {
+      this.textureUnits.set(name, this.nextTextureUnit++);
+    }
+    const unit = this.textureUnits.get(name);
+    if (!this.textures.has(name)) {
+      const texture2 = gl.createTexture();
+      if (texture2) {
+        this.textures.set(name, texture2);
+      }
+    }
+    const texture = this.textures.get(name);
+    if (!texture) return;
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      imageBitmap
+    );
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    const location = this.uniformLocations.get(name);
+    if (location) {
+      gl.uniform1i(location, unit);
+    }
+  }
+  /**
+   * Handle canvas resize
+   */
+  resize(width, height) {
+    const gl = this.gl;
+    gl.viewport(0, 0, width, height);
+    if (this.backbufferEnabled) {
+      this.createBackbufferFramebuffers();
+    }
+  }
+  /**
+   * Get parameter definitions for host
+   */
+  getParameterDefinitions() {
+    return this.parameters;
+  }
+}
 class VijiWorkerRuntime {
   canvas = null;
   ctx = null;
@@ -1684,13 +2958,12 @@ class VijiWorkerRuntime {
   }
   /**
    * Initialize P5.js mode
-   * Lazy-loads P5WorkerAdapter and sets up P5 rendering
+   * Sets up P5 rendering with P5WorkerAdapter
    */
   async initP5Mode(setup, render) {
     try {
       this.rendererType = "p5";
       this.debugLog("🎨 Initializing P5.js mode...");
-      const { P5WorkerAdapter } = await import("./renderers/P5WorkerAdapter-B4koBeZd.js");
       this.p5Adapter = new P5WorkerAdapter(
         this.canvas,
         this.viji,
@@ -1719,7 +2992,6 @@ class VijiWorkerRuntime {
     try {
       this.rendererType = "shader";
       this.debugLog("🎨 Initializing Shader mode...");
-      const { ShaderWorkerAdapter } = await import("./renderers/ShaderWorkerAdapter-Cn60jh9g.js");
       this.shaderAdapter = new ShaderWorkerAdapter(
         this.canvas,
         this.viji,
@@ -2232,4 +3504,4 @@ async function setSceneCode(sceneCode) {
   }
 }
 self.setSceneCode = setSceneCode;
-//# sourceMappingURL=viji.worker-kGDstU5X.js.map
+//# sourceMappingURL=viji.worker-DHpeQQ14.js.map