@viji-dev/core 0.3.24 → 0.3.26

package/dist/assets/{viji.worker-Zg128woJ.js → viji.worker-PAf0oIec.js}

@@ -1185,21 +1185,21 @@ class CVSystem {
         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.activeFeatures.has("emotionDetection"))) {
+      if ("faces" in results && (this.activeFeatures.has("faceDetection") || this.activeFeatures.has("faceMesh") || this.activeFeatures.has("emotionDetection"))) {
         this.results.faces = results.faces;
         this.debugLog(`📥 Received ${results.faces.length} face results`);
       }
-      if (results.hands && this.activeFeatures.has("handTracking")) {
+      if ("hands" in results && this.activeFeatures.has("handTracking")) {
         this.results.hands = results.hands;
         this.debugLog(`📥 Received ${results.hands.length} hand results`);
       }
-      if (results.pose && this.activeFeatures.has("poseDetection")) {
+      if ("pose" in results && this.activeFeatures.has("poseDetection")) {
         this.results.pose = results.pose;
-        this.debugLog(`📥 Received pose results with ${results.pose.landmarks.length} landmarks`);
+        this.debugLog(`📥 Received pose results: ${results.pose ? results.pose.landmarks.length + " landmarks" : "none"}`);
       }
-      if (results.segmentation && this.activeFeatures.has("bodySegmentation")) {
+      if ("segmentation" in results && this.activeFeatures.has("bodySegmentation")) {
         this.results.segmentation = results.segmentation;
-        this.debugLog(`📥 Received segmentation results ${results.segmentation.width}x${results.segmentation.height}`);
+        this.debugLog(`📥 Received segmentation: ${results.segmentation ? results.segmentation.width + "x" + results.segmentation.height : "none"}`);
       }
       const processingTime = performance.now() - this.processingStartTime;
       this.processingTimes.push(processingTime);
@@ -2642,11 +2642,11 @@ uniform float u_audioPeak; // Peak amplitude (0-1)
 uniform float u_audioVolumeSmoothed; // Smoothed volume for animation (200ms decay)
 
 // Audio - Frequency Bands (instant)
-uniform float u_audioLow; // Low 20-150 Hz (0-1)
-uniform float u_audioLowMid; // Low-mid 150-400 Hz (0-1)
-uniform float u_audioMid; // Mid 400-2500 Hz (0-1)
-uniform float u_audioHighMid; // High-mid 2500-8000 Hz (0-1)
-uniform float u_audioHigh; // High 8000-20000 Hz (0-1)
+uniform float u_audioLow; // Low 20-120 Hz (0-1)
+uniform float u_audioLowMid; // Low-mid 120-400 Hz (0-1)
+uniform float u_audioMid; // Mid 400-1600 Hz (0-1)
+uniform float u_audioHighMid; // High-mid 1600-6000 Hz (0-1)
+uniform float u_audioHigh; // High 6000-16000 Hz (0-1)
 
 // Audio - Frequency Bands (smoothed, 150ms decay)
 uniform float u_audioLowSmoothed; // Smoothed low band (0-1)
@@ -2683,7 +2683,7 @@ uniform float u_audioBrightness; // Spectral brightness / centroid (0-1)
 uniform float u_audioFlatness; // Spectral flatness / noisiness (0-1)
 
 // Audio - Textures
-uniform sampler2D u_audioFFT; // FFT frequency spectrum (512 bins, 0-255)
+uniform sampler2D u_audioFFT; // FFT frequency spectrum (1024 bins, 0-255)
 uniform sampler2D u_audioWaveform; // Time-domain waveform (fftSize samples, -1 to 1)
 
 // Video
@@ -2823,18 +2823,41 @@ uniform float u_face0TongueOut;
 uniform int u_handCount; // Number of detected hands (0-2)
 uniform vec3 u_leftHandPalm; // Left hand palm position (x, y, z)
 uniform vec3 u_rightHandPalm; // Right hand palm position (x, y, z)
+uniform float u_leftHandConfidence; // Left hand detection confidence (0-1)
+uniform float u_rightHandConfidence; // Right hand detection confidence (0-1)
+uniform vec4 u_leftHandBounds; // Left hand bounding box (x, y, width, height) normalized 0-1
+uniform vec4 u_rightHandBounds; // Right hand bounding box (x, y, width, height) normalized 0-1
 uniform float u_leftHandFist; // Left hand fist gesture confidence (0-1)
 uniform float u_leftHandOpen; // Left hand open palm gesture confidence (0-1)
+uniform float u_leftHandPeace; // Left hand peace/victory gesture confidence (0-1)
+uniform float u_leftHandThumbsUp; // Left hand thumbs up gesture confidence (0-1)
+uniform float u_leftHandThumbsDown; // Left hand thumbs down gesture confidence (0-1)
+uniform float u_leftHandPointing; // Left hand pointing gesture confidence (0-1)
+uniform float u_leftHandILoveYou; // Left hand I-love-you gesture confidence (0-1)
 uniform float u_rightHandFist; // Right hand fist gesture confidence (0-1)
 uniform float u_rightHandOpen; // Right hand open palm gesture confidence (0-1)
+uniform float u_rightHandPeace; // Right hand peace/victory gesture confidence (0-1)
+uniform float u_rightHandThumbsUp; // Right hand thumbs up gesture confidence (0-1)
+uniform float u_rightHandThumbsDown; // Right hand thumbs down gesture confidence (0-1)
+uniform float u_rightHandPointing; // Right hand pointing gesture confidence (0-1)
+uniform float u_rightHandILoveYou; // Right hand I-love-you gesture confidence (0-1)
 
 // CV - Pose Detection
 uniform bool u_poseDetected; // True if a pose is currently detected
-uniform vec2 u_nosePosition; // Nose landmark position in pixels
-uniform vec2 u_leftWristPosition; // Left wrist landmark position in pixels
-uniform vec2 u_rightWristPosition; // Right wrist landmark position in pixels
-uniform vec2 u_leftAnklePosition; // Left ankle landmark position in pixels
-uniform vec2 u_rightAnklePosition; // Right ankle landmark position in pixels
+uniform float u_poseConfidence; // Pose detection confidence (0-1)
+uniform vec2 u_nosePosition; // Nose landmark position (normalized 0-1)
+uniform vec2 u_leftShoulderPosition; // Left shoulder position (normalized 0-1)
+uniform vec2 u_rightShoulderPosition; // Right shoulder position (normalized 0-1)
+uniform vec2 u_leftElbowPosition; // Left elbow position (normalized 0-1)
+uniform vec2 u_rightElbowPosition; // Right elbow position (normalized 0-1)
+uniform vec2 u_leftWristPosition; // Left wrist position (normalized 0-1)
+uniform vec2 u_rightWristPosition; // Right wrist position (normalized 0-1)
+uniform vec2 u_leftHipPosition; // Left hip position (normalized 0-1)
+uniform vec2 u_rightHipPosition; // Right hip position (normalized 0-1)
+uniform vec2 u_leftKneePosition; // Left knee position (normalized 0-1)
+uniform vec2 u_rightKneePosition; // Right knee position (normalized 0-1)
+uniform vec2 u_leftAnklePosition; // Left ankle position (normalized 0-1)
+uniform vec2 u_rightAnklePosition; // Right ankle position (normalized 0-1)
 
 // CV - Segmentation
 uniform sampler2D u_segmentationMask; // Body segmentation mask texture (0=background, 1=person)
@@ -3268,40 +3291,88 @@ ${error}`);
     const leftHand = hands.find((h) => h.handedness === "left");
     const rightHand = hands.find((h) => h.handedness === "right");
     if (leftHand) {
-      this.setUniform("u_leftHandPalm", "vec3", [leftHand.palm.x, leftHand.palm.y, leftHand.palm.z]);
-      this.setUniform("u_leftHandFist", "float", leftHand.gestures?.fist || 0);
-      this.setUniform("u_leftHandOpen", "float", leftHand.gestures?.openPalm || 0);
+      const palm = leftHand.palm || leftHand.landmarks?.[9];
+      const g = leftHand.gestures || {};
+      const b = leftHand.bounds;
+      this.setUniform("u_leftHandPalm", "vec3", [palm?.x || 0, palm?.y || 0, palm?.z || 0]);
+      this.setUniform("u_leftHandConfidence", "float", leftHand.confidence || 0);
+      this.setUniform("u_leftHandBounds", "vec4", [b?.x || 0, b?.y || 0, b?.width || 0, b?.height || 0]);
+      this.setUniform("u_leftHandFist", "float", g.fist || 0);
+      this.setUniform("u_leftHandOpen", "float", g.openPalm || 0);
+      this.setUniform("u_leftHandPeace", "float", g.peace || 0);
+      this.setUniform("u_leftHandThumbsUp", "float", g.thumbsUp || 0);
+      this.setUniform("u_leftHandThumbsDown", "float", g.thumbsDown || 0);
+      this.setUniform("u_leftHandPointing", "float", g.pointing || 0);
+      this.setUniform("u_leftHandILoveYou", "float", g.iLoveYou || 0);
     } else {
       this.setUniform("u_leftHandPalm", "vec3", [0, 0, 0]);
+      this.setUniform("u_leftHandConfidence", "float", 0);
+      this.setUniform("u_leftHandBounds", "vec4", [0, 0, 0, 0]);
       this.setUniform("u_leftHandFist", "float", 0);
       this.setUniform("u_leftHandOpen", "float", 0);
+      this.setUniform("u_leftHandPeace", "float", 0);
+      this.setUniform("u_leftHandThumbsUp", "float", 0);
+      this.setUniform("u_leftHandThumbsDown", "float", 0);
+      this.setUniform("u_leftHandPointing", "float", 0);
+      this.setUniform("u_leftHandILoveYou", "float", 0);
     }
     if (rightHand) {
-      this.setUniform("u_rightHandPalm", "vec3", [rightHand.palm.x, rightHand.palm.y, rightHand.palm.z]);
-      this.setUniform("u_rightHandFist", "float", rightHand.gestures?.fist || 0);
-      this.setUniform("u_rightHandOpen", "float", rightHand.gestures?.openPalm || 0);
+      const palm = rightHand.palm || rightHand.landmarks?.[9];
+      const g = rightHand.gestures || {};
+      const b = rightHand.bounds;
+      this.setUniform("u_rightHandPalm", "vec3", [palm?.x || 0, palm?.y || 0, palm?.z || 0]);
+      this.setUniform("u_rightHandConfidence", "float", rightHand.confidence || 0);
+      this.setUniform("u_rightHandBounds", "vec4", [b?.x || 0, b?.y || 0, b?.width || 0, b?.height || 0]);
+      this.setUniform("u_rightHandFist", "float", g.fist || 0);
+      this.setUniform("u_rightHandOpen", "float", g.openPalm || 0);
+      this.setUniform("u_rightHandPeace", "float", g.peace || 0);
+      this.setUniform("u_rightHandThumbsUp", "float", g.thumbsUp || 0);
+      this.setUniform("u_rightHandThumbsDown", "float", g.thumbsDown || 0);
+      this.setUniform("u_rightHandPointing", "float", g.pointing || 0);
+      this.setUniform("u_rightHandILoveYou", "float", g.iLoveYou || 0);
     } else {
       this.setUniform("u_rightHandPalm", "vec3", [0, 0, 0]);
+      this.setUniform("u_rightHandConfidence", "float", 0);
+      this.setUniform("u_rightHandBounds", "vec4", [0, 0, 0, 0]);
       this.setUniform("u_rightHandFist", "float", 0);
       this.setUniform("u_rightHandOpen", "float", 0);
+      this.setUniform("u_rightHandPeace", "float", 0);
+      this.setUniform("u_rightHandThumbsUp", "float", 0);
+      this.setUniform("u_rightHandThumbsDown", "float", 0);
+      this.setUniform("u_rightHandPointing", "float", 0);
+      this.setUniform("u_rightHandILoveYou", "float", 0);
     }
     const pose = video.pose;
     this.setUniform("u_poseDetected", "bool", pose !== null);
-    if (pose) {
-      const nose = pose.landmarks[0];
-      const leftWrist = pose.landmarks[15];
-      const rightWrist = pose.landmarks[16];
-      const leftAnkle = pose.landmarks[27];
-      const rightAnkle = pose.landmarks[28];
-      this.setUniform("u_nosePosition", "vec2", [nose?.x || 0, nose?.y || 0]);
-      this.setUniform("u_leftWristPosition", "vec2", [leftWrist?.x || 0, leftWrist?.y || 0]);
-      this.setUniform("u_rightWristPosition", "vec2", [rightWrist?.x || 0, rightWrist?.y || 0]);
-      this.setUniform("u_leftAnklePosition", "vec2", [leftAnkle?.x || 0, leftAnkle?.y || 0]);
-      this.setUniform("u_rightAnklePosition", "vec2", [rightAnkle?.x || 0, rightAnkle?.y || 0]);
+    if (pose && pose.landmarks) {
+      const lm = pose.landmarks;
+      this.setUniform("u_poseConfidence", "float", pose.confidence || 0);
+      this.setUniform("u_nosePosition", "vec2", [lm[0]?.x || 0, lm[0]?.y || 0]);
+      this.setUniform("u_leftShoulderPosition", "vec2", [lm[11]?.x || 0, lm[11]?.y || 0]);
+      this.setUniform("u_rightShoulderPosition", "vec2", [lm[12]?.x || 0, lm[12]?.y || 0]);
+      this.setUniform("u_leftElbowPosition", "vec2", [lm[13]?.x || 0, lm[13]?.y || 0]);
+      this.setUniform("u_rightElbowPosition", "vec2", [lm[14]?.x || 0, lm[14]?.y || 0]);
+      this.setUniform("u_leftWristPosition", "vec2", [lm[15]?.x || 0, lm[15]?.y || 0]);
+      this.setUniform("u_rightWristPosition", "vec2", [lm[16]?.x || 0, lm[16]?.y || 0]);
+      this.setUniform("u_leftHipPosition", "vec2", [lm[23]?.x || 0, lm[23]?.y || 0]);
+      this.setUniform("u_rightHipPosition", "vec2", [lm[24]?.x || 0, lm[24]?.y || 0]);
+      this.setUniform("u_leftKneePosition", "vec2", [lm[25]?.x || 0, lm[25]?.y || 0]);
+      this.setUniform("u_rightKneePosition", "vec2", [lm[26]?.x || 0, lm[26]?.y || 0]);
+      this.setUniform("u_leftAnklePosition", "vec2", [lm[27]?.x || 0, lm[27]?.y || 0]);
+      this.setUniform("u_rightAnklePosition", "vec2", [lm[28]?.x || 0, lm[28]?.y || 0]);
     } else {
+      this.setUniform("u_poseConfidence", "float", 0);
       this.setUniform("u_nosePosition", "vec2", [0, 0]);
+      this.setUniform("u_leftShoulderPosition", "vec2", [0, 0]);
+      this.setUniform("u_rightShoulderPosition", "vec2", [0, 0]);
+      this.setUniform("u_leftElbowPosition", "vec2", [0, 0]);
+      this.setUniform("u_rightElbowPosition", "vec2", [0, 0]);
       this.setUniform("u_leftWristPosition", "vec2", [0, 0]);
       this.setUniform("u_rightWristPosition", "vec2", [0, 0]);
+      this.setUniform("u_leftHipPosition", "vec2", [0, 0]);
+      this.setUniform("u_rightHipPosition", "vec2", [0, 0]);
+      this.setUniform("u_leftKneePosition", "vec2", [0, 0]);
+      this.setUniform("u_rightKneePosition", "vec2", [0, 0]);
       this.setUniform("u_leftAnklePosition", "vec2", [0, 0]);
       this.setUniform("u_rightAnklePosition", "vec2", [0, 0]);
     }
@@ -3943,43 +4014,9 @@ class VijiWorkerRuntime {
   autoCaptureEnabled = false;
   autoCaptureFormat = { flipY: true };
   // Default: flip for WebGL compatibility
-  // Audio state (Phase 5) - receives analysis results from host
-  audioState = {
-    isConnected: false,
-    volume: { current: 0, peak: 0, smoothed: 0 },
-    bands: {
-      low: 0,
-      lowMid: 0,
-      mid: 0,
-      highMid: 0,
-      high: 0,
-      lowSmoothed: 0,
-      lowMidSmoothed: 0,
-      midSmoothed: 0,
-      highMidSmoothed: 0,
-      highSmoothed: 0
-    },
-    beat: {
-      kick: 0,
-      snare: 0,
-      hat: 0,
-      any: 0,
-      kickSmoothed: 0,
-      snareSmoothed: 0,
-      hatSmoothed: 0,
-      anySmoothed: 0,
-      triggers: { any: false, kick: false, snare: false, hat: false },
-      bpm: 120,
-      confidence: 0,
-      isLocked: false
-    },
-    spectral: {
-      brightness: 0,
-      flatness: 0
-    },
-    frequencyData: new Uint8Array(0),
-    waveformData: new Float32Array(0)
-  };
+  // Audio raw data buffers (referenced by closures in viji.audio)
+  audioFrequencyData = new Uint8Array(0);
+  audioWaveformData = new Float32Array(0);
   // Device sensor state (internal device + external devices)
   deviceState = {
     device: {
@@ -4004,8 +4041,41 @@ class VijiWorkerRuntime {
     deltaTime: 0,
     frameCount: 0,
     fps: 60,
-    // Audio API (Phase 5) - will be set in constructor
-    audio: {},
+    // Audio API (Phase 5) — stable reference, mutated in place
+    audio: {
+      isConnected: false,
+      volume: { current: 0, peak: 0, smoothed: 0 },
+      bands: {
+        low: 0,
+        lowMid: 0,
+        mid: 0,
+        highMid: 0,
+        high: 0,
+        lowSmoothed: 0,
+        lowMidSmoothed: 0,
+        midSmoothed: 0,
+        highMidSmoothed: 0,
+        highSmoothed: 0
+      },
+      beat: {
+        kick: 0,
+        snare: 0,
+        hat: 0,
+        any: 0,
+        kickSmoothed: 0,
+        snareSmoothed: 0,
+        hatSmoothed: 0,
+        anySmoothed: 0,
+        triggers: { any: false, kick: false, snare: false, hat: false },
+        events: [],
+        bpm: 120,
+        confidence: 0,
+        isLocked: false
+      },
+      spectral: { brightness: 0, flatness: 0 },
+      getFrequencyData: () => new Uint8Array(0),
+      getWaveform: () => new Float32Array(0)
+    },
     // Main video stream (index 0, CV enabled)
     video: {
       isConnected: false,
@@ -4117,11 +4187,8 @@ class VijiWorkerRuntime {
     });
     this.interactionSystem = new InteractionSystem();
     Object.assign(this.viji, this.interactionSystem.getInteractionAPIs());
-    this.viji.audio = {
-      ...this.audioState,
-      getFrequencyData: () => this.audioState.frequencyData,
-      getWaveform: () => this.audioState.waveformData
-    };
+    this.viji.audio.getFrequencyData = () => this.audioFrequencyData;
+    this.viji.audio.getWaveform = () => this.audioWaveformData;
     this.setupMessageHandling();
   }
   /**
@@ -4224,47 +4291,7 @@ class VijiWorkerRuntime {
   resetParameterState() {
     this.parameterSystem.resetParameterState();
     this.interactionSystem.resetInteractionState();
-    this.audioState = {
-      isConnected: false,
-      volume: { current: 0, peak: 0, smoothed: 0 },
-      bands: {
-        low: 0,
-        lowMid: 0,
-        mid: 0,
-        highMid: 0,
-        high: 0,
-        lowSmoothed: 0,
-        lowMidSmoothed: 0,
-        midSmoothed: 0,
-        highMidSmoothed: 0,
-        highSmoothed: 0
-      },
-      beat: {
-        kick: 0,
-        snare: 0,
-        hat: 0,
-        any: 0,
-        kickSmoothed: 0,
-        snareSmoothed: 0,
-        hatSmoothed: 0,
-        anySmoothed: 0,
-        triggers: { any: false, kick: false, snare: false, hat: false },
-        bpm: 120,
-        confidence: 0,
-        isLocked: false
-      },
-      spectral: {
-        brightness: 0,
-        flatness: 0
-      },
-      frequencyData: new Uint8Array(0),
-      waveformData: new Float32Array(0)
-    };
-    this.viji.audio = {
-      ...this.audioState,
-      getFrequencyData: () => this.audioState.frequencyData,
-      getWaveform: () => this.audioState.waveformData
-    };
+    this.resetAudioState();
     this.videoSystems.forEach((vs) => vs?.resetVideoState());
     if (this.videoSystems[0]) {
       Object.assign(this.viji.video, this.videoSystems[0].getVideoAPI());
@@ -4494,30 +4521,98 @@ class VijiWorkerRuntime {
     this.debugLog("Stream update:", message.data);
   }
   handleAudioAnalysisUpdate(message) {
-    const events = message.data.beat.events || [];
-    const triggers = {
-      kick: events.some((e) => e.type === "kick"),
-      snare: events.some((e) => e.type === "snare"),
-      hat: events.some((e) => e.type === "hat"),
-      any: events.length > 0
-    };
-    this.audioState = {
-      isConnected: message.data.isConnected,
-      volume: message.data.volume,
-      bands: message.data.bands,
-      beat: {
-        ...message.data.beat,
-        triggers
-      },
-      spectral: message.data.spectral,
-      frequencyData: new Uint8Array(message.data.frequencyData),
-      waveformData: message.data.waveformData ? new Float32Array(message.data.waveformData) : new Float32Array(0)
-    };
-    this.viji.audio = {
-      ...this.audioState,
-      getFrequencyData: () => this.audioState.frequencyData,
-      getWaveform: () => this.audioState.waveformData
-    };
+    const d = message.data;
+    const audio = this.viji.audio;
+    audio.isConnected = d.isConnected;
+    audio.volume.current = d.volume.current;
+    audio.volume.peak = d.volume.peak;
+    audio.volume.smoothed = d.volume.smoothed;
+    audio.bands.low = d.bands.low;
+    audio.bands.lowMid = d.bands.lowMid;
+    audio.bands.mid = d.bands.mid;
+    audio.bands.highMid = d.bands.highMid;
+    audio.bands.high = d.bands.high;
+    audio.bands.lowSmoothed = d.bands.lowSmoothed;
+    audio.bands.lowMidSmoothed = d.bands.lowMidSmoothed;
+    audio.bands.midSmoothed = d.bands.midSmoothed;
+    audio.bands.highMidSmoothed = d.bands.highMidSmoothed;
+    audio.bands.highSmoothed = d.bands.highSmoothed;
+    audio.beat.kick = d.beat.kick;
+    audio.beat.snare = d.beat.snare;
+    audio.beat.hat = d.beat.hat;
+    audio.beat.any = d.beat.any;
+    audio.beat.kickSmoothed = d.beat.kickSmoothed;
+    audio.beat.snareSmoothed = d.beat.snareSmoothed;
+    audio.beat.hatSmoothed = d.beat.hatSmoothed;
+    audio.beat.anySmoothed = d.beat.anySmoothed;
+    const events = d.beat.events || [];
+    if (events.length > 0) {
+      audio.beat.triggers.kick = audio.beat.triggers.kick || events.some((e) => e.type === "kick");
+      audio.beat.triggers.snare = audio.beat.triggers.snare || events.some((e) => e.type === "snare");
+      audio.beat.triggers.hat = audio.beat.triggers.hat || events.some((e) => e.type === "hat");
+      audio.beat.triggers.any = true;
+      audio.beat.events.push(...events);
+    }
+    audio.beat.bpm = d.beat.bpm;
+    audio.beat.confidence = d.beat.confidence;
+    audio.beat.isLocked = d.beat.isLocked;
+    audio.spectral.brightness = d.spectral.brightness;
+    audio.spectral.flatness = d.spectral.flatness;
+    this.audioFrequencyData = new Uint8Array(d.frequencyData);
+    this.audioWaveformData = d.waveformData ? new Float32Array(d.waveformData) : new Float32Array(0);
+  }
+  /**
+   * Reset frame-scoped audio events (triggers + events array).
+   * Called after each render, mirroring interactionSystem.frameStart().
+   */
+  resetAudioFrameEvents() {
+    const t = this.viji.audio.beat.triggers;
+    t.kick = false;
+    t.snare = false;
+    t.hat = false;
+    t.any = false;
+    this.viji.audio.beat.events.length = 0;
+  }
+  /**
+   * Full audio state reset (scene reload / disconnect).
+   * Zeroes everything without replacing the stable viji.audio reference.
+   */
+  resetAudioState() {
+    const audio = this.viji.audio;
+    audio.isConnected = false;
+    audio.volume.current = 0;
+    audio.volume.peak = 0;
+    audio.volume.smoothed = 0;
+    audio.bands.low = 0;
+    audio.bands.lowMid = 0;
+    audio.bands.mid = 0;
+    audio.bands.highMid = 0;
+    audio.bands.high = 0;
+    audio.bands.lowSmoothed = 0;
+    audio.bands.lowMidSmoothed = 0;
+    audio.bands.midSmoothed = 0;
+    audio.bands.highMidSmoothed = 0;
+    audio.bands.highSmoothed = 0;
+    audio.beat.kick = 0;
+    audio.beat.snare = 0;
+    audio.beat.hat = 0;
+    audio.beat.any = 0;
+    audio.beat.kickSmoothed = 0;
+    audio.beat.snareSmoothed = 0;
+    audio.beat.hatSmoothed = 0;
+    audio.beat.anySmoothed = 0;
+    audio.beat.triggers.kick = false;
+    audio.beat.triggers.snare = false;
+    audio.beat.triggers.hat = false;
+    audio.beat.triggers.any = false;
+    audio.beat.events.length = 0;
+    audio.beat.bpm = 120;
+    audio.beat.confidence = 0;
+    audio.beat.isLocked = false;
+    audio.spectral.brightness = 0;
+    audio.spectral.flatness = 0;
+    this.audioFrequencyData = new Uint8Array(0);
+    this.audioWaveformData = new Float32Array(0);
   }
   handleVideoCanvasSetup(message) {
     const { streamIndex, streamType, deviceId } = message.data;
@@ -4828,6 +4923,7 @@ class VijiWorkerRuntime {
     }
     this.reportPerformanceStats(currentTime);
     this.interactionSystem.frameStart();
+    this.resetAudioFrameEvents();
     requestAnimationFrame(() => this.renderFrame());
   }
   postMessage(type, data) {
@@ -26249,4 +26345,4 @@ async function setSceneCode(sceneCode) {
   }
 }
 self.setSceneCode = setSceneCode;
-//# sourceMappingURL=viji.worker-Zg128woJ.js.map
+//# sourceMappingURL=viji.worker-PAf0oIec.js.map