@viji-dev/core 0.2.7 → 0.2.8

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

@@ -1,1428 +0,0 @@
-(function() {
-  "use strict";
-  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;
-    }
-    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;
-      }
-      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()),
-          timestamp: performance.now()
-        });
-        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;
-    }
-  }
-  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 VideoSystem {
-    // ✅ CORRECT: Worker-owned OffscreenCanvas (transferred from host)
-    offscreenCanvas = null;
-    ctx = null;
-    gl = null;
-    // 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);
-      }
-    }
-    // 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 preparation - CV processing placeholder
-    cvFeatures = {
-      faceDetection: false,
-      handTracking: false,
-      bodySegmentation: false
-    };
-    cvResults = {
-      faces: [],
-      hands: [],
-      bodySegmentation: null
-    };
-    constructor() {
-    }
-    /**
-     * Get the video API for inclusion in the viji object
-     */
-    getVideoAPI() {
-      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,
-        faces: this.cvResults.faces,
-        hands: this.cvResults.hands
-      };
-    }
-    /**
-     * ✅ 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)
-     */
-    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;
-        }
-        this.performCVAnalysis();
-        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.cvConfig) {
-          this.updateCVConfig(data.cvConfig);
-        }
-      } 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.resetCVResults();
-      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 preparation - Update CV configuration
-     */
-    updateCVConfig(cvConfig) {
-      this.cvFeatures = {
-        faceDetection: cvConfig.faceDetection || false,
-        handTracking: cvConfig.handTracking || false,
-        bodySegmentation: cvConfig.bodySegmentation || false
-      };
-      this.debugLog("CV configuration updated (Phase 11 preparation, worker-side):", this.cvFeatures);
-    }
-    /**
-     * Phase 11 preparation - Perform computer vision analysis
-     */
-    performCVAnalysis() {
-      if (this.cvFeatures.faceDetection) ;
-      if (this.cvFeatures.handTracking) ;
-      if (this.cvFeatures.bodySegmentation) ;
-    }
-    /**
-     * Reset CV results
-     */
-    resetCVResults() {
-      this.cvResults = {
-        faces: [],
-        hands: [],
-        bodySegmentation: null
-      };
-    }
-    /**
-     * Reset all video state (called when loading new scene)
-     */
-    resetVideoState() {
-      this.disconnectVideo();
-      this.resetCVResults();
-    }
-    /**
-     * 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;
-    }
-  }
-  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;
-    /**
-     * 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);
-      },
-      // 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();
-    }
-    // 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 "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("ready", {
-          id: message.id,
-          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");
-      }
-    }
-    trackEffectiveFrameTime(currentTime) {
-      this.effectiveFrameTimes.push(currentTime);
-      if (this.effectiveFrameTimes.length > 60) {
-        this.effectiveFrameTimes.shift();
-      }
-    }
-    reportEffectiveRefreshRate(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);
-          this.postMessage("performance-update", {
-            effectiveRefreshRate,
-            frameRateMode: this.frameRateMode,
-            screenRefreshRate: this.screenRefreshRate,
-            parameterCount: this.parameterSystem.getParameterCount()
-          });
-        }
-        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);
-        }
-        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: 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 {
-          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.reportEffectiveRefreshRate(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);
-    }
-  }
-  const runtime = new VijiWorkerRuntime();
-  let renderFunction = null;
-  function setSceneCode(sceneCode) {
-    try {
-      runtime.resetParameterState();
-      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-BKsgIT1d.js.map