@viji-dev/core 0.2.6 → 0.2.8

package/dist/assets/viji.worker-BjMgRS7D.js

@@ -0,0 +1,2150 @@
+class ParameterSystem {
+  // Parameter system for Phase 2 (new object-based approach)
+  parameterDefinitions = /* @__PURE__ */ new Map();
+  parameterGroups = /* @__PURE__ */ new Map();
+  parameterValues = /* @__PURE__ */ new Map();
+  parameterObjects = /* @__PURE__ */ new Map();
+  // Maps parameter names to their objects
+  parametersDefined = false;
+  initialValuesSynced = false;
+  // Track if initial values have been synced from host
+  // Debug logging control
+  debugMode = false;
+  /**
+   * Enable or disable debug logging
+   */
+  setDebugMode(enabled) {
+    this.debugMode = enabled;
+  }
+  /**
+   * Debug logging helper
+   */
+  debugLog(message, ...args) {
+    if (this.debugMode) {
+      console.log(message, ...args);
+    }
+  }
+  // Message posting callback
+  postMessageCallback;
+  constructor(postMessageCallback) {
+    this.postMessageCallback = postMessageCallback;
+  }
+  // Parameter helper function implementations (return parameter objects)
+  createSliderParameter(defaultValue, config) {
+    const paramName = config.label;
+    const sliderObject = {
+      value: defaultValue,
+      min: config.min ?? 0,
+      max: config.max ?? 100,
+      step: config.step ?? 1,
+      label: config.label,
+      description: config.description ?? "",
+      group: config.group ?? "general",
+      category: config.category ?? "general"
+    };
+    const definition = {
+      type: "slider",
+      defaultValue,
+      label: sliderObject.label,
+      description: sliderObject.description,
+      group: sliderObject.group,
+      category: sliderObject.category,
+      config: {
+        min: sliderObject.min,
+        max: sliderObject.max,
+        step: sliderObject.step
+      }
+    };
+    this.storeParameterDefinition(paramName, definition);
+    this.parameterObjects.set(paramName, sliderObject);
+    return sliderObject;
+  }
+  createColorParameter(defaultValue, config) {
+    const paramName = config.label;
+    const colorObject = {
+      value: defaultValue,
+      label: config.label,
+      description: config.description ?? "",
+      group: config.group ?? "general",
+      category: config.category ?? "general"
+    };
+    const definition = {
+      type: "color",
+      defaultValue,
+      label: colorObject.label,
+      description: colorObject.description,
+      group: colorObject.group,
+      category: colorObject.category
+    };
+    this.storeParameterDefinition(paramName, definition);
+    this.parameterObjects.set(paramName, colorObject);
+    return colorObject;
+  }
+  createToggleParameter(defaultValue, config) {
+    const paramName = config.label;
+    const toggleObject = {
+      value: defaultValue,
+      label: config.label,
+      description: config.description ?? "",
+      group: config.group ?? "general",
+      category: config.category ?? "general"
+    };
+    const definition = {
+      type: "toggle",
+      defaultValue,
+      label: toggleObject.label,
+      description: toggleObject.description,
+      group: toggleObject.group,
+      category: toggleObject.category
+    };
+    this.storeParameterDefinition(paramName, definition);
+    this.parameterObjects.set(paramName, toggleObject);
+    return toggleObject;
+  }
+  createSelectParameter(defaultValue, config) {
+    const paramName = config.label;
+    const selectObject = {
+      value: defaultValue,
+      options: config.options,
+      label: config.label,
+      description: config.description ?? "",
+      group: config.group ?? "general",
+      category: config.category ?? "general"
+    };
+    const definition = {
+      type: "select",
+      defaultValue,
+      label: selectObject.label,
+      description: selectObject.description,
+      group: selectObject.group,
+      category: selectObject.category,
+      config: {
+        options: selectObject.options
+      }
+    };
+    this.storeParameterDefinition(paramName, definition);
+    this.parameterObjects.set(paramName, selectObject);
+    return selectObject;
+  }
+  createTextParameter(defaultValue, config) {
+    const paramName = config.label;
+    const textObject = {
+      value: defaultValue,
+      maxLength: config.maxLength ?? 1e3,
+      label: config.label,
+      description: config.description ?? "",
+      group: config.group ?? "general",
+      category: config.category ?? "general"
+    };
+    const definition = {
+      type: "text",
+      defaultValue,
+      label: textObject.label,
+      description: textObject.description,
+      group: textObject.group,
+      category: textObject.category,
+      config: {
+        maxLength: textObject.maxLength
+      }
+    };
+    this.storeParameterDefinition(paramName, definition);
+    this.parameterObjects.set(paramName, textObject);
+    return textObject;
+  }
+  createNumberParameter(defaultValue, config) {
+    const paramName = config.label;
+    const numberObject = {
+      value: defaultValue,
+      min: config.min ?? 0,
+      max: config.max ?? 100,
+      step: config.step ?? 1,
+      label: config.label,
+      description: config.description ?? "",
+      group: config.group ?? "general",
+      category: config.category ?? "general"
+    };
+    const definition = {
+      type: "number",
+      defaultValue,
+      label: numberObject.label,
+      description: numberObject.description,
+      group: numberObject.group,
+      category: numberObject.category,
+      config: {
+        min: numberObject.min,
+        max: numberObject.max,
+        step: numberObject.step
+      }
+    };
+    this.storeParameterDefinition(paramName, definition);
+    this.parameterObjects.set(paramName, numberObject);
+    return numberObject;
+  }
+  createImageParameter(defaultValue, config) {
+    const paramName = config.label;
+    const imageObject = {
+      value: defaultValue,
+      label: config.label,
+      description: config.description ?? "",
+      group: config.group ?? "general",
+      category: config.category ?? "general"
+    };
+    const definition = {
+      type: "image",
+      defaultValue,
+      label: imageObject.label,
+      description: imageObject.description,
+      group: imageObject.group,
+      category: imageObject.category
+    };
+    this.storeParameterDefinition(paramName, definition);
+    this.parameterObjects.set(paramName, imageObject);
+    return imageObject;
+  }
+  storeParameterDefinition(name, definition) {
+    this.parameterDefinitions.set(name, definition);
+    this.parameterValues.set(name, definition.defaultValue);
+  }
+  updateParameterValue(name, value) {
+    const definition = this.parameterDefinitions.get(name);
+    if (!definition) {
+      console.warn(`Unknown parameter: ${name}. Available parameters:`, Array.from(this.parameterDefinitions.keys()));
+      return false;
+    }
+    if (!this.validateParameterValue(name, value, definition)) {
+      console.warn(`Validation failed for parameter ${name} = ${value}`);
+      return false;
+    }
+    const currentValue = this.parameterValues.get(name);
+    const isInitialSync = !this.initialValuesSynced;
+    if (currentValue === value && !isInitialSync) {
+      return false;
+    }
+    this.parameterValues.set(name, value);
+    const parameterObject = this.parameterObjects.get(name);
+    if (parameterObject) {
+      parameterObject.value = value;
+    }
+    return true;
+  }
+  validateParameterValue(name, value, definition) {
+    if (definition.validate && !definition.validate(value)) {
+      console.error(`Custom validation failed for parameter '${name}': ${value}`);
+      return false;
+    }
+    switch (definition.type) {
+      case "slider":
+      case "number":
+        if (typeof value !== "number" || isNaN(value)) {
+          console.error(`Parameter '${name}' must be a number, got: ${value}`);
+          return false;
+        }
+        if (definition.config?.min !== void 0 && value < definition.config.min) {
+          console.error(`Parameter '${name}' value ${value} is below minimum ${definition.config.min}`);
+          return false;
+        }
+        if (definition.config?.max !== void 0 && value > definition.config.max) {
+          console.error(`Parameter '${name}' value ${value} is above maximum ${definition.config.max}`);
+          return false;
+        }
+        break;
+      case "color":
+        if (typeof value !== "string" || !/^#[0-9A-Fa-f]{6}$/.test(value)) {
+          console.error(`Parameter '${name}' must be a valid hex color, got: ${value}`);
+          return false;
+        }
+        break;
+      case "toggle":
+        if (typeof value !== "boolean") {
+          console.error(`Parameter '${name}' must be a boolean, got: ${value}`);
+          return false;
+        }
+        break;
+      case "select":
+        if (!definition.config?.options || !definition.config.options.includes(value)) {
+          console.error(`Parameter '${name}' value ${value} is not in options: ${definition.config?.options}`);
+          return false;
+        }
+        break;
+      case "text":
+        if (typeof value !== "string") {
+          console.error(`Parameter '${name}' must be a string, got: ${value}`);
+          return false;
+        }
+        if (definition.config?.maxLength && value.length > definition.config.maxLength) {
+          console.error(`Parameter '${name}' text too long: ${value.length} > ${definition.config.maxLength}`);
+          return false;
+        }
+        break;
+      case "image":
+        if (value !== null && !(value instanceof ImageBitmap) && !(value instanceof OffscreenCanvas)) {
+          console.error(`Parameter '${name}' must be null, ImageBitmap, or OffscreenCanvas, got: ${value}`);
+          return false;
+        }
+        break;
+    }
+    return true;
+  }
+  // Reset parameter state (called when loading new scene)
+  resetParameterState() {
+    this.parametersDefined = false;
+    this.initialValuesSynced = false;
+    this.parameterDefinitions.clear();
+    this.parameterGroups.clear();
+    this.parameterValues.clear();
+    this.parameterObjects.clear();
+  }
+  // Send all parameters (from helper functions) to host
+  sendAllParametersToHost() {
+    if (this.parametersDefined || this.parameterDefinitions.size === 0) {
+      return;
+    }
+    try {
+      const groups = /* @__PURE__ */ new Map();
+      for (const [paramName, paramDef] of this.parameterDefinitions) {
+        const groupName = paramDef.group || "general";
+        if (!groups.has(groupName)) {
+          const category = paramDef.category || "general";
+          groups.set(groupName, {
+            groupName,
+            category,
+            parameters: {}
+          });
+        }
+        const group = groups.get(groupName);
+        group.parameters[paramName] = paramDef;
+      }
+      this.parametersDefined = true;
+      this.postMessageCallback("parameters-defined", {
+        groups: Array.from(groups.values())
+      });
+      this.debugLog(`All parameters sent to host: ${this.parameterDefinitions.size} parameters in ${groups.size} groups`);
+    } catch (error) {
+      this.postMessageCallback("parameter-validation-error", {
+        message: `Failed to send parameters to host: ${error.message}`,
+        code: "PARAMETER_SENDING_ERROR"
+      });
+    }
+  }
+  // Mark initial values as synced
+  markInitialValuesSynced() {
+    this.initialValuesSynced = true;
+  }
+  // Get parameter count for performance reporting
+  getParameterCount() {
+    return this.parameterDefinitions.size;
+  }
+  // Get all parameter objects (for P5 adapter to add .p5 properties)
+  getAllParameterObjects() {
+    return this.parameterObjects;
+  }
+}
+class InteractionSystem {
+  // Interaction enabled state
+  isEnabled = true;
+  // Mouse interaction state
+  mouseState = {
+    x: 0,
+    y: 0,
+    isInCanvas: false,
+    isPressed: false,
+    leftButton: false,
+    rightButton: false,
+    middleButton: false,
+    velocity: { x: 0, y: 0 },
+    deltaX: 0,
+    deltaY: 0,
+    wheelDelta: 0,
+    wheelX: 0,
+    wheelY: 0,
+    wasPressed: false,
+    wasReleased: false,
+    wasMoved: false
+  };
+  // Keyboard interaction state
+  keyboardState = {
+    isPressed: (key) => this.keyboardState.activeKeys.has(key.toLowerCase()),
+    wasPressed: (key) => this.keyboardState.pressedThisFrame.has(key.toLowerCase()),
+    wasReleased: (key) => this.keyboardState.releasedThisFrame.has(key.toLowerCase()),
+    activeKeys: /* @__PURE__ */ new Set(),
+    pressedThisFrame: /* @__PURE__ */ new Set(),
+    releasedThisFrame: /* @__PURE__ */ new Set(),
+    lastKeyPressed: "",
+    lastKeyReleased: "",
+    shift: false,
+    ctrl: false,
+    alt: false,
+    meta: false
+  };
+  // Touch interaction state
+  touchState = {
+    points: [],
+    count: 0,
+    started: [],
+    moved: [],
+    ended: [],
+    primary: null,
+    gestures: {
+      isPinching: false,
+      isRotating: false,
+      isPanning: false,
+      isTapping: false,
+      pinchScale: 1,
+      pinchDelta: 0,
+      rotationAngle: 0,
+      rotationDelta: 0,
+      panDelta: { x: 0, y: 0 },
+      tapCount: 0,
+      lastTapTime: 0,
+      tapPosition: null
+    }
+  };
+  constructor() {
+    this.handleMouseUpdate = this.handleMouseUpdate.bind(this);
+    this.handleKeyboardUpdate = this.handleKeyboardUpdate.bind(this);
+    this.handleTouchUpdate = this.handleTouchUpdate.bind(this);
+    this.frameStart = this.frameStart.bind(this);
+  }
+  /**
+   * Get the interaction APIs for inclusion in the viji object
+   */
+  getInteractionAPIs() {
+    return {
+      mouse: this.mouseState,
+      keyboard: this.keyboardState,
+      touches: this.touchState
+    };
+  }
+  /**
+   * Called at the start of each frame to reset frame-based events
+   */
+  frameStart() {
+    this.mouseState.wasPressed = false;
+    this.mouseState.wasReleased = false;
+    this.mouseState.wasMoved = false;
+    this.mouseState.wheelDelta = 0;
+    this.mouseState.wheelX = 0;
+    this.mouseState.wheelY = 0;
+    this.keyboardState.pressedThisFrame.clear();
+    this.keyboardState.releasedThisFrame.clear();
+    this.touchState.started = [];
+    this.touchState.moved = [];
+    this.touchState.ended = [];
+    this.touchState.gestures.isTapping = false;
+    this.touchState.gestures.pinchDelta = 0;
+    this.touchState.gestures.rotationDelta = 0;
+  }
+  /**
+   * Handle mouse update messages from the host
+   */
+  handleMouseUpdate(data) {
+    if (!this.isEnabled) return;
+    this.mouseState.x = data.x;
+    this.mouseState.y = data.y;
+    this.mouseState.isInCanvas = data.isInCanvas !== void 0 ? data.isInCanvas : true;
+    this.mouseState.leftButton = (data.buttons & 1) !== 0;
+    this.mouseState.rightButton = (data.buttons & 2) !== 0;
+    this.mouseState.middleButton = (data.buttons & 4) !== 0;
+    this.mouseState.isPressed = data.buttons > 0;
+    this.mouseState.deltaX = data.deltaX || 0;
+    this.mouseState.deltaY = data.deltaY || 0;
+    this.mouseState.wheelDelta = data.wheelDeltaY || 0;
+    this.mouseState.wheelX = data.wheelDeltaX || 0;
+    this.mouseState.wheelY = data.wheelDeltaY || 0;
+    this.mouseState.velocity.x = data.deltaX || 0;
+    this.mouseState.velocity.y = data.deltaY || 0;
+    this.mouseState.wasPressed = data.wasPressed || false;
+    this.mouseState.wasReleased = data.wasReleased || false;
+    this.mouseState.wasMoved = data.deltaX !== 0 || data.deltaY !== 0;
+  }
+  /**
+   * Handle keyboard update messages from the host
+   */
+  handleKeyboardUpdate(data) {
+    if (!this.isEnabled) return;
+    const key = data.key.toLowerCase();
+    if (data.type === "keydown") {
+      if (!this.keyboardState.activeKeys.has(key)) {
+        this.keyboardState.activeKeys.add(key);
+        this.keyboardState.pressedThisFrame.add(key);
+        this.keyboardState.lastKeyPressed = data.key;
+      }
+    } else if (data.type === "keyup") {
+      this.keyboardState.activeKeys.delete(key);
+      this.keyboardState.releasedThisFrame.add(key);
+      this.keyboardState.lastKeyReleased = data.key;
+    }
+    this.keyboardState.shift = data.shiftKey;
+    this.keyboardState.ctrl = data.ctrlKey;
+    this.keyboardState.alt = data.altKey;
+    this.keyboardState.meta = data.metaKey;
+  }
+  /**
+   * Handle touch update messages from the host
+   */
+  handleTouchUpdate(data) {
+    if (!this.isEnabled) return;
+    this.touchState.started = [];
+    this.touchState.moved = [];
+    this.touchState.ended = [];
+    const touches = data.touches.map((touch) => ({
+      id: touch.identifier,
+      x: touch.clientX,
+      y: touch.clientY,
+      pressure: touch.pressure || 0,
+      radius: Math.max(touch.radiusX || 0, touch.radiusY || 0),
+      radiusX: touch.radiusX || 0,
+      radiusY: touch.radiusY || 0,
+      rotationAngle: touch.rotationAngle || 0,
+      force: touch.force || touch.pressure || 0,
+      deltaX: 0,
+      // Could be calculated if we track previous positions
+      deltaY: 0,
+      velocity: { x: 0, y: 0 },
+      // Could be calculated if we track movement
+      isNew: data.type === "touchstart",
+      isActive: true,
+      isEnding: data.type === "touchend" || data.type === "touchcancel"
+    }));
+    this.touchState.points = touches;
+    this.touchState.count = touches.length;
+    this.touchState.primary = touches[0] || null;
+    if (data.type === "touchstart") {
+      this.touchState.started = touches;
+    } else if (data.type === "touchmove") {
+      this.touchState.moved = touches;
+    } else if (data.type === "touchend" || data.type === "touchcancel") {
+      this.touchState.ended = touches;
+    }
+    this.touchState.gestures = {
+      isPinching: false,
+      isRotating: false,
+      isPanning: false,
+      isTapping: false,
+      pinchScale: 1,
+      pinchDelta: 0,
+      rotationAngle: 0,
+      rotationDelta: 0,
+      panDelta: { x: 0, y: 0 },
+      tapCount: 0,
+      lastTapTime: 0,
+      tapPosition: null
+    };
+  }
+  /**
+   * Reset all interaction state (called when loading new scene)
+   */
+  resetInteractionState() {
+    Object.assign(this.mouseState, {
+      x: 0,
+      y: 0,
+      isInCanvas: false,
+      isPressed: false,
+      leftButton: false,
+      rightButton: false,
+      middleButton: false,
+      velocity: { x: 0, y: 0 },
+      deltaX: 0,
+      deltaY: 0,
+      wheelDelta: 0,
+      wheelX: 0,
+      wheelY: 0,
+      wasPressed: false,
+      wasReleased: false,
+      wasMoved: false
+    });
+    this.keyboardState.activeKeys.clear();
+    this.keyboardState.pressedThisFrame.clear();
+    this.keyboardState.releasedThisFrame.clear();
+    this.keyboardState.lastKeyPressed = "";
+    this.keyboardState.lastKeyReleased = "";
+    this.keyboardState.shift = false;
+    this.keyboardState.ctrl = false;
+    this.keyboardState.alt = false;
+    this.keyboardState.meta = false;
+    this.touchState.points = [];
+    this.touchState.count = 0;
+    this.touchState.started = [];
+    this.touchState.moved = [];
+    this.touchState.ended = [];
+    this.touchState.primary = null;
+    Object.assign(this.touchState.gestures, {
+      isPinching: false,
+      isRotating: false,
+      isPanning: false,
+      isTapping: false,
+      pinchScale: 1,
+      pinchDelta: 0,
+      rotationAngle: 0,
+      rotationDelta: 0,
+      panDelta: { x: 0, y: 0 },
+      tapCount: 0,
+      lastTapTime: 0,
+      tapPosition: null
+    });
+  }
+  /**
+   * Enable or disable interaction processing
+   */
+  setInteractionEnabled(enabled) {
+    this.isEnabled = enabled;
+    if (!enabled) {
+      this.resetInteractionStates();
+    }
+  }
+  /**
+   * Get current interaction enabled state
+   */
+  getInteractionEnabled() {
+    return this.isEnabled;
+  }
+  /**
+   * Reset all interaction states to default values
+   */
+  resetInteractionStates() {
+    this.mouseState.x = 0;
+    this.mouseState.y = 0;
+    this.mouseState.isInCanvas = false;
+    this.mouseState.isPressed = false;
+    this.mouseState.leftButton = false;
+    this.mouseState.rightButton = false;
+    this.mouseState.middleButton = false;
+    this.mouseState.velocity.x = 0;
+    this.mouseState.velocity.y = 0;
+    this.mouseState.deltaX = 0;
+    this.mouseState.deltaY = 0;
+    this.mouseState.wheelDelta = 0;
+    this.mouseState.wheelX = 0;
+    this.mouseState.wheelY = 0;
+    this.mouseState.wasPressed = false;
+    this.mouseState.wasReleased = false;
+    this.mouseState.wasMoved = false;
+    this.keyboardState.activeKeys.clear();
+    this.keyboardState.pressedThisFrame.clear();
+    this.keyboardState.releasedThisFrame.clear();
+    this.keyboardState.lastKeyPressed = "";
+    this.keyboardState.lastKeyReleased = "";
+    this.keyboardState.shift = false;
+    this.keyboardState.ctrl = false;
+    this.keyboardState.alt = false;
+    this.keyboardState.meta = false;
+    this.touchState.points = [];
+    this.touchState.count = 0;
+    this.touchState.started = [];
+    this.touchState.moved = [];
+    this.touchState.ended = [];
+    this.touchState.primary = null;
+    this.touchState.gestures.isPinching = false;
+    this.touchState.gestures.isRotating = false;
+    this.touchState.gestures.isPanning = false;
+    this.touchState.gestures.isTapping = false;
+    this.touchState.gestures.pinchScale = 1;
+    this.touchState.gestures.pinchDelta = 0;
+    this.touchState.gestures.rotationAngle = 0;
+    this.touchState.gestures.rotationDelta = 0;
+    this.touchState.gestures.panDelta = { x: 0, y: 0 };
+    this.touchState.gestures.tapCount = 0;
+    this.touchState.gestures.lastTapTime = 0;
+    this.touchState.gestures.tapPosition = null;
+  }
+}
+class CVSystem {
+  // MediaPipe Tasks Vision worker
+  cvWorker = null;
+  workerRestartCount = 0;
+  maxWorkerRestarts = 3;
+  workerLastRestart = 0;
+  workerRestartCooldown = 5e3;
+  // 5 seconds
+  // Feature activation state
+  activeFeatures = /* @__PURE__ */ new Set();
+  pendingFeatures = /* @__PURE__ */ new Set();
+  // Features to restore after restart
+  // CV Results cache (for non-blocking processing)
+  results = {
+    faces: [],
+    hands: [],
+    pose: null,
+    segmentation: null
+  };
+  // Processing state and performance tracking
+  processing = false;
+  cvFrameCounter = 0;
+  cvFrameRateMode = "quarter";
+  // Default: 1/4 scene rate
+  sceneTargetFPS = 60;
+  // Will be updated from scene processing rate
+  processingStartTime = 0;
+  processingTimes = [];
+  // CV Frame Rate Tracking (similar to main core)
+  cvFrameTimes = [];
+  lastCVFrameTime = 0;
+  actualCVFPS = 0;
+  debugMode = false;
+  // Debug mode disabled for production
+  constructor() {
+    this.debugLog("🔧 CVSystem initialized for MediaPipe Tasks Vision");
+  }
+  debugLog(...args) {
+    if (this.debugMode) {
+      console.log("🔧 [CVSystem]", ...args);
+    }
+  }
+  setDebugMode(enabled) {
+    this.debugMode = enabled;
+    this.debugLog(`Debug mode ${enabled ? "enabled" : "disabled"}`);
+  }
+  /**
+   * Update CV frame rate configuration (called from worker)
+   */
+  updateCVFrameRate(mode, sceneTargetFPS) {
+    this.cvFrameRateMode = mode;
+    this.sceneTargetFPS = sceneTargetFPS;
+    this.debugLog(`CV frame rate updated: mode=${mode}, sceneTargetFPS=${sceneTargetFPS}`);
+  }
+  /**
+   * Initialize MediaPipe Tasks Vision worker
+   */
+  async ensureCVWorker() {
+    if (this.cvWorker) return;
+    try {
+      this.debugLog("🔧 Creating MediaPipe Tasks Vision worker...");
+      const workerUrl = "/dist/assets/cv-tasks.worker.js";
+      this.cvWorker = new Worker(workerUrl);
+      this.cvWorker.addEventListener("message", (evt) => {
+        const msg = evt.data;
+        this.debugLog(`📨 [CV Worker -> CVSystem] ${msg.type}`, msg.success ? msg.data : msg.error);
+      });
+      this.cvWorker.onerror = (err) => {
+        this.debugLog("❌ CV worker error event", err.message);
+        this.handleWorkerFailure(`Worker error: ${err.message}`);
+      };
+      this.cvWorker.onmessageerror = (err) => {
+        this.debugLog("❌ CV worker message error", err);
+        this.handleWorkerFailure("Worker message error");
+      };
+      await this.postToCV("init", {});
+      this.debugLog("✅ CV worker initialized");
+    } catch (error) {
+      this.debugLog("❌ Failed to initialize CV worker:", error);
+      throw error;
+    }
+  }
+  /**
+   * Handle worker failure and attempt restart
+   */
+  async handleWorkerFailure(reason) {
+    this.debugLog(`⚠️ CV Worker failure: ${reason}`);
+    if (this.cvWorker) {
+      this.cvWorker.terminate();
+      this.cvWorker = null;
+    }
+    const now = Date.now();
+    if (this.workerRestartCount >= this.maxWorkerRestarts) {
+      this.debugLog("❌ Max worker restarts exceeded, giving up");
+      return;
+    }
+    if (now - this.workerLastRestart < this.workerRestartCooldown) {
+      this.debugLog("⏱️ Worker restart cooldown active, skipping restart");
+      return;
+    }
+    this.pendingFeatures = new Set(this.activeFeatures);
+    this.activeFeatures.clear();
+    try {
+      this.workerRestartCount++;
+      this.workerLastRestart = now;
+      this.debugLog(`🔄 Restarting CV worker (attempt ${this.workerRestartCount}/${this.maxWorkerRestarts})`);
+      await this.ensureCVWorker();
+      if (this.pendingFeatures.size > 0) {
+        const featuresToRestore = Array.from(this.pendingFeatures);
+        this.debugLog(`🔄 Restoring features: [${featuresToRestore.join(", ")}]`);
+        try {
+          await this.postToCV("config", { features: featuresToRestore });
+          this.activeFeatures = new Set(this.pendingFeatures);
+          this.debugLog("✅ Features restored successfully");
+        } catch (error) {
+          this.debugLog("❌ Failed to restore features:", error);
+        }
+        this.pendingFeatures.clear();
+      }
+      this.debugLog("✅ CV worker restarted successfully");
+    } catch (error) {
+      this.debugLog("❌ Failed to restart CV worker:", error);
+    }
+  }
+  /**
+   * Send message to CV worker and wait for response
+   */
+  postToCV(type, data, transfer) {
+    return new Promise((resolve, reject) => {
+      if (!this.cvWorker) {
+        return reject(new Error("CV worker not initialized"));
+      }
+      const timeout = setTimeout(() => {
+        this.debugLog(`⏱️ [CV Worker] timeout for ${type}`);
+        if (type === "config") {
+          this.handleWorkerFailure(`Timeout for ${type} message`);
+        }
+        reject(new Error(`CV worker timeout for ${type}`));
+      }, 5e3);
+      const onMessage = (ev) => {
+        const msg = ev.data;
+        if (msg.type === "result") {
+          clearTimeout(timeout);
+          this.cvWorker.removeEventListener("message", onMessage);
+          if (msg.success) {
+            this.debugLog(`✅ [CV Worker] response for ${type}`, msg.data);
+            resolve(msg.data);
+          } else {
+            this.debugLog(`❌ [CV Worker] error response for ${type}`, msg.error);
+            if (msg.restartRequired) {
+              this.handleWorkerFailure(`Worker reported restart required: ${msg.error}`);
+            }
+            reject(new Error(msg.error || "CV worker error"));
+          }
+        }
+      };
+      this.cvWorker.addEventListener("message", onMessage);
+      const message = {
+        type,
+        ...data
+      };
+      this.debugLog(`📤 [CVSystem -> CV Worker] ${type}`, data);
+      this.cvWorker.postMessage(message, transfer || []);
+    });
+  }
+  /**
+   * Enable face detection feature (bounding boxes only)
+   */
+  async enableFaceDetection() {
+    if (this.activeFeatures.has("faceDetection")) return;
+    try {
+      this.debugLog("🔧 Enabling face detection...");
+      if (this.activeFeatures.size >= 3 && !this.checkWebGLContextAvailability()) {
+        this.debugLog("⚠️ Warning: WebGL contexts may be running low. Consider disabling unused CV features.");
+      }
+      await this.ensureCVWorker();
+      const newFeatures = Array.from(this.activeFeatures).concat(["faceDetection"]);
+      await this.postToCV("config", { features: newFeatures });
+      this.activeFeatures.add("faceDetection");
+      this.debugLog("✅ Face detection enabled");
+    } catch (error) {
+      this.debugLog("❌ Failed to enable face detection:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disable face detection and cleanup
+   */
+  async disableFaceDetection() {
+    if (!this.activeFeatures.has("faceDetection")) return;
+    try {
+      this.debugLog("🔧 Disabling face detection...");
+      this.activeFeatures.delete("faceDetection");
+      if (!this.activeFeatures.has("faceMesh")) {
+        this.results.faces = [];
+      }
+      const newFeatures = Array.from(this.activeFeatures);
+      await this.postToCV("config", { features: newFeatures });
+      this.debugLog("✅ Face detection disabled and cleaned up");
+    } catch (error) {
+      this.debugLog("❌ Failed to disable face detection:", error);
+      throw error;
+    }
+  }
+  /**
+   * Enable face mesh feature (468-point facial landmarks)
+   */
+  async enableFaceMesh() {
+    if (this.activeFeatures.has("faceMesh")) return;
+    try {
+      this.debugLog("🔧 Enabling face mesh...");
+      if (this.activeFeatures.size >= 3 && !this.checkWebGLContextAvailability()) {
+        this.debugLog("⚠️ Warning: WebGL contexts may be running low. Consider disabling unused CV features.");
+      }
+      await this.ensureCVWorker();
+      const newFeatures = Array.from(this.activeFeatures).concat(["faceMesh"]);
+      await this.postToCV("config", { features: newFeatures });
+      this.activeFeatures.add("faceMesh");
+      this.debugLog("✅ Face mesh enabled");
+    } catch (error) {
+      this.debugLog("❌ Failed to enable face mesh:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disable face mesh and cleanup
+   */
+  async disableFaceMesh() {
+    if (!this.activeFeatures.has("faceMesh")) return;
+    try {
+      this.debugLog("🔧 Disabling face mesh...");
+      this.activeFeatures.delete("faceMesh");
+      if (!this.activeFeatures.has("faceDetection")) {
+        this.results.faces = [];
+      }
+      const newFeatures = Array.from(this.activeFeatures);
+      await this.postToCV("config", { features: newFeatures });
+      this.debugLog("✅ Face mesh disabled and cleaned up");
+    } catch (error) {
+      this.debugLog("❌ Failed to disable face mesh:", error);
+      throw error;
+    }
+  }
+  /**
+   * Enable hand tracking feature
+   */
+  async enableHandTracking() {
+    if (this.activeFeatures.has("handTracking")) return;
+    try {
+      this.debugLog("🔧 Enabling hand tracking...");
+      await this.ensureCVWorker();
+      const newFeatures = Array.from(this.activeFeatures).concat(["handTracking"]);
+      await this.postToCV("config", { features: newFeatures });
+      this.activeFeatures.add("handTracking");
+      this.debugLog("✅ Hand tracking enabled");
+    } catch (error) {
+      this.debugLog("❌ Failed to enable hand tracking:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disable hand tracking and cleanup
+   */
+  async disableHandTracking() {
+    if (!this.activeFeatures.has("handTracking")) return;
+    try {
+      this.debugLog("🔧 Disabling hand tracking...");
+      this.activeFeatures.delete("handTracking");
+      this.results.hands = [];
+      const newFeatures = Array.from(this.activeFeatures);
+      await this.postToCV("config", { features: newFeatures });
+      this.debugLog("✅ Hand tracking disabled and cleaned up");
+    } catch (error) {
+      this.debugLog("❌ Failed to disable hand tracking:", error);
+      throw error;
+    }
+  }
+  /**
+   * Enable pose detection feature
+   */
+  async enablePoseDetection() {
+    if (this.activeFeatures.has("poseDetection")) return;
+    try {
+      this.debugLog("🔧 Enabling pose detection...");
+      await this.ensureCVWorker();
+      const newFeatures = Array.from(this.activeFeatures).concat(["poseDetection"]);
+      await this.postToCV("config", { features: newFeatures });
+      this.activeFeatures.add("poseDetection");
+      this.debugLog("✅ Pose detection enabled");
+    } catch (error) {
+      this.debugLog("❌ Failed to enable pose detection:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disable pose detection and cleanup
+   */
+  async disablePoseDetection() {
+    if (!this.activeFeatures.has("poseDetection")) return;
+    try {
+      this.debugLog("🔧 Disabling pose detection...");
+      this.activeFeatures.delete("poseDetection");
+      this.results.pose = null;
+      const newFeatures = Array.from(this.activeFeatures);
+      await this.postToCV("config", { features: newFeatures });
+      this.debugLog("✅ Pose detection disabled and cleaned up");
+    } catch (error) {
+      this.debugLog("❌ Failed to disable pose detection:", error);
+      throw error;
+    }
+  }
+  /**
+   * Enable body segmentation feature
+   */
+  async enableBodySegmentation() {
+    if (this.activeFeatures.has("bodySegmentation")) return;
+    try {
+      this.debugLog("🔧 Enabling body segmentation...");
+      await this.ensureCVWorker();
+      const newFeatures = Array.from(this.activeFeatures).concat(["bodySegmentation"]);
+      await this.postToCV("config", { features: newFeatures });
+      this.activeFeatures.add("bodySegmentation");
+      this.debugLog("✅ Body segmentation enabled");
+    } catch (error) {
+      this.debugLog("❌ Failed to enable body segmentation:", error);
+      throw error;
+    }
+  }
+  /**
+   * Disable body segmentation and cleanup
+   */
+  async disableBodySegmentation() {
+    if (!this.activeFeatures.has("bodySegmentation")) return;
+    try {
+      this.debugLog("🔧 Disabling body segmentation...");
+      this.activeFeatures.delete("bodySegmentation");
+      this.results.segmentation = null;
+      const newFeatures = Array.from(this.activeFeatures);
+      await this.postToCV("config", { features: newFeatures });
+      this.debugLog("✅ Body segmentation disabled and cleaned up");
+    } catch (error) {
+      this.debugLog("❌ Failed to disable body segmentation:", error);
+      throw error;
+    }
+  }
+  /**
+   * Process video frame with active CV features
+   */
+  async processFrame(bitmap) {
+    if (this.processing || this.activeFeatures.size === 0) {
+      return;
+    }
+    this.cvFrameCounter++;
+    const shouldProcess = this.shouldProcessFrame();
+    if (!shouldProcess) {
+      return;
+    }
+    this.processing = true;
+    this.processingStartTime = performance.now();
+    this.trackCVFrameRate();
+    this.debugLog(`🎬 Processing frame ${this.cvFrameCounter} with features:`, Array.from(this.activeFeatures));
+    try {
+      const features = Array.from(this.activeFeatures);
+      const timestamp = performance.now();
+      const processPromise = this.postToCV("process", {
+        bitmap,
+        timestamp,
+        features
+      }, [bitmap]);
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("CV processing timeout")), 500);
+      });
+      const results = await Promise.race([processPromise, timeoutPromise]);
+      if (results.faces && (this.activeFeatures.has("faceDetection") || this.activeFeatures.has("faceMesh"))) {
+        this.results.faces = results.faces;
+        this.debugLog(`📥 Received ${results.faces.length} face results`);
+      }
+      if (results.hands && this.activeFeatures.has("handTracking")) {
+        this.results.hands = results.hands;
+        this.debugLog(`📥 Received ${results.hands.length} hand results`);
+      }
+      if (results.pose && this.activeFeatures.has("poseDetection")) {
+        this.results.pose = results.pose;
+        this.debugLog(`📥 Received pose results with ${results.pose.landmarks.length} landmarks`);
+      }
+      if (results.segmentation && this.activeFeatures.has("bodySegmentation")) {
+        this.results.segmentation = results.segmentation;
+        this.debugLog(`📥 Received segmentation results ${results.segmentation.width}x${results.segmentation.height}`);
+      }
+      const processingTime = performance.now() - this.processingStartTime;
+      this.processingTimes.push(processingTime);
+      if (this.processingTimes.length > 30) {
+        this.processingTimes.shift();
+      }
+    } catch (error) {
+      this.debugLog("⚠️ CV processing failed:", error);
+    } finally {
+      this.processing = false;
+    }
+  }
+  /**
+   * Check if current frame should be processed based on CV frame rate mode
+   */
+  shouldProcessFrame() {
+    const divisor = this.getFrameRateDivisor();
+    return this.cvFrameCounter % divisor === 0;
+  }
+  /**
+   * Track CV processing frame rate (similar to main core)
+   */
+  trackCVFrameRate() {
+    const now = performance.now();
+    if (this.lastCVFrameTime > 0) {
+      const deltaTime = now - this.lastCVFrameTime;
+      this.cvFrameTimes.push(deltaTime);
+      if (this.cvFrameTimes.length > 30) {
+        this.cvFrameTimes.shift();
+      }
+      if (this.cvFrameTimes.length > 0) {
+        const avgDeltaTime = this.cvFrameTimes.reduce((a, b) => a + b, 0) / this.cvFrameTimes.length;
+        this.actualCVFPS = Math.round(1e3 / avgDeltaTime);
+      }
+    }
+    this.lastCVFrameTime = now;
+  }
+  /**
+   * Get frame rate divisor based on current mode
+   */
+  getFrameRateDivisor() {
+    switch (this.cvFrameRateMode) {
+      case "full":
+        return 1;
+      case "half":
+        return 2;
+      case "quarter":
+        return 4;
+      case "eighth":
+        return 8;
+      default:
+        return 4;
+    }
+  }
+  /**
+   * Get current CV results
+   */
+  getResults() {
+    return { ...this.results };
+  }
+  /**
+   * Get processing statistics
+   */
+  getStats() {
+    const avgProcessingTime = this.processingTimes.length > 0 ? this.processingTimes.reduce((a, b) => a + b, 0) / this.processingTimes.length : 0;
+    const targetFPS = this.sceneTargetFPS / this.getFrameRateDivisor();
+    return {
+      activeFeatures: Array.from(this.activeFeatures),
+      processingTime: avgProcessingTime,
+      effectiveFPS: targetFPS,
+      actualFPS: this.actualCVFPS,
+      // Add actual measured CV FPS
+      isProcessing: this.processing
+    };
+  }
+  /**
+   * Check WebGL context availability before enabling features
+   */
+  checkWebGLContextAvailability() {
+    try {
+      const canvas = new OffscreenCanvas(1, 1);
+      const gl = canvas.getContext("webgl");
+      if (!gl) {
+        this.debugLog("⚠️ WebGL contexts may be exhausted");
+        return false;
+      }
+      const ext = gl.getExtension("WEBGL_lose_context");
+      if (ext) ext.loseContext();
+      return true;
+    } catch (error) {
+      this.debugLog("⚠️ WebGL context check failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Get CV control interface for artist API
+   */
+  getControlInterface() {
+    return {
+      enableFaceDetection: (enabled) => {
+        if (enabled === false) {
+          return this.disableFaceDetection();
+        } else {
+          return this.enableFaceDetection();
+        }
+      },
+      disableFaceDetection: () => this.disableFaceDetection(),
+      enableFaceMesh: (enabled) => {
+        if (enabled === false) {
+          return this.disableFaceMesh();
+        } else {
+          return this.enableFaceMesh();
+        }
+      },
+      disableFaceMesh: () => this.disableFaceMesh(),
+      enableHandTracking: (enabled) => {
+        if (enabled === false) {
+          return this.disableHandTracking();
+        } else {
+          return this.enableHandTracking();
+        }
+      },
+      disableHandTracking: () => this.disableHandTracking(),
+      enablePoseDetection: (enabled) => {
+        if (enabled === false) {
+          return this.disablePoseDetection();
+        } else {
+          return this.enablePoseDetection();
+        }
+      },
+      disablePoseDetection: () => this.disablePoseDetection(),
+      enableBodySegmentation: (enabled) => {
+        if (enabled === false) {
+          return this.disableBodySegmentation();
+        } else {
+          return this.enableBodySegmentation();
+        }
+      },
+      disableBodySegmentation: () => this.disableBodySegmentation(),
+      getActiveFeatures: () => Array.from(this.activeFeatures),
+      isProcessing: () => this.processing,
+      getStats: () => this.getStats(),
+      getWorkerStatus: () => ({
+        healthy: !!this.cvWorker,
+        restartCount: this.workerRestartCount,
+        maxRestarts: this.maxWorkerRestarts
+      }),
+      restartWorker: () => this.handleWorkerFailure("Manual restart requested"),
+      // WebGL context monitoring
+      checkWebGLAvailability: () => this.checkWebGLContextAvailability(),
+      getResourceUsage: () => ({
+        activeFeatures: this.activeFeatures.size,
+        estimatedWebGLContexts: this.activeFeatures.size * 2,
+        // ~2 contexts per feature
+        webglAvailable: this.checkWebGLContextAvailability()
+      })
+    };
+  }
+  /**
+   * Cleanup all CV resources
+   */
+  async cleanup() {
+    this.debugLog("🔧 Cleaning up CVSystem...");
+    for (const feature of Array.from(this.activeFeatures)) {
+      switch (feature) {
+        case "faceDetection":
+          await this.disableFaceDetection();
+          break;
+        case "handTracking":
+          await this.disableHandTracking();
+          break;
+        case "poseDetection":
+          await this.disablePoseDetection();
+          break;
+        case "bodySegmentation":
+          await this.disableBodySegmentation();
+          break;
+      }
+    }
+    if (this.cvWorker) {
+      this.cvWorker.terminate();
+      this.cvWorker = null;
+    }
+    this.activeFeatures.clear();
+    this.pendingFeatures.clear();
+    this.workerRestartCount = 0;
+    this.results.faces = [];
+    this.results.hands = [];
+    this.results.pose = null;
+    this.results.segmentation = null;
+    this.processing = false;
+    this.processingTimes = [];
+    this.debugLog("✅ CVSystem cleanup complete");
+  }
+}
+class VideoSystem {
+  // ✅ CORRECT: Worker-owned OffscreenCanvas (transferred from host)
+  offscreenCanvas = null;
+  ctx = null;
+  gl = null;
+  // CV processing helpers
+  cvScratchCanvas = null;
+  cvScratchContext = null;
+  // Debug logging control
+  debugMode = false;
+  /**
+   * Enable or disable debug logging
+   */
+  setDebugMode(enabled) {
+    this.debugMode = enabled;
+    if (this.cvSystem) {
+      this.cvSystem.setDebugMode(enabled);
+    }
+  }
+  /**
+   * Debug logging helper
+   */
+  debugLog(message, ...args) {
+    if (this.debugMode) {
+      console.log(message, ...args);
+    }
+  }
+  // Frame processing configuration
+  targetFrameRate = 30;
+  // Default target FPS for video processing
+  lastFrameTime = 0;
+  frameInterval = 1e3 / this.targetFrameRate;
+  // ms between frames
+  // Processing state
+  hasLoggedFirstFrame = false;
+  frameCount = 0;
+  // Video state for artist API
+  videoState = {
+    isConnected: false,
+    currentFrame: null,
+    frameWidth: 0,
+    frameHeight: 0,
+    frameRate: 0,
+    frameData: null
+  };
+  // Phase 11 - CV System Integration
+  cvSystem;
+  constructor() {
+    this.cvSystem = new CVSystem();
+  }
+  /**
+   * Get the video API for inclusion in the viji object
+   */
+  getVideoAPI() {
+    const cvResults = this.cvSystem.getResults();
+    return {
+      isConnected: this.videoState.isConnected,
+      currentFrame: this.videoState.currentFrame,
+      frameWidth: this.videoState.frameWidth,
+      frameHeight: this.videoState.frameHeight,
+      frameRate: this.videoState.frameRate,
+      getFrameData: () => this.videoState.frameData,
+      // CV Results from CVSystem
+      faces: cvResults.faces,
+      hands: cvResults.hands,
+      pose: cvResults.pose,
+      segmentation: cvResults.segmentation,
+      // CV Control Interface
+      cv: this.cvSystem.getControlInterface()
+    };
+  }
+  /**
+   * ✅ CORRECT: Receive OffscreenCanvas transfer from host
+   */
+  handleCanvasSetup(data) {
+    try {
+      this.disconnectVideo();
+      this.offscreenCanvas = data.offscreenCanvas;
+      this.ctx = this.offscreenCanvas.getContext("2d", {
+        willReadFrequently: true
+        // Optimize for frequent getImageData calls
+      });
+      if (!this.ctx) {
+        throw new Error("Failed to get 2D context from transferred OffscreenCanvas");
+      }
+      try {
+        this.gl = this.offscreenCanvas.getContext("webgl2") || this.offscreenCanvas.getContext("webgl");
+      } catch (e) {
+        this.debugLog("WebGL not available, using 2D context only");
+      }
+      this.videoState.isConnected = true;
+      this.videoState.currentFrame = this.offscreenCanvas;
+      this.videoState.frameWidth = data.width;
+      this.videoState.frameHeight = data.height;
+      this.frameCount = 0;
+      this.hasLoggedFirstFrame = false;
+      this.debugLog("✅ OffscreenCanvas received and setup completed (worker-side)", {
+        width: data.width,
+        height: data.height,
+        hasWebGL: !!this.gl,
+        targetFrameRate: this.targetFrameRate
+      });
+      this.debugLog("🎬 CORRECT OffscreenCanvas approach - Worker has full GPU access!");
+    } catch (error) {
+      console.error("Failed to setup OffscreenCanvas in worker:", error);
+      this.disconnectVideo();
+    }
+  }
+  /**
+   * ✅ CORRECT: Receive ImageBitmap frame and draw to worker's OffscreenCanvas
+   */
+  handleFrameUpdate(data) {
+    if (!this.offscreenCanvas || !this.ctx) {
+      console.warn("🔴 Received frame but OffscreenCanvas not setup");
+      return;
+    }
+    try {
+      if (this.frameCount % 150 === 0) {
+        this.debugLog("✅ Worker received ImageBitmap frame:", {
+          bitmapSize: `${data.imageBitmap.width}x${data.imageBitmap.height}`,
+          canvasSize: `${this.offscreenCanvas.width}x${this.offscreenCanvas.height}`,
+          frameCount: this.frameCount,
+          timestamp: data.timestamp
+        });
+      }
+      this.ctx.drawImage(data.imageBitmap, 0, 0, this.offscreenCanvas.width, this.offscreenCanvas.height);
+      this.processCurrentFrame(data.timestamp);
+      data.imageBitmap.close();
+      this.frameCount++;
+    } catch (error) {
+      console.error("🔴 Error processing video frame (worker-side):", error);
+    }
+  }
+  /**
+   * Process current frame (called when new frame is drawn)
+   */
+  async processCurrentFrame(timestamp) {
+    if (!this.offscreenCanvas || !this.ctx) {
+      return;
+    }
+    try {
+      this.videoState.frameData = this.ctx.getImageData(
+        0,
+        0,
+        this.offscreenCanvas.width,
+        this.offscreenCanvas.height
+      );
+      const deltaTime = timestamp - this.lastFrameTime;
+      this.videoState.frameRate = deltaTime > 0 ? 1e3 / deltaTime : 0;
+      if (!this.hasLoggedFirstFrame) {
+        this.debugLog(`🎯 Worker-side OffscreenCanvas processing active: ${this.videoState.frameRate.toFixed(1)} FPS (${this.offscreenCanvas.width}x${this.offscreenCanvas.height})`);
+        this.debugLog("✅ Full GPU access available for custom effects and CV analysis");
+        this.hasLoggedFirstFrame = true;
+      }
+      if (this.videoState.frameData) {
+        try {
+          const bitmap = await createImageBitmap(this.videoState.frameData);
+          this.cvSystem.processFrame(bitmap);
+        } catch (bitmapError) {
+          this.debugLog("⚠️ createImageBitmap failed – falling back to reusable CV canvas:", bitmapError);
+          if (!this.cvScratchCanvas || !this.cvScratchContext || this.cvScratchCanvas.width !== this.videoState.frameData.width || this.cvScratchCanvas.height !== this.videoState.frameData.height) {
+            this.cvScratchCanvas = new OffscreenCanvas(
+              this.videoState.frameData.width,
+              this.videoState.frameData.height
+            );
+            this.cvScratchContext = this.cvScratchCanvas.getContext("2d");
+            if (!this.cvScratchContext) {
+              throw new Error("Failed to get 2D context for CV fallback canvas");
+            }
+          }
+          this.cvScratchContext.putImageData(this.videoState.frameData, 0, 0);
+          const fallbackBitmap = this.cvScratchCanvas.transferToImageBitmap();
+          this.cvSystem.processFrame(fallbackBitmap);
+        }
+      }
+      this.lastFrameTime = timestamp;
+    } catch (error) {
+      console.error("Error processing video frame (worker-side):", error);
+    }
+  }
+  /**
+   * Handle video configuration updates (including disconnection and resize)
+   */
+  handleVideoConfigUpdate(data) {
+    try {
+      if (data.disconnect) {
+        this.disconnectVideo();
+        return;
+      }
+      if (data.width && data.height && this.offscreenCanvas) {
+        this.resizeCanvas(data.width, data.height);
+      }
+      if (data.targetFrameRate) {
+        this.updateProcessingConfig(data.targetFrameRate);
+      }
+      if (data.cvFrameRate) {
+        this.updateCVFrameRate(data.cvFrameRate);
+      }
+    } catch (error) {
+      console.error("Error handling video config update:", error);
+    }
+  }
+  /**
+   * Resize the OffscreenCanvas (when video dimensions change)
+   */
+  resizeCanvas(width, height) {
+    if (!this.offscreenCanvas) return;
+    try {
+      this.offscreenCanvas.width = width;
+      this.offscreenCanvas.height = height;
+      this.videoState.frameWidth = width;
+      this.videoState.frameHeight = height;
+      if (this.gl) {
+        this.gl.viewport(0, 0, width, height);
+      }
+      this.debugLog(`📐 OffscreenCanvas resized to ${width}x${height} (worker-side)`);
+    } catch (error) {
+      console.error("Error resizing OffscreenCanvas:", error);
+    }
+  }
+  /**
+   * Disconnect video and clean up resources
+   */
+  disconnectVideo() {
+    if (this.offscreenCanvas && this.ctx) {
+      this.ctx.clearRect(0, 0, this.offscreenCanvas.width, this.offscreenCanvas.height);
+      this.debugLog("🧹 Cleared OffscreenCanvas on disconnect");
+    }
+    this.offscreenCanvas = null;
+    this.ctx = null;
+    this.gl = null;
+    this.videoState.isConnected = false;
+    this.videoState.currentFrame = null;
+    this.videoState.frameWidth = 0;
+    this.videoState.frameHeight = 0;
+    this.videoState.frameRate = 0;
+    this.videoState.frameData = null;
+    this.cvScratchCanvas = null;
+    this.cvScratchContext = null;
+    this.hasLoggedFirstFrame = false;
+    this.frameCount = 0;
+    this.debugLog("Video disconnected (worker-side)");
+  }
+  /**
+   * Update video processing configuration
+   */
+  updateProcessingConfig(targetFrameRate) {
+    this.targetFrameRate = Math.max(1, Math.min(60, targetFrameRate));
+    this.frameInterval = 1e3 / this.targetFrameRate;
+    this.debugLog(`Video processing frame rate updated to ${this.targetFrameRate} FPS (worker-side)`);
+  }
+  /**
+   * Phase 11 - Update CV frame rate configuration
+   */
+  updateCVFrameRate(cvFrameRate) {
+    this.cvSystem.updateCVFrameRate(cvFrameRate.mode, cvFrameRate.sceneTargetFPS);
+    this.debugLog(`CV frame rate updated to ${cvFrameRate.mode} of ${cvFrameRate.sceneTargetFPS} FPS (worker-side)`);
+  }
+  /**
+   * Reset all video state (called when loading new scene)
+   */
+  resetVideoState() {
+    this.disconnectVideo();
+    if (this.cvSystem) {
+      this.cvSystem.cleanup();
+    }
+  }
+  /**
+   * Get current processing configuration
+   */
+  getProcessingConfig() {
+    return {
+      targetFrameRate: this.targetFrameRate,
+      frameInterval: this.frameInterval,
+      frameCount: this.frameCount
+    };
+  }
+  /**
+   * Get WebGL context for advanced effects (if available)
+   */
+  getWebGLContext() {
+    return this.gl;
+  }
+  /**
+   * ✅ WORKER API: Artists can access the OffscreenCanvas directly for custom effects
+   */
+  getCanvasForArtistEffects() {
+    return this.offscreenCanvas;
+  }
+  /**
+   * Get CV processing statistics
+   */
+  getCVStats() {
+    return this.cvSystem.getStats();
+  }
+}
+class VijiWorkerRuntime {
+  canvas = null;
+  ctx = null;
+  gl = null;
+  isRunning = false;
+  frameCount = 0;
+  lastTime = 0;
+  startTime = 0;
+  frameRateMode = "full";
+  skipNextFrame = false;
+  screenRefreshRate = 60;
+  // Will be detected
+  // Debug logging control
+  debugMode = false;
+  // P5.js adapter for P5 mode
+  p5Adapter = null;
+  rendererType = "native";
+  /**
+   * Enable or disable debug logging
+   */
+  setDebugMode(enabled) {
+    this.debugMode = enabled;
+    if (this.videoSystem) this.videoSystem.setDebugMode(enabled);
+    if (this.parameterSystem && "setDebugMode" in this.parameterSystem) {
+      this.parameterSystem.setDebugMode(enabled);
+    }
+    if (this.interactionSystem && "setDebugMode" in this.interactionSystem) {
+      this.interactionSystem.setDebugMode(enabled);
+    }
+  }
+  /**
+   * Debug logging helper
+   */
+  debugLog(message, ...args) {
+    if (this.debugMode) {
+      console.log(message, ...args);
+    }
+  }
+  // Effective refresh rate tracking
+  effectiveFrameTimes = [];
+  lastEffectiveRateReport = 0;
+  effectiveRateReportInterval = 1e3;
+  // Report every 1 second
+  // Parameter system
+  parameterSystem;
+  // Interaction system (Phase 7)
+  interactionSystem;
+  // Video system (Phase 10) - worker-side video processing
+  videoSystem;
+  // Audio state (Phase 5) - receives analysis results from host
+  audioState = {
+    isConnected: false,
+    volume: { rms: 0, peak: 0 },
+    bands: {
+      bass: 0,
+      mid: 0,
+      treble: 0,
+      subBass: 0,
+      lowMid: 0,
+      highMid: 0,
+      presence: 0,
+      brilliance: 0
+    },
+    frequencyData: new Uint8Array(0)
+  };
+  // Video state is now managed by the worker-side VideoSystem
+  // Artist API object
+  viji = {
+    // Canvas (will be set during init)
+    canvas: null,
+    ctx: null,
+    gl: null,
+    width: 0,
+    height: 0,
+    pixelRatio: 1,
+    // Timing
+    time: 0,
+    deltaTime: 0,
+    frameCount: 0,
+    fps: 60,
+    // Audio API (Phase 5) - will be set in constructor
+    audio: {},
+    video: {
+      isConnected: false,
+      currentFrame: null,
+      frameWidth: 0,
+      frameHeight: 0,
+      frameRate: 0,
+      getFrameData: () => null,
+      faces: [],
+      hands: []
+    },
+    // Interaction APIs will be added during construction
+    mouse: {},
+    keyboard: {},
+    touches: {},
+    // Parameter helper functions (return parameter objects) - delegate to parameter system
+    slider: (defaultValue, config) => {
+      return this.parameterSystem.createSliderParameter(defaultValue, config);
+    },
+    color: (defaultValue, config) => {
+      return this.parameterSystem.createColorParameter(defaultValue, config);
+    },
+    toggle: (defaultValue, config) => {
+      return this.parameterSystem.createToggleParameter(defaultValue, config);
+    },
+    select: (defaultValue, config) => {
+      return this.parameterSystem.createSelectParameter(defaultValue, config);
+    },
+    text: (defaultValue, config) => {
+      return this.parameterSystem.createTextParameter(defaultValue, config);
+    },
+    number: (defaultValue, config) => {
+      return this.parameterSystem.createNumberParameter(defaultValue, config);
+    },
+    image: (defaultValue, config) => {
+      return this.parameterSystem.createImageParameter(defaultValue, config);
+    },
+    // Context selection
+    useContext: (type) => {
+      if (type === "2d") {
+        if (!this.ctx && this.canvas) {
+          this.ctx = this.canvas.getContext("2d");
+          this.viji.ctx = this.ctx;
+        }
+        return this.ctx;
+      } else if (type === "webgl") {
+        if (!this.gl && this.canvas) {
+          this.gl = this.canvas.getContext("webgl2") || this.canvas.getContext("webgl");
+          this.viji.gl = this.gl;
+          if (this.gl) {
+            this.gl.viewport(0, 0, this.viji.width, this.viji.height);
+          }
+        }
+        return this.gl;
+      }
+      return null;
+    }
+  };
+  constructor() {
+    this.parameterSystem = new ParameterSystem((type, data) => {
+      this.postMessage(type, data);
+    });
+    this.interactionSystem = new InteractionSystem();
+    this.videoSystem = new VideoSystem();
+    Object.assign(this.viji, this.interactionSystem.getInteractionAPIs());
+    Object.assign(this.viji.video, this.videoSystem.getVideoAPI());
+    this.viji.audio = {
+      ...this.audioState,
+      getFrequencyData: () => this.audioState.frequencyData
+    };
+    this.setupMessageHandling();
+  }
+  /**
+   * Initialize P5.js mode
+   * Lazy-loads P5WorkerAdapter and sets up P5 rendering
+   */
+  async initP5Mode(setup, render) {
+    try {
+      this.rendererType = "p5";
+      this.debugLog("🎨 Initializing P5.js mode...");
+      const { P5WorkerAdapter } = await import("./P5WorkerAdapter-bO_02bv6.js");
+      this.p5Adapter = new P5WorkerAdapter(
+        this.canvas,
+        this.viji,
+        {
+          setup,
+          render
+        }
+      );
+      await this.p5Adapter.init();
+      this.debugLog("✅ P5.js mode initialized successfully");
+    } catch (error) {
+      console.error("❌ Failed to initialize P5.js mode:", error);
+      this.postMessage("error", {
+        message: `P5.js initialization failed: ${error.message}`,
+        code: "P5_INIT_ERROR"
+      });
+      this.rendererType = "native";
+      this.p5Adapter = null;
+    }
+  }
+  // Reset parameter state (called when loading new scene)
+  resetParameterState() {
+    this.parameterSystem.resetParameterState();
+    this.interactionSystem.resetInteractionState();
+    this.audioState = {
+      isConnected: false,
+      volume: { rms: 0, peak: 0 },
+      bands: {
+        bass: 0,
+        mid: 0,
+        treble: 0,
+        subBass: 0,
+        lowMid: 0,
+        highMid: 0,
+        presence: 0,
+        brilliance: 0
+      },
+      frequencyData: new Uint8Array(0)
+    };
+    this.viji.audio = {
+      ...this.audioState,
+      getFrequencyData: () => this.audioState.frequencyData
+    };
+    this.videoSystem.resetVideoState();
+    Object.assign(this.viji.video, this.videoSystem.getVideoAPI());
+  }
+  // Send all parameters (from helper functions) to host
+  sendAllParametersToHost() {
+    this.parameterSystem.sendAllParametersToHost();
+  }
+  setupMessageHandling() {
+    self.onmessage = (event) => {
+      const message = event.data;
+      switch (message.type) {
+        case "init":
+          this.handleInit(message);
+          break;
+        case "frame-rate-update":
+          this.handleFrameRateUpdate(message);
+          break;
+        case "refresh-rate-update":
+          this.handleRefreshRateUpdate(message);
+          break;
+        case "cv-frame-rate-update":
+          this.handleCVFrameRateUpdate(message);
+          break;
+        case "resolution-update":
+          this.handleResolutionUpdate(message);
+          break;
+        case "set-scene-code":
+          this.handleSetSceneCode(message);
+          break;
+        case "debug-mode":
+          this.setDebugMode(message.data.enabled);
+          break;
+        case "parameter-update":
+          this.handleParameterUpdate(message);
+          break;
+        case "parameter-batch-update":
+          this.handleParameterBatchUpdate(message);
+          break;
+        case "stream-update":
+          this.handleStreamUpdate(message);
+          break;
+        case "audio-analysis-update":
+          this.handleAudioAnalysisUpdate(message);
+          break;
+        case "video-canvas-setup":
+          this.handleVideoCanvasSetup(message);
+          break;
+        case "video-frame-update":
+          this.handleVideoFrameUpdate(message);
+          break;
+        case "video-config-update":
+          this.handleVideoConfigUpdate(message);
+          break;
+        case "mouse-update":
+          this.handleMouseUpdate(message);
+          break;
+        case "keyboard-update":
+          this.handleKeyboardUpdate(message);
+          break;
+        case "touch-update":
+          this.handleTouchUpdate(message);
+          break;
+        case "interaction-enabled":
+          this.handleInteractionEnabled(message);
+          break;
+        case "performance-update":
+          this.handlePerformanceUpdate(message);
+          break;
+        case "capture-frame":
+          this.handleCaptureFrame(message);
+          break;
+      }
+    };
+  }
+  handleInit(message) {
+    try {
+      this.canvas = message.data.canvas;
+      this.viji.canvas = this.canvas;
+      this.viji.width = this.canvas.width;
+      this.viji.height = this.canvas.height;
+      this.startRenderLoop();
+      this.postMessage("init-response", {
+        id: message.id
+      });
+      this.postMessage("ready", {
+        rendererType: this.rendererType,
+        canvasSize: { width: this.canvas.width, height: this.canvas.height }
+      });
+    } catch (error) {
+      this.postMessage("error", {
+        id: message.id,
+        message: error.message,
+        code: "INIT_ERROR"
+      });
+    }
+  }
+  handleFrameRateUpdate(message) {
+    if (message.data && message.data.mode) {
+      this.frameRateMode = message.data.mode;
+      this.debugLog("Frame rate mode updated to:", message.data.mode);
+    }
+  }
+  handleRefreshRateUpdate(message) {
+    if (message.data && message.data.screenRefreshRate) {
+      this.screenRefreshRate = message.data.screenRefreshRate;
+      this.debugLog("Screen refresh rate updated to:", message.data.screenRefreshRate + "Hz");
+    }
+  }
+  handleCVFrameRateUpdate(message) {
+    if (message.data && message.data.mode) {
+      const sceneProcessingFPS = this.frameRateMode === "full" ? this.screenRefreshRate : this.screenRefreshRate / 2;
+      if (this.videoSystem) {
+        this.videoSystem.handleVideoConfigUpdate({
+          cvFrameRate: {
+            mode: message.data.mode,
+            sceneTargetFPS: sceneProcessingFPS
+          },
+          timestamp: performance.now()
+        });
+      }
+      this.debugLog(`CV frame rate updated to: ${message.data.mode} of ${sceneProcessingFPS} FPS scene processing`);
+    }
+  }
+  trackEffectiveFrameTime(currentTime) {
+    this.effectiveFrameTimes.push(currentTime);
+    if (this.effectiveFrameTimes.length > 60) {
+      this.effectiveFrameTimes.shift();
+    }
+  }
+  reportPerformanceStats(currentTime) {
+    if (currentTime - this.lastEffectiveRateReport >= this.effectiveRateReportInterval) {
+      if (this.effectiveFrameTimes.length >= 2) {
+        const totalTime = this.effectiveFrameTimes[this.effectiveFrameTimes.length - 1] - this.effectiveFrameTimes[0];
+        const frameCount = this.effectiveFrameTimes.length - 1;
+        const effectiveRefreshRate = Math.round(frameCount / totalTime * 1e3);
+        const cvStats = this.videoSystem.getCVStats();
+        this.postMessage("performance-update", {
+          effectiveRefreshRate,
+          frameRateMode: this.frameRateMode,
+          screenRefreshRate: this.screenRefreshRate,
+          rendererType: this.rendererType,
+          parameterCount: this.parameterSystem.getParameterCount(),
+          // Include CV stats if available
+          cv: cvStats ? {
+            activeFeatures: cvStats.activeFeatures,
+            processingTime: cvStats.processingTime,
+            targetFPS: cvStats.effectiveFPS,
+            actualFPS: cvStats.actualFPS,
+            isProcessing: cvStats.isProcessing
+          } : void 0
+        });
+      }
+      this.lastEffectiveRateReport = currentTime;
+    }
+  }
+  handleResolutionUpdate(message) {
+    if (message.data) {
+      if (this.canvas) {
+        this.canvas.width = Math.round(message.data.effectiveWidth);
+        this.canvas.height = Math.round(message.data.effectiveHeight);
+      }
+      this.viji.width = Math.round(message.data.effectiveWidth);
+      this.viji.height = Math.round(message.data.effectiveHeight);
+      if (this.gl) {
+        this.gl.viewport(0, 0, this.viji.width, this.viji.height);
+      }
+      if (this.p5Adapter && this.rendererType === "p5") {
+        this.p5Adapter.resize(this.viji.width, this.viji.height);
+      }
+      this.debugLog("Canvas resolution updated to:", this.viji.width + "x" + this.viji.height);
+    }
+  }
+  handleParameterUpdate(message) {
+    if (message.data && message.data.name !== void 0 && message.data.value !== void 0) {
+      this.parameterSystem.updateParameterValue(message.data.name, message.data.value);
+    }
+  }
+  handleParameterBatchUpdate(message) {
+    if (message.data && message.data.updates) {
+      for (const update of message.data.updates) {
+        this.parameterSystem.updateParameterValue(update.name, update.value);
+      }
+      this.parameterSystem.markInitialValuesSynced();
+      this.debugLog("Parameter system initialized successfully");
+    }
+  }
+  handleStreamUpdate(message) {
+    this.debugLog("Stream update:", message.data);
+  }
+  handleAudioAnalysisUpdate(message) {
+    this.audioState = {
+      isConnected: message.data.isConnected,
+      volume: message.data.volume,
+      bands: message.data.bands,
+      frequencyData: new Uint8Array(message.data.frequencyData)
+    };
+    this.viji.audio = {
+      ...this.audioState,
+      getFrequencyData: () => this.audioState.frequencyData
+    };
+  }
+  handleVideoCanvasSetup(message) {
+    this.videoSystem.handleCanvasSetup({
+      offscreenCanvas: message.data.offscreenCanvas,
+      width: message.data.width,
+      height: message.data.height,
+      timestamp: message.data.timestamp
+    });
+    Object.assign(this.viji.video, this.videoSystem.getVideoAPI());
+  }
+  handleVideoFrameUpdate(message) {
+    this.videoSystem.handleFrameUpdate({
+      imageBitmap: message.data.imageBitmap,
+      timestamp: message.data.timestamp
+    });
+    Object.assign(this.viji.video, this.videoSystem.getVideoAPI());
+  }
+  handleVideoConfigUpdate(message) {
+    this.videoSystem.handleVideoConfigUpdate({
+      ...message.data.targetFrameRate && { targetFrameRate: message.data.targetFrameRate },
+      ...message.data.cvConfig && { cvConfig: message.data.cvConfig },
+      ...message.data.width && { width: message.data.width },
+      ...message.data.height && { height: message.data.height },
+      ...message.data.disconnect && { disconnect: message.data.disconnect },
+      timestamp: message.data.timestamp
+    });
+    Object.assign(this.viji.video, this.videoSystem.getVideoAPI());
+  }
+  handlePerformanceUpdate(message) {
+    this.debugLog("Performance update:", message.data);
+  }
+  /**
+   * Handle capture-frame request from host.
+   * Produces an ArrayBuffer (image bytes) to send back as transferable.
+   */
+  async handleCaptureFrame(message) {
+    try {
+      if (!this.canvas) {
+        throw new Error("Canvas not initialized");
+      }
+      const mimeType = message.data.type || "image/jpeg";
+      const srcWidth = this.canvas.width;
+      const srcHeight = this.canvas.height;
+      let targetWidth = srcWidth;
+      let targetHeight = srcHeight;
+      if (typeof message.data.resolution === "number") {
+        const scale = message.data.resolution > 0 ? message.data.resolution : 1;
+        targetWidth = Math.max(1, Math.floor(srcWidth * scale));
+        targetHeight = Math.max(1, Math.floor(srcHeight * scale));
+      } else if (message.data.resolution && typeof message.data.resolution === "object") {
+        targetWidth = Math.max(1, Math.floor(message.data.resolution.width));
+        targetHeight = Math.max(1, Math.floor(message.data.resolution.height));
+      }
+      const srcAspect = srcWidth / srcHeight;
+      const dstAspect = targetWidth / targetHeight;
+      let sx = 0;
+      let sy = 0;
+      let sWidth = srcWidth;
+      let sHeight = srcHeight;
+      if (Math.abs(srcAspect - dstAspect) > 1e-6) {
+        if (dstAspect > srcAspect) {
+          sHeight = Math.floor(srcWidth / dstAspect);
+          sy = Math.floor((srcHeight - sHeight) / 2);
+        } else {
+          sWidth = Math.floor(srcHeight * dstAspect);
+          sx = Math.floor((srcWidth - sWidth) / 2);
+        }
+      }
+      const temp = new OffscreenCanvas(targetWidth, targetHeight);
+      const tctx = temp.getContext("2d");
+      if (!tctx) throw new Error("Failed to get 2D context");
+      tctx.drawImage(this.canvas, sx, sy, sWidth, sHeight, 0, 0, targetWidth, targetHeight);
+      const blob = await temp.convertToBlob({ type: mimeType });
+      const arrayBuffer = await blob.arrayBuffer();
+      self.postMessage({
+        type: "capture-frame-result",
+        id: message.id,
+        timestamp: Date.now(),
+        data: {
+          mimeType,
+          buffer: arrayBuffer,
+          width: targetWidth,
+          height: targetHeight
+        }
+      }, [arrayBuffer]);
+    } catch (error) {
+      this.postMessage("error", {
+        id: message.id,
+        message: error.message,
+        code: "CAPTURE_FRAME_ERROR"
+      });
+    }
+  }
+  handleSetSceneCode(message) {
+    if (message.data && message.data.sceneCode) {
+      self.setSceneCode(message.data.sceneCode);
+    }
+  }
+  startRenderLoop() {
+    this.isRunning = true;
+    this.startTime = performance.now();
+    this.lastTime = this.startTime;
+    this.renderFrame();
+  }
+  renderFrame() {
+    if (!this.isRunning) return;
+    const currentTime = performance.now();
+    this.interactionSystem.frameStart();
+    this.viji.fps = this.frameRateMode === "full" ? this.screenRefreshRate : this.screenRefreshRate / 2;
+    let shouldRender = true;
+    if (this.frameRateMode === "half") {
+      shouldRender = !this.skipNextFrame;
+      this.skipNextFrame = !this.skipNextFrame;
+    }
+    if (shouldRender) {
+      this.viji.deltaTime = (currentTime - this.lastTime) / 1e3;
+      this.viji.time = (currentTime - this.startTime) / 1e3;
+      this.viji.frameCount = ++this.frameCount;
+      this.trackEffectiveFrameTime(currentTime);
+      this.lastTime = currentTime;
+      try {
+        if (this.p5Adapter && this.rendererType === "p5") {
+          const parameterObjects = this.parameterSystem.getAllParameterObjects();
+          this.p5Adapter.tick(this.viji, parameterObjects);
+        } else {
+          const renderFunction2 = self.renderFunction;
+          if (renderFunction2 && typeof renderFunction2 === "function") {
+            renderFunction2(this.viji);
+          }
+        }
+      } catch (error) {
+        console.error("Render error:", error);
+        this.postMessage("error", {
+          message: error.message,
+          code: "RENDER_ERROR",
+          stack: error.stack
+        });
+      }
+    }
+    this.reportPerformanceStats(currentTime);
+    requestAnimationFrame(() => this.renderFrame());
+  }
+  postMessage(type, data) {
+    self.postMessage({
+      type,
+      id: data?.id || `${type}_${Date.now()}`,
+      timestamp: Date.now(),
+      data
+    });
+  }
+  // Phase 7: Interaction Message Handlers (delegated to InteractionSystem)
+  handleMouseUpdate(message) {
+    this.interactionSystem.handleMouseUpdate(message.data);
+  }
+  handleKeyboardUpdate(message) {
+    this.interactionSystem.handleKeyboardUpdate(message.data);
+  }
+  handleTouchUpdate(message) {
+    this.interactionSystem.handleTouchUpdate(message.data);
+  }
+  handleInteractionEnabled(message) {
+    this.interactionSystem.setInteractionEnabled(message.data.enabled);
+  }
+}
+class SceneAnalyzer {
+  /**
+   * Detects the renderer type from scene code comments
+   * 
+   * Looks for:
+   * - // @renderer p5
+   * - /* @renderer p5 *\/
+   * 
+   * @param sceneCode - The artist's scene code to analyze
+   * @returns The detected renderer type ('p5' or 'native')
+   */
+  static detectRendererType(sceneCode) {
+    return /\/\/\s*@renderer\s+p5|\/\*\s*@renderer\s+p5\s*\*\//.test(sceneCode) ? "p5" : "native";
+  }
+}
+const runtime = new VijiWorkerRuntime();
+let renderFunction = null;
+async function setSceneCode(sceneCode) {
+  try {
+    runtime.resetParameterState();
+    const rendererType = SceneAnalyzer.detectRendererType(sceneCode);
+    if (rendererType === "p5") {
+      const functionBody = sceneCode + '\nreturn {   setup: typeof setup !== "undefined" ? setup : null,   render: typeof render !== "undefined" ? render : null };';
+      const sceneFunction = new Function("viji", "p5", functionBody);
+      const { setup, render } = sceneFunction(runtime.viji, null);
+      if (!render) {
+        throw new Error("P5 mode requires a render(viji, p5) function");
+      }
+      await runtime.initP5Mode(setup, render);
+      runtime.sendAllParametersToHost();
+    } else {
+      const functionBody = sceneCode + '\nif (typeof render === "function") {\n  return render;\n}\nthrow new Error("Scene code must define a render function");';
+      const sceneFunction = new Function("viji", functionBody);
+      renderFunction = sceneFunction(runtime.viji);
+      self.renderFunction = renderFunction;
+      runtime.sendAllParametersToHost();
+    }
+  } catch (error) {
+    console.error("Failed to load scene code:", error);
+    self.postMessage({
+      type: "error",
+      id: `scene_error_${Date.now()}`,
+      timestamp: Date.now(),
+      data: {
+        message: `Scene code error: ${error.message}`,
+        code: "SCENE_CODE_ERROR"
+      }
+    });
+  }
+}
+self.setSceneCode = setSceneCode;
+//# sourceMappingURL=viji.worker-BjMgRS7D.js.map