@meframe/core 0.0.30 → 0.0.32

package/dist/orchestrator/GlobalAudioSession.js

@@ -1,58 +1,76 @@
 import { OfflineAudioMixer } from "../stages/compose/OfflineAudioMixer.js";
 import { MeframeEvent } from "../event/events.js";
 import { AudioChunkEncoder } from "../stages/encode/AudioChunkEncoder.js";
-import { hasResourceId, isAudioClip, hasAudioConfig } from "../model/types.js";
+import { AudioChunkDecoder } from "../stages/decode/AudioChunkDecoder.js";
+import { hasResourceId, isAudioClip } from "../model/types.js";
 class GlobalAudioSession {
   mixer;
   activeClips = /* @__PURE__ */ new Set();
-  streamEndedClips = /* @__PURE__ */ new Set();
   deps;
   model = null;
   audioContext = null;
-  audioSources = [];
-  audioGainNodes = [];
   volume = 1;
   playbackRate = 1;
   isPlaying = false;
-  currentPlaybackTimeUs = 0;
-  ensuringClips = /* @__PURE__ */ new Set();
-  // Track all decoding attempts (Resource & L2)
+  // Lookahead scheduling state
+  nextScheduleTime = 0;
+  // Next AudioContext time to schedule
+  nextContentTimeUs = 0;
+  // Next timeline position (Us)
+  scheduledSources = /* @__PURE__ */ new Set();
+  LOOKAHEAD_TIME = 0.2;
+  // 200ms lookahead
+  CHUNK_DURATION = 0.1;
+  // 100ms chunks
   constructor(deps) {
     this.deps = deps;
     this.mixer = new OfflineAudioMixer(deps.cacheManager, () => this.model);
   }
   setModel(model) {
     this.model = model;
-    this.activateAllAudioClips();
+    void this.activateAllAudioClips();
   }
   onAudioData(message) {
-    const { sessionId, audioData, clipDurationUs } = message;
-    this.deps.cacheManager.putClipAudioData(sessionId, audioData, clipDurationUs);
+    const { sessionId, audioData, clipStartUs, clipDurationUs } = message;
+    const globalTimeUs = clipStartUs + (audioData.timestamp ?? 0);
+    this.deps.cacheManager.putClipAudioData(sessionId, audioData, clipDurationUs, globalTimeUs);
   }
-  async ensureAudioForTime(timeUs) {
+  async ensureAudioForTime(timeUs, options) {
     const model = this.model;
     if (!model) return;
+    const immediate = options?.immediate ?? false;
     const activeClips = [];
     for (const track of model.tracks) {
       if (track.kind !== "audio" && track.kind !== "video") continue;
       const clips = model.getClipsAtTime(timeUs, track.id);
       activeClips.push(...clips);
     }
-    await Promise.all(
-      activeClips.map(async (clip) => {
-        if (this.deps.cacheManager.hasClipPCM(clip.id)) return;
-        if (!hasResourceId(clip)) return;
-        const resource = model.getResource(clip.resourceId);
-        if (!resource) return;
-        if (this.deps.cacheManager.audioSampleCache.has(clip.resourceId)) {
-          await this.ensureClipAudio(clip.id);
+    const ensureAudioWindowPromises = activeClips.map(async (clip) => {
+      if (!hasResourceId(clip)) return;
+      const resource = model.getResource(clip.resourceId);
+      if (!resource) return;
+      if (!this.deps.cacheManager.audioSampleCache.has(clip.resourceId)) {
+        const resource2 = model.getResource(clip.resourceId);
+        if (resource2?.state === "ready") {
           return;
         }
-        if (this.activeClips.has(clip.id)) {
-          await this.waitForClipPCM(clip.id, 2e3);
-        }
-      })
-    );
+        await this.deps.resourceLoader.fetch(clip.resourceId, {
+          priority: "high",
+          clipId: clip.id,
+          trackId: clip.trackId
+        });
+      }
+      const clipRelativeTimeUs = timeUs - clip.startUs;
+      const WINDOW_DURATION = 3e6;
+      const startUs = clipRelativeTimeUs;
+      const endUs = Math.min(clip.durationUs, startUs + WINDOW_DURATION);
+      await this.ensureAudioWindow(clip.id, startUs, endUs);
+    });
+    if (immediate) {
+      void Promise.all(ensureAudioWindowPromises);
+    } else {
+      await Promise.all(ensureAudioWindowPromises);
+    }
   }
   async activateAllAudioClips() {
     const model = this.model;
@@ -67,18 +85,16 @@ class GlobalAudioSession {
             throw new Error(`Clip ${clip.id} in audio track is not an audio clip`);
           }
           if (this.deps.cacheManager.audioSampleCache.has(clip.resourceId)) {
-            await this.ensureClipAudio(clip.id);
             this.activeClips.add(clip.id);
+            this.deps.eventBus.emit(MeframeEvent.ClipActivated, { clipId: clip.id });
             continue;
           }
-          await this.setupAudioPipeline(clip);
-          this.activeClips.add(clip.id);
           await this.deps.resourceLoader.fetch(clip.resourceId, {
             priority: "high",
-            sessionId: clip.id,
             clipId: clip.id,
             trackId: track.id
           });
+          this.activeClips.add(clip.id);
           this.deps.eventBus.emit(MeframeEvent.ClipActivated, { clipId: clip.id });
         }
       }
@@ -88,140 +104,95 @@ class GlobalAudioSession {
     if (!this.activeClips.has(clipId)) {
       return;
     }
-    this.stopClipAudioSources(clipId);
-    this.deps.workerPool.terminate("audioDemux", clipId);
-    this.deps.workerPool.terminate("audioDecode", clipId);
     this.activeClips.delete(clipId);
     this.deps.cacheManager.clearClipAudioData(clipId);
   }
-  restartPlayingClip(clipId, currentTimeUs) {
-    if (!this.isPlaying || !this.audioContext) {
-      return;
-    }
-    const timeUs = currentTimeUs ?? this.currentPlaybackTimeUs;
-    const model = this.model;
-    if (!model) {
-      return;
-    }
-    const clip = model.findClip(clipId);
-    if (!clip) {
-      return;
-    }
-    const clipEndUs = clip.startUs + clip.durationUs;
-    if (timeUs < clip.startUs || timeUs >= clipEndUs) {
-      return;
-    }
-    this.startClipPlayback(clip, timeUs);
-  }
-  stopClipAudioSources(clipId) {
-    const sourcesToStop = [];
-    const gainNodesToDisconnect = [];
-    for (let i = this.audioSources.length - 1; i >= 0; i--) {
-      const source = this.audioSources[i];
-      if (source && source._meframeClipId === clipId) {
-        sourcesToStop.push(source);
-        this.audioSources.splice(i, 1);
-        const gainNode = this.audioGainNodes[i];
-        if (gainNode) {
-          gainNodesToDisconnect.push(gainNode);
-          this.audioGainNodes.splice(i, 1);
-        }
-      }
-    }
-    for (const source of sourcesToStop) {
-      try {
-        source.stop();
-        source.disconnect();
-      } catch {
-      }
-    }
-    for (const gainNode of gainNodesToDisconnect) {
-      try {
-        gainNode.disconnect();
-      } catch {
-      }
-    }
-  }
-  handleAudioStream(stream, metadata) {
-    const sessionId = metadata.sessionId || "unknown";
-    const clipStartUs = metadata.clipStartUs ?? 0;
-    const clipDurationUs = metadata.clipDurationUs ?? 0;
-    const reader = stream.getReader();
-    const pump = async () => {
-      try {
-        const { done, value } = await reader.read();
-        if (done) {
-          this.streamEndedClips.add(sessionId);
-          reader.releaseLock();
-          return;
-        }
-        this.onAudioData({
-          sessionId,
-          audioData: value,
-          clipStartUs,
-          clipDurationUs
-        });
-        await pump();
-      } catch (error) {
-        console.error("[GlobalAudioSession] Audio stream error:", error);
-        reader.releaseLock();
-      }
-    };
-    pump();
-  }
   async startPlayback(timeUs, audioContext) {
     this.audioContext = audioContext;
     if (audioContext.state === "suspended") {
       await audioContext.resume();
     }
-    await this.ensureAudioForTime(timeUs);
+    await this.ensureAudioForTime(timeUs, { immediate: false });
     this.isPlaying = true;
-    this.startAllActiveClips(timeUs);
+    this.resetPlaybackStates();
   }
   stopPlayback() {
     this.isPlaying = false;
     this.stopAllAudioSources();
   }
-  updateTime(timeUs) {
-    this.currentPlaybackTimeUs = timeUs;
-    if (!this.isPlaying) {
+  updateTime(_timeUs) {
+  }
+  /**
+   * Schedule audio chunks ahead of playback cursor
+   * Uses OfflineAudioMixer for proper mixing, then plays the result
+   */
+  async scheduleAudio(currentTimelineUs, audioContext) {
+    if (!this.isPlaying || !this.model || !this.audioContext) {
       return;
     }
-    this.checkAndStartNewClips(timeUs);
+    const lookaheadTime = audioContext.currentTime + this.LOOKAHEAD_TIME;
+    if (this.nextScheduleTime === 0) {
+      this.nextScheduleTime = audioContext.currentTime + 0.01;
+      this.nextContentTimeUs = currentTimelineUs;
+    }
+    while (this.nextScheduleTime < lookaheadTime) {
+      const chunkDurationUs = Math.round(this.CHUNK_DURATION * 1e6);
+      const startUs = this.nextContentTimeUs;
+      const endUs = startUs + chunkDurationUs;
+      if (endUs > this.model.durationUs) {
+        break;
+      }
+      try {
+        const mixedBuffer = await this.mixer.mix(startUs, endUs);
+        const source = audioContext.createBufferSource();
+        source.buffer = mixedBuffer;
+        source.playbackRate.value = this.playbackRate;
+        const gainNode = audioContext.createGain();
+        gainNode.gain.value = this.volume;
+        source.connect(gainNode);
+        gainNode.connect(audioContext.destination);
+        source.start(this.nextScheduleTime);
+        this.scheduledSources.add(source);
+        source.onended = () => {
+          source.disconnect();
+          gainNode.disconnect();
+          this.scheduledSources.delete(source);
+        };
+        const actualDuration = mixedBuffer.duration;
+        this.nextScheduleTime += actualDuration;
+        this.nextContentTimeUs += chunkDurationUs;
+      } catch (error) {
+        console.warn("[GlobalAudioSession] Mix error, skipping chunk:", error);
+        this.nextScheduleTime += this.CHUNK_DURATION;
+        this.nextContentTimeUs += chunkDurationUs;
+      }
+    }
+  }
+  /**
+   * Reset playback states (called on seek)
+   */
+  resetPlaybackStates() {
+    this.stopAllAudioSources();
+    this.nextScheduleTime = 0;
+    this.nextContentTimeUs = 0;
   }
   setVolume(volume) {
     this.volume = volume;
-    for (let i = 0; i < this.audioGainNodes.length; i++) {
-      const gainNode = this.audioGainNodes[i];
-      const source = this.audioSources[i];
-      const clipId = source._meframeClipId;
-      if (clipId && gainNode) {
-        const model = this.model;
-        const clip = model?.findClip(clipId);
-        if (clip && hasAudioConfig(clip)) {
-          const clipVolume = clip.audioConfig?.volume ?? 1;
-          const muted = clip.audioConfig?.muted ?? false;
-          gainNode.gain.value = muted ? 0 : clipVolume * this.volume;
-        }
-      }
-    }
   }
   setPlaybackRate(rate) {
     this.playbackRate = rate;
-    for (const source of this.audioSources) {
-      source.playbackRate.value = this.playbackRate;
-    }
+    this.resetPlaybackStates();
   }
   reset() {
     this.stopAllAudioSources();
     this.deps.cacheManager.resetAudioCache();
     this.activeClips.clear();
-    this.streamEndedClips.clear();
   }
   /**
    * Mix and encode audio for a specific segment (used by ExportScheduler)
    */
   async mixAndEncodeSegment(startUs, endUs, onChunk) {
+    await this.ensureAudioForSegment(startUs, endUs);
     const mixedBuffer = await this.mixer.mix(startUs, endUs);
     const audioData = this.audioBufferToAudioData(mixedBuffer, startUs);
     if (!audioData) return;
@@ -230,10 +201,38 @@ class GlobalAudioSession {
       await this.exportEncoder.initialize();
       this.exportEncoderStream = this.exportEncoder.createStream();
       this.exportEncoderWriter = this.exportEncoderStream.writable.getWriter();
-      this.startExportEncoderReader(this.exportEncoderStream.readable, onChunk);
+      void this.startExportEncoderReader(this.exportEncoderStream.readable, onChunk);
+      await new Promise((resolve) => setTimeout(resolve, 10));
     }
     await this.exportEncoderWriter?.write(audioData);
   }
+  /**
+   * Ensure audio clips in time range are decoded (for export)
+   * Decodes from AudioSampleCache (replaces Worker pipeline)
+   */
+  async ensureAudioForSegment(startUs, endUs) {
+    const model = this.model;
+    if (!model) return;
+    const clips = [];
+    for (const track of model.tracks) {
+      if (track.kind !== "audio" && track.kind !== "video") continue;
+      for (const clip of track.clips) {
+        const clipEndUs = clip.startUs + clip.durationUs;
+        if (clip.startUs < endUs && clipEndUs > startUs) {
+          clips.push(clip);
+        }
+      }
+    }
+    for (const clip of clips) {
+      if (!hasResourceId(clip)) continue;
+      if (!this.deps.cacheManager.audioSampleCache.has(clip.resourceId)) {
+        continue;
+      }
+      const clipRelativeStartUs = Math.max(0, startUs - clip.startUs);
+      const clipRelativeEndUs = Math.min(clip.durationUs, endUs - clip.startUs);
+      await this.ensureAudioWindow(clip.id, clipRelativeStartUs, clipRelativeEndUs);
+    }
+  }
   exportEncoder = null;
   exportEncoderStream = null;
   exportEncoderWriter = null;
@@ -259,279 +258,113 @@ class GlobalAudioSession {
     this.exportEncoder = null;
     this.exportEncoderStream = null;
   }
-  /**
-   * Create export audio stream
-   */
-  async createExportAudioStream() {
-    const model = this.model;
-    if (!model) {
-      return null;
-    }
-    const totalDurationUs = model.durationUs;
-    await this.activateAllAudioClips();
-    await this.waitForAudioClipsReady();
-    return new ReadableStream({
-      start: async (controller) => {
-        const windowSize = 5e6;
-        let currentUs = 0;
-        while (currentUs < totalDurationUs) {
-          const windowEndUs = Math.min(currentUs + windowSize, totalDurationUs);
-          const mixedBuffer = await this.mixer.mix(currentUs, windowEndUs);
-          const audioData = this.audioBufferToAudioData(mixedBuffer, currentUs);
-          if (audioData) {
-            controller.enqueue(audioData);
-          }
-          currentUs = windowEndUs;
-        }
-        controller.close();
-      }
-    });
-  }
-  async waitForAudioClipsReady() {
-    const model = this.model;
-    if (!model) return;
-    const audioClips = model.tracks.filter((track) => track.kind === "audio").flatMap((track) => track.clips);
-    const waitPromises = audioClips.map((clip) => this.waitForClipPCM(clip.id, 1e4));
-    await Promise.allSettled(waitPromises);
-  }
-  waitForClipPCM(clipId, timeoutMs) {
-    return new Promise((resolve) => {
-      const checkInterval = 100;
-      let elapsed = 0;
-      let lastFrameCount = 0;
-      let stableCount = 0;
-      let streamEndDetected = false;
-      const check = () => {
-        const pcm = this.deps.cacheManager.getClipPCM(clipId, 0, Number.MAX_SAFE_INTEGER);
-        if (pcm && pcm.length > 0) {
-          const currentFrameCount = pcm[0]?.length ?? 0;
-          if (this.streamEndedClips.has(clipId)) {
-            streamEndDetected = true;
-          }
-          if (streamEndDetected) {
-            resolve(true);
-            return;
-          }
-          if (currentFrameCount === lastFrameCount) {
-            stableCount++;
-            if (stableCount >= 5) {
-              resolve(true);
-              return;
-            }
-          } else {
-            stableCount = 0;
-            lastFrameCount = currentFrameCount;
-          }
-        }
-        elapsed += checkInterval;
-        if (elapsed >= timeoutMs) {
-          console.warn("[GlobalAudioSession] Timeout waiting for clip", clipId, {
-            frames: lastFrameCount,
-            elapsed
-          });
-          resolve(false);
-          return;
-        }
-        setTimeout(check, checkInterval);
-      };
-      check();
-    });
-  }
-  startAllActiveClips(timeUs) {
-    if (!this.audioContext) {
-      return;
-    }
-    const currentClips = this.getActiveAudioClips(timeUs);
-    for (const clip of currentClips) {
-      this.startClipPlayback(clip, timeUs);
-    }
-  }
-  checkAndStartNewClips(timeUs) {
-    if (!this.audioContext) {
-      return;
-    }
-    const currentClips = this.getActiveAudioClips(timeUs);
-    const activeClipIds = new Set(
-      this.audioSources.map((source) => source._meframeClipId).filter(Boolean)
-    );
-    for (const clip of currentClips) {
-      const clipEndUs = clip.startUs + clip.durationUs;
-      if (timeUs >= clipEndUs) {
-        continue;
-      }
-      if (timeUs < clip.startUs) {
-        continue;
-      }
-      const MIN_REMAINING_TIME_US = 3e4;
-      if (clipEndUs - timeUs < MIN_REMAINING_TIME_US) {
-        continue;
-      }
-      if (!activeClipIds.has(clip.id)) {
-        this.startClipPlayback(clip, timeUs);
-      }
-    }
-  }
-  startClipPlayback(clip, currentTimeUs) {
-    if (!this.audioContext) {
-      console.warn("[GlobalAudioSession] No audioContext, cannot start playback");
-      return;
-    }
-    const clipPCMData = this.deps.cacheManager.getClipPCMWithMetadata(
-      clip.id,
-      0,
-      // Start from beginning of clip (0-based)
-      clip.durationUs
-      // Full clip duration
-    );
-    if (!clipPCMData || clipPCMData.planes.length === 0) {
-      void this.ensureClipAudio(clip.id);
-      return;
-    }
-    const buffer = this.pcmToAudioBuffer(clipPCMData.planes, clipPCMData.sampleRate);
-    const offsetUs = Math.max(0, currentTimeUs - clip.startUs);
-    const offsetSeconds = offsetUs / 1e6;
-    const actualDurationSeconds = buffer.duration - offsetSeconds;
-    const MIN_PLAYBACK_DURATION_SECONDS = 0.03;
-    if (actualDurationSeconds < MIN_PLAYBACK_DURATION_SECONDS) {
-      return;
-    }
-    const source = this.audioContext.createBufferSource();
-    source.buffer = buffer;
-    source.playbackRate.value = this.playbackRate;
-    source._meframeClipId = clip.id;
-    const gainNode = this.audioContext.createGain();
-    if (hasAudioConfig(clip)) {
-      const volume = clip.audioConfig?.volume ?? 1;
-      const muted = clip.audioConfig?.muted ?? false;
-      gainNode.gain.value = muted ? 0 : volume * this.volume;
-    } else {
-      gainNode.gain.value = this.volume;
-    }
-    source.connect(gainNode);
-    gainNode.connect(this.audioContext.destination);
-    source.start(0, offsetSeconds, actualDurationSeconds);
-    source.onended = () => {
-      const index = this.audioSources.indexOf(source);
-      if (index >= 0) {
-        this.audioSources.splice(index, 1);
-        this.audioGainNodes.splice(index, 1);
-      }
-    };
-    this.audioSources.push(source);
-    this.audioGainNodes.push(gainNode);
-  }
   stopAllAudioSources() {
-    for (const source of this.audioSources) {
+    for (const source of this.scheduledSources) {
       try {
         source.stop();
         source.disconnect();
       } catch {
       }
     }
-    for (const gainNode of this.audioGainNodes) {
-      try {
-        gainNode.disconnect();
-      } catch {
-      }
-    }
-    this.audioSources = [];
-    this.audioGainNodes = [];
+    this.scheduledSources.clear();
   }
-  getActiveAudioClips(timeUs) {
-    const model = this.model;
-    if (!model) {
-      return [];
-    }
-    const clips = [];
-    for (const track of model.tracks) {
-      if (track.kind !== "audio" && track.kind !== "video") {
-        continue;
-      }
-      const trackClips = model.getClipsAtTime(timeUs, track.id);
-      clips.push(...trackClips);
+  /**
+   * Ensure audio window for a clip (aligned with video architecture)
+   *
+   * Note: Unlike video getFrame(), this method doesn't need a 'preheat' parameter
+   * Why: Audio cache check is window-level (range query) via hasWindowPCM()
+   *      It verifies the entire window has ≥80% data, not just a single point
+   *      This naturally prevents premature return during preheating
+   */
+  async ensureAudioWindow(clipId, startUs, endUs) {
+    if (this.deps.cacheManager.hasWindowPCM(clipId, startUs, endUs)) {
+      return;
     }
-    return clips;
+    await this.decodeAudioWindow(clipId, startUs, endUs);
   }
   /**
-   * Ensure PCM for a clip is available
-   * Priority: AudioSampleCache (Resource) > L2 > None
+   * Decode audio window for a clip (aligned with video architecture)
+   * Simple strategy: decode entire window range, cache handles duplicates
    */
-  async ensureClipAudio(clipId) {
-    if (this.deps.cacheManager.hasClipPCM(clipId)) {
+  async decodeAudioWindow(clipId, startUs, endUs) {
+    const clip = this.model?.findClip(clipId);
+    if (!clip || !hasResourceId(clip)) {
       return;
     }
-    if (this.ensuringClips.has(clipId)) {
+    const audioRecord = this.deps.cacheManager.audioSampleCache.get(clip.resourceId);
+    if (!audioRecord) {
       return;
     }
-    this.ensuringClips.add(clipId);
-    try {
-      await this.ensureClipAudioFromResource(clipId);
-    } finally {
-      this.ensuringClips.delete(clipId);
-    }
-  }
-  /**
-   * Ensure PCM from AudioSampleCache (Resource-level)
-   * Returns true if successful
-   */
-  async ensureClipAudioFromResource(clipId) {
-    const model = this.model;
-    const clip = model?.findClip(clipId);
-    if (!clip) return false;
-    const resourceId = clip.resourceId;
-    if (!resourceId) return false;
-    const audioRecord = this.deps.cacheManager.audioSampleCache.get(resourceId);
-    if (!audioRecord) return false;
-    try {
-      const clipSamples = audioRecord.samples.filter((s) => {
-        const sampleEndUs = s.timestamp + (s.duration ?? 0);
-        return s.timestamp < clip.durationUs && sampleEndUs > 0;
-      });
-      if (clipSamples.length === 0) {
-        return false;
-      }
-      await this.decodeAudioSamples(clipId, clipSamples, audioRecord.metadata, clip.durationUs);
-      return true;
-    } catch (error) {
-      console.warn(
-        `[GlobalAudioSession] Failed to decode audio from resource ${resourceId}:`,
-        error
-      );
-      return false;
+    const windowChunks = audioRecord.samples.filter((s) => {
+      const sampleEndUs = s.timestamp + (s.duration ?? 0);
+      return s.timestamp < endUs && sampleEndUs > startUs;
+    });
+    if (windowChunks.length === 0) {
+      return;
     }
+    await this.decodeAudioSamples(
+      clipId,
+      windowChunks,
+      audioRecord.metadata,
+      clip.durationUs,
+      clip.startUs
+    );
   }
   /**
    * Decode audio samples to PCM and cache
+   * Uses AudioChunkDecoder for consistency with project architecture
+   * Resamples to AudioContext sample rate if needed for better quality
    */
-  async decodeAudioSamples(clipId, samples, config, clipDurationUs) {
-    const decoder = new AudioDecoder({
-      output: (audioData) => {
-        this.deps.cacheManager.putClipAudioData(clipId, audioData, clipDurationUs);
-      },
-      error: (error) => {
-        console.error(`[GlobalAudioSession] Decoder error for clip ${clipId}:`, error);
+  async decodeAudioSamples(clipId, samples, config, clipDurationUs, clipStartUs) {
+    let description;
+    if (config.description) {
+      if (config.description instanceof ArrayBuffer) {
+        description = config.description;
+      } else if (ArrayBuffer.isView(config.description)) {
+        const view = config.description;
+        const newBuffer = new ArrayBuffer(view.byteLength);
+        new Uint8Array(newBuffer).set(
+          new Uint8Array(view.buffer, view.byteOffset, view.byteLength)
+        );
+        description = newBuffer;
       }
-    });
-    decoder.configure(config);
-    for (const sample of samples) {
-      decoder.decode(sample);
     }
-    await decoder.flush();
-    decoder.close();
-  }
-  pcmToAudioBuffer(planes, sampleRate) {
-    const numberOfChannels = planes.length;
-    const numberOfFrames = planes[0]?.length ?? 0;
-    const ctx = new OfflineAudioContext(numberOfChannels, 1, sampleRate);
-    const buffer = ctx.createBuffer(numberOfChannels, numberOfFrames, sampleRate);
-    for (let channel = 0; channel < numberOfChannels; channel++) {
-      const plane = planes[channel];
-      if (plane) {
-        const channelData = buffer.getChannelData(channel);
-        channelData.set(plane);
+    const decoderConfig = {
+      codec: config.codec,
+      sampleRate: config.sampleRate,
+      numberOfChannels: config.numberOfChannels,
+      description
+    };
+    const decoder = new AudioChunkDecoder(`audio-${clipId}`, decoderConfig);
+    try {
+      const chunkStream = new ReadableStream({
+        start(controller) {
+          for (const sample of samples) {
+            controller.enqueue(sample);
+          }
+          controller.close();
+        }
+      });
+      const audioDataStream = chunkStream.pipeThrough(decoder.createStream());
+      const reader = audioDataStream.getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value) {
+            const globalTimeUs = clipStartUs + (value.timestamp ?? 0);
+            this.deps.cacheManager.putClipAudioData(clipId, value, clipDurationUs, globalTimeUs);
+          }
+        }
+      } finally {
+        reader.releaseLock();
       }
+    } catch (error) {
+      console.error(`[GlobalAudioSession] Decoder error for clip ${clipId}:`, error);
+      throw error;
+    } finally {
+      await decoder.close();
     }
-    return buffer;
   }
   audioBufferToAudioData(buffer, timestampUs) {
     const sampleRate = buffer.sampleRate;
@@ -563,48 +396,6 @@ class GlobalAudioSession {
     }
     return interleaved.buffer;
   }
-  async setupAudioPipeline(clip) {
-    const { id: clipId, resourceId, startUs, durationUs } = clip;
-    const audioDemuxWorker = await this.deps.workerPool.getOrCreate("audioDemux", clipId, {
-      lazy: true
-    });
-    const audioDecodeWorker = await this.deps.workerPool.getOrCreate("audioDecode", clipId, {
-      lazy: true
-    });
-    const demuxToDecodeChannel = new MessageChannel();
-    await audioDemuxWorker.send(
-      "connect",
-      { direction: "downstream", port: demuxToDecodeChannel.port1, streamType: "audio", clipId },
-      { transfer: [demuxToDecodeChannel.port1] }
-    );
-    await audioDecodeWorker.send(
-      "connect",
-      {
-        direction: "upstream",
-        port: demuxToDecodeChannel.port2,
-        streamType: "audio",
-        sessionId: clipId,
-        clipStartUs: startUs || 0,
-        clipDurationUs: durationUs || 0
-      },
-      { transfer: [demuxToDecodeChannel.port2] }
-    );
-    audioDecodeWorker.receiveStream((stream, metadata) => {
-      this.handleAudioStream(stream, {
-        sessionId: clipId,
-        clipStartUs: startUs || 0,
-        clipDurationUs: durationUs || 0,
-        ...metadata
-      });
-    });
-    const demuxConfig = this.deps.buildWorkerConfigs().audioDemux;
-    await audioDemuxWorker.send("configure", {
-      initial: true,
-      resourceId,
-      clipId,
-      config: demuxConfig
-    });
-  }
 }
 export {
   GlobalAudioSession