@meframe/core 0.2.0 → 0.2.2

package/dist/orchestrator/GlobalAudioSession.js

@@ -1,683 +0,0 @@
-import { OfflineAudioMixer } from "../stages/compose/OfflineAudioMixer.js";
-import { MeframeEvent } from "../event/events.js";
-import { AudioMixBlockCache } from "../cache/AudioMixBlockCache.js";
-import { AudioChunkEncoder } from "../stages/encode/AudioChunkEncoder.js";
-import { AudioChunkDecoder } from "../stages/decode/AudioChunkDecoder.js";
-import { hasResourceId, isAudioClip } from "../model/types.js";
-class GlobalAudioSession {
-  mixer;
-  activeClips = /* @__PURE__ */ new Set();
-  deps;
-  model = null;
-  audioContext = null;
-  volume = 1;
-  playbackRate = 1;
-  isPlaying = false;
-  // Preview strategy (unified):
-  // - Always schedule audio in fixed 60s "mix blocks"
-  // - Cache 2~3 mixed AudioBuffer blocks (LRU) to accelerate seek
-  // - Schedule ahead using AudioContext clock to avoid underrun
-  PREVIEW_BLOCK_DURATION_US = 60 * 1e6;
-  // 60s
-  PREVIEW_BLOCK_CACHE_SIZE = 3;
-  PREVIEW_SCHEDULE_AHEAD_SEC = 12;
-  // keep enough scheduled audio to hide mixing latency
-  PREVIEW_BUFFER_GUARD_US = 2e6;
-  // if next block isn't ready near boundary -> buffering
-  PREVIEW_BLOCK_FADE_SEC = 0.01;
-  // 10ms fade-in/out to avoid click at boundaries
-  previewBlockCache = new AudioMixBlockCache(this.PREVIEW_BLOCK_CACHE_SIZE);
-  previewScheduleTask = null;
-  previewScheduleToken = 0;
-  previewMixToken = 0;
-  previewNextBlockIndex = 0;
-  previewNextScheduleTime = 0;
-  // AudioContext time
-  previewFirstBlockOffsetUs = 0;
-  // seek offset within the first block
-  previewLastTimelineUs = 0;
-  previewLastStallWarnAt = 0;
-  // AudioContext time (sec)
-  previewScheduledSources = /* @__PURE__ */ new Set();
-  previewMixQueue = Promise.resolve();
-  constructor(deps) {
-    this.deps = deps;
-    this.mixer = new OfflineAudioMixer(deps.cacheManager, () => this.model);
-  }
-  enqueuePreviewMix(work, token) {
-    const run = () => work();
-    const next = this.previewMixQueue.then(
-      () => {
-        if (this.previewMixToken !== token) {
-          return null;
-        }
-        return run();
-      },
-      () => {
-        if (this.previewMixToken !== token) {
-          return null;
-        }
-        return run();
-      }
-    );
-    this.previewMixQueue = next.then(
-      () => void 0,
-      () => void 0
-    );
-    return next;
-  }
-  setModel(model) {
-    this.model = model;
-  }
-  onAudioData(message) {
-    const { sessionId, audioData, clipStartUs, clipDurationUs } = message;
-    const globalTimeUs = clipStartUs + (audioData.timestamp ?? 0);
-    this.deps.cacheManager.putClipAudioData(sessionId, audioData, clipDurationUs, globalTimeUs);
-  }
-  async ensureAudioForTime(timeUs, options) {
-    const model = this.model;
-    if (!model) return;
-    const mode = options?.mode ?? "blocking";
-    const blockIndex = Math.floor(Math.max(0, timeUs) / this.PREVIEW_BLOCK_DURATION_US);
-    if (mode === "probe") {
-      void this.getOrCreateMixedBlock(blockIndex);
-      const blockEndUs2 = (blockIndex + 1) * this.PREVIEW_BLOCK_DURATION_US;
-      const remainingToBoundaryUs2 = blockEndUs2 - Math.max(0, timeUs);
-      const lookaheadUs = Math.floor(this.PREVIEW_SCHEDULE_AHEAD_SEC * 1e6);
-      if (remainingToBoundaryUs2 > 0 && remainingToBoundaryUs2 <= lookaheadUs) {
-        void this.getOrCreateMixedBlock(blockIndex + 1);
-      }
-      return;
-    }
-    await this.getOrCreateMixedBlock(blockIndex);
-    const blockEndUs = (blockIndex + 1) * this.PREVIEW_BLOCK_DURATION_US;
-    const remainingToBoundaryUs = blockEndUs - Math.max(0, timeUs);
-    if (remainingToBoundaryUs > 0 && remainingToBoundaryUs <= this.PREVIEW_BUFFER_GUARD_US) {
-      await this.getOrCreateMixedBlock(blockIndex + 1);
-    }
-  }
-  isPreviewMixBlockCached(timeUs) {
-    const blockIndex = Math.floor(Math.max(0, timeUs) / this.PREVIEW_BLOCK_DURATION_US);
-    return this.previewBlockCache.get(blockIndex) !== null;
-  }
-  shouldEnterBufferingForUpcomingPreviewAudio(timeUs) {
-    const model = this.model;
-    if (!model) return false;
-    const clampedUs = Math.max(0, timeUs);
-    const blockIndex = Math.floor(clampedUs / this.PREVIEW_BLOCK_DURATION_US);
-    const nextBlockStartUs = (blockIndex + 1) * this.PREVIEW_BLOCK_DURATION_US;
-    if (nextBlockStartUs >= model.durationUs) return false;
-    const remainingToBoundaryUs = nextBlockStartUs - clampedUs;
-    if (remainingToBoundaryUs > this.PREVIEW_BUFFER_GUARD_US) return false;
-    return !this.isPreviewMixBlockCached(nextBlockStartUs);
-  }
-  /**
-   * Fast readiness probe for preview playback.
-   *
-   * This is intentionally synchronous and lightweight:
-   * - Only checks resource-level readiness (download + MP4 index parsing).
-   * - If any relevant resource isn't ready yet, return false.
-   * - Does NOT require audio samples / PCM window coverage (probe is resource-level only).
-   *
-   * Note: This probe does NOT gate on PCM coverage to avoid frequent buffering oscillation.
-   * PCM is prepared incrementally by scheduleAudio() / ensureAudioForTimeRange().
-   */
-  isAudioResourceWindowReady(startUs, endUs) {
-    const model = this.model;
-    if (!model) return true;
-    const activeClips = model.getActiveClips(startUs, endUs);
-    for (const clip of activeClips) {
-      if (clip.trackKind !== "audio" && clip.trackKind !== "video") continue;
-      if (!hasResourceId(clip)) continue;
-      const resource = model.getResource(clip.resourceId);
-      if (resource?.state !== "ready") {
-        return false;
-      }
-    }
-    return true;
-  }
-  async activateAllAudioClips() {
-    const model = this.model;
-    if (!model) {
-      return;
-    }
-    const audioTracks = model.tracks.filter((track) => track.kind === "audio");
-    if (audioTracks.length === 0) return;
-    const maxClipCount = Math.max(...audioTracks.map((track) => track.clips.length));
-    for (let clipIndex = 0; clipIndex < maxClipCount; clipIndex++) {
-      for (const track of audioTracks) {
-        const clip = track.clips[clipIndex];
-        if (!clip || this.activeClips.has(clip.id)) continue;
-        if (!isAudioClip(clip)) {
-          throw new Error(`Clip ${clip.id} in audio track is not an audio clip`);
-        }
-        if (this.deps.cacheManager.audioSampleCache.has(clip.resourceId)) {
-          this.activeClips.add(clip.id);
-          this.deps.eventBus.emit(MeframeEvent.ClipActivated, { clipId: clip.id });
-          continue;
-        }
-        await this.deps.resourceLoader.load(clip.resourceId, {
-          isPreload: false,
-          clipId: clip.id,
-          trackId: track.id
-        });
-        this.activeClips.add(clip.id);
-        this.deps.eventBus.emit(MeframeEvent.ClipActivated, { clipId: clip.id });
-      }
-    }
-  }
-  async deactivateClip(clipId) {
-    if (!this.activeClips.has(clipId)) {
-      return;
-    }
-    this.activeClips.delete(clipId);
-    this.deps.cacheManager.clearClipAudioData(clipId);
-  }
-  async startPlayback(timeUs, audioContext) {
-    this.audioContext = audioContext;
-    if (audioContext.state === "suspended") {
-      await audioContext.resume();
-    }
-    await this.ensureAudioForTime(timeUs, { mode: "blocking" });
-    this.isPlaying = true;
-    this.startPreviewBlockScheduling(timeUs, audioContext);
-    await this.scheduleNextPreviewBlock(audioContext, this.previewScheduleToken);
-    void this.scheduleAudio(timeUs, audioContext);
-  }
-  stopPlayback() {
-    this.isPlaying = false;
-    this.stopAllPreviewSources();
-    this.cancelPreviewBlockScheduling();
-    this.previewMixToken += 1;
-  }
-  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.previewLastTimelineUs = currentTimelineUs;
-    if (this.previewScheduleTask) return;
-    if (this.previewNextScheduleTime === 0) {
-      this.startPreviewBlockScheduling(currentTimelineUs, audioContext);
-    }
-    const token = this.previewScheduleToken;
-    this.previewScheduleTask = this.runPreviewBlockSchedulingLoop(audioContext, token).finally(
-      () => {
-        if (this.previewScheduleToken === token) {
-          this.previewScheduleTask = null;
-        }
-      }
-    );
-  }
-  /**
-   * Reset playback states (called on seek)
-   */
-  resetPlaybackStates() {
-    this.stopAllPreviewSources();
-    this.cancelPreviewBlockScheduling();
-    this.previewMixToken += 1;
-  }
-  setVolume(volume) {
-    this.volume = volume;
-    const audioContext = this.audioContext;
-    if (!audioContext) return;
-    const t = audioContext.currentTime;
-    for (const { gain } of this.previewScheduledSources) {
-      try {
-        gain.gain.cancelScheduledValues(t);
-        gain.gain.setValueAtTime(gain.gain.value, t);
-        gain.gain.linearRampToValueAtTime(volume, t + 0.01);
-      } catch {
-      }
-    }
-  }
-  setPlaybackRate(rate) {
-    this.playbackRate = rate;
-    this.resetPlaybackStates();
-  }
-  startPreviewBlockScheduling(startTimelineUs, audioContext) {
-    this.cancelPreviewBlockScheduling();
-    this.stopAllPreviewSources();
-    const clampedUs = Math.max(0, startTimelineUs);
-    const blockIndex = Math.floor(clampedUs / this.PREVIEW_BLOCK_DURATION_US);
-    const blockStartUs = blockIndex * this.PREVIEW_BLOCK_DURATION_US;
-    this.previewFirstBlockOffsetUs = clampedUs - blockStartUs;
-    this.previewNextBlockIndex = blockIndex;
-    this.previewNextScheduleTime = audioContext.currentTime + 0.02;
-    this.previewLastTimelineUs = startTimelineUs;
-  }
-  cancelPreviewBlockScheduling() {
-    this.previewScheduleToken += 1;
-    this.previewScheduleTask = null;
-    this.previewNextBlockIndex = 0;
-    this.previewNextScheduleTime = 0;
-    this.previewFirstBlockOffsetUs = 0;
-    this.previewLastTimelineUs = 0;
-  }
-  realignPreviewSchedulingToTimeline(audioContext) {
-    const model = this.model;
-    if (!model) return;
-    const clampedUs = Math.max(0, this.previewLastTimelineUs);
-    const blockIndex = Math.floor(clampedUs / this.PREVIEW_BLOCK_DURATION_US);
-    const blockStartUs = blockIndex * this.PREVIEW_BLOCK_DURATION_US;
-    if (blockStartUs >= model.durationUs) return;
-    this.stopAllPreviewSources();
-    this.previewFirstBlockOffsetUs = clampedUs - blockStartUs;
-    this.previewNextBlockIndex = blockIndex;
-    this.previewNextScheduleTime = audioContext.currentTime + 0.02;
-  }
-  async runPreviewBlockSchedulingLoop(audioContext, token) {
-    while (this.isPlaying && this.previewScheduleToken === token) {
-      const model = this.model;
-      if (!model) return;
-      const nextBlockStartUs = this.previewNextBlockIndex * this.PREVIEW_BLOCK_DURATION_US;
-      if (nextBlockStartUs >= model.durationUs) {
-        this.previewNextScheduleTime = audioContext.currentTime + this.PREVIEW_SCHEDULE_AHEAD_SEC;
-        return;
-      }
-      const scheduleAheadTime = audioContext.currentTime + this.PREVIEW_SCHEDULE_AHEAD_SEC;
-      if (this.previewNextScheduleTime >= scheduleAheadTime) return;
-      const prevBlockIndex = this.previewNextBlockIndex;
-      const prevScheduleTime = this.previewNextScheduleTime;
-      await this.scheduleNextPreviewBlock(audioContext, token);
-      if (this.previewScheduleToken === token && this.previewNextBlockIndex === prevBlockIndex && this.previewNextScheduleTime === prevScheduleTime) {
-        const now = audioContext.currentTime;
-        if (now - this.previewLastStallWarnAt >= 1) {
-          this.previewLastStallWarnAt = now;
-          console.warn(
-            "[GlobalAudioSession][preview] scheduling stalled; stop loop to avoid spin",
-            {
-              prevBlockIndex,
-              prevScheduleTime,
-              now
-            }
-          );
-        }
-        return;
-      }
-    }
-  }
-  async getOrCreateMixedBlock(blockIndex) {
-    const model = this.model;
-    if (!model) return null;
-    const token = this.previewMixToken;
-    return await this.previewBlockCache.getOrCreate(blockIndex, async () => {
-      return await this.enqueuePreviewMix(async () => {
-        const startUs = blockIndex * this.PREVIEW_BLOCK_DURATION_US;
-        const endUs = Math.min(startUs + this.PREVIEW_BLOCK_DURATION_US, model.durationUs);
-        await this.ensureAudioForTimeRange(startUs, endUs, {
-          mode: "blocking",
-          loadResource: true
-        });
-        const mixed = await this.mixer.mix(startUs, endUs);
-        this.deps.cacheManager.clearAudioCache();
-        return mixed;
-      }, token);
-    });
-  }
-  async scheduleNextPreviewBlock(audioContext, token) {
-    const model = this.model;
-    if (!this.isPlaying || !model) return;
-    if (this.previewScheduleToken !== token) return;
-    if (this.previewNextScheduleTime < audioContext.currentTime + 0.01) {
-      this.realignPreviewSchedulingToTimeline(audioContext);
-    }
-    const blockIndex = this.previewNextBlockIndex;
-    const blockStartUs = blockIndex * this.PREVIEW_BLOCK_DURATION_US;
-    if (blockStartUs >= model.durationUs) {
-      this.previewFirstBlockOffsetUs = 0;
-      this.previewNextBlockIndex = blockIndex + 1;
-      this.previewNextScheduleTime = audioContext.currentTime + this.PREVIEW_SCHEDULE_AHEAD_SEC;
-      return;
-    }
-    const buffer = await this.getOrCreateMixedBlock(blockIndex);
-    if (!buffer) {
-      this.previewFirstBlockOffsetUs = 0;
-      this.previewNextBlockIndex = blockIndex + 1;
-      this.previewNextScheduleTime = audioContext.currentTime + 0.02;
-      return;
-    }
-    if (this.previewScheduleToken !== token) return;
-    const rate = this.playbackRate || 1;
-    const offsetUs = this.previewFirstBlockOffsetUs;
-    let startTime = this.previewNextScheduleTime;
-    let offsetSec = offsetUs > 0 ? offsetUs / 1e6 : 0;
-    const now = audioContext.currentTime;
-    if (startTime < now + 0.01) {
-      const targetStartTime = now + 0.02;
-      const skippedSec = Math.max(0, (targetStartTime - startTime) * rate);
-      startTime = targetStartTime;
-      offsetSec += skippedSec;
-    }
-    if (offsetSec >= buffer.duration) {
-      this.previewFirstBlockOffsetUs = 0;
-      this.previewNextBlockIndex = blockIndex + 1;
-      this.previewNextScheduleTime = startTime;
-      return;
-    }
-    const remainingSec = Math.max(0, buffer.duration - offsetSec);
-    if (remainingSec <= 0) return;
-    const source = audioContext.createBufferSource();
-    source.buffer = buffer;
-    source.playbackRate.value = rate;
-    const gainNode = audioContext.createGain();
-    const volume = this.volume;
-    const fadeSec = Math.min(this.PREVIEW_BLOCK_FADE_SEC, remainingSec / 2);
-    gainNode.gain.setValueAtTime(0, startTime);
-    gainNode.gain.linearRampToValueAtTime(volume, startTime + fadeSec);
-    gainNode.gain.setValueAtTime(volume, startTime + Math.max(fadeSec, remainingSec - fadeSec));
-    gainNode.gain.linearRampToValueAtTime(0, startTime + remainingSec);
-    source.connect(gainNode);
-    gainNode.connect(audioContext.destination);
-    source.start(startTime, offsetSec);
-    const entry = { source, gain: gainNode };
-    this.previewScheduledSources.add(entry);
-    source.onended = () => {
-      try {
-        source.disconnect();
-        gainNode.disconnect();
-      } catch {
-      }
-      this.previewScheduledSources.delete(entry);
-    };
-    this.previewFirstBlockOffsetUs = 0;
-    this.previewNextBlockIndex = blockIndex + 1;
-    this.previewNextScheduleTime = startTime + remainingSec / rate;
-  }
-  stopAllPreviewSources() {
-    for (const { source, gain } of this.previewScheduledSources) {
-      try {
-        source.disconnect();
-      } catch {
-      }
-      try {
-        source.stop(0);
-      } catch {
-      }
-      try {
-        gain.disconnect();
-      } catch {
-      }
-    }
-    this.previewScheduledSources.clear();
-  }
-  reset() {
-    this.stopAllPreviewSources();
-    this.deps.cacheManager.clearAudioCache();
-    this.activeClips.clear();
-    this.previewBlockCache.clear();
-    this.cancelPreviewBlockScheduling();
-    this.previewMixToken += 1;
-  }
-  /**
-   * 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;
-    if (!this.exportEncoder) {
-      this.exportEncoder = new AudioChunkEncoder();
-      await this.exportEncoder.initialize();
-      this.exportEncoderStream = this.exportEncoder.createStream();
-      this.exportEncoderWriter = this.exportEncoderStream.writable.getWriter();
-      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) {
-    await this.ensureAudioForTimeRange(startUs, endUs, {
-      mode: "blocking",
-      loadResource: false,
-      strictMode: true
-    });
-  }
-  exportEncoder = null;
-  exportEncoderStream = null;
-  exportEncoderWriter = null;
-  async startExportEncoderReader(stream, onChunk) {
-    const reader = stream.getReader();
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        if (value) {
-          onChunk(value.chunk, value.metadata);
-        }
-      }
-    } catch (e) {
-      console.error("Export encoder reader error", e);
-    }
-  }
-  async finalizeExportAudio() {
-    if (this.exportEncoderWriter) {
-      await this.exportEncoderWriter.close();
-      this.exportEncoderWriter = null;
-    }
-    this.exportEncoder = null;
-    this.exportEncoderStream = null;
-  }
-  // Preview source scheduling is managed by stopAllPreviewSources()/previewScheduledSources.
-  /**
-   * Core method to ensure audio for all clips in a time range
-   * Unified implementation used by ensureAudioForTime, scheduleAudio, and export
-   */
-  async ensureAudioForTimeRange(startUs, endUs, options) {
-    const model = this.model;
-    if (!model) return;
-    const { mode = "blocking", loadResource = true, strictMode = false } = options;
-    const activeClips = model.getActiveClips(startUs, endUs);
-    const ensurePromises = activeClips.map(async (clip) => {
-      if (clip.trackKind !== "audio" && clip.trackKind !== "video") return;
-      if (!hasResourceId(clip)) return;
-      const resource = model.getResource(clip.resourceId);
-      if (resource?.state === "ready" && !this.deps.cacheManager.audioSampleCache.has(clip.resourceId)) {
-        return;
-      }
-      if (!this.deps.cacheManager.audioSampleCache.has(clip.resourceId)) {
-        if (!loadResource) {
-          return;
-        }
-        const resource2 = model.getResource(clip.resourceId);
-        if (resource2?.state !== "ready") {
-          await this.deps.resourceLoader.load(clip.resourceId, {
-            isPreload: false,
-            clipId: clip.id,
-            trackId: clip.trackId
-          });
-        }
-      }
-      const clipRelativeStartUs = Math.max(0, startUs - clip.startUs);
-      const clipRelativeEndUs = Math.min(clip.durationUs, endUs - clip.startUs);
-      const trimStartUs = clip.trimStartUs ?? 0;
-      const resourceStartUs = clipRelativeStartUs + trimStartUs;
-      const resourceEndUs = clipRelativeEndUs + trimStartUs;
-      await this.ensureAudioWindow(clip.id, resourceStartUs, resourceEndUs, strictMode);
-    });
-    if (mode === "probe") {
-      void Promise.all(ensurePromises);
-      return;
-    }
-    await Promise.all(ensurePromises);
-  }
-  /**
-   * 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 ≥95% data (preview) or ≥99% (export)
-   *      This naturally prevents premature return during preheating
-   */
-  async ensureAudioWindow(clipId, startUs, endUs, strictMode = false) {
-    if (this.deps.cacheManager.hasWindowPCM(clipId, startUs, endUs, strictMode)) {
-      return;
-    }
-    await this.decodeAudioWindow(clipId, startUs, endUs);
-  }
-  /**
-   * Decode audio window for a clip (aligned with video architecture)
-   * Incremental decoding strategy with smart fallback:
-   * - High coverage (≥80%): Skip decoding
-   * - Low coverage (<30%): Full decode (avoid fragmentation)
-   * - Medium coverage (30%-80%): Incremental decode
-   */
-  async decodeAudioWindow(clipId, startUs, endUs) {
-    const clip = this.model?.findClip(clipId);
-    if (!clip || !hasResourceId(clip)) {
-      return;
-    }
-    const audioRecord = this.deps.cacheManager.audioSampleCache.get(clip.resourceId);
-    if (!audioRecord) {
-      return;
-    }
-    const windowChunks = audioRecord.samples.filter((s) => {
-      const sampleEndUs = s.timestamp + (s.duration ?? 0);
-      return s.timestamp < endUs && sampleEndUs > startUs;
-    });
-    if (windowChunks.length === 0) {
-      return;
-    }
-    const INCREMENTAL_THRESHOLD = 0.95;
-    const FULL_FALLBACK_THRESHOLD = 0.3;
-    const coverage = this.deps.cacheManager.getAudioRangeCoverage(
-      clipId,
-      startUs,
-      endUs,
-      INCREMENTAL_THRESHOLD
-    );
-    if (coverage.covered) {
-      return;
-    }
-    if (coverage.coverageRatio < FULL_FALLBACK_THRESHOLD) {
-      await this.decodeAudioSamples(
-        clipId,
-        windowChunks,
-        audioRecord.metadata,
-        clip.durationUs,
-        clip.startUs
-      );
-      return;
-    }
-    const chunksToDecode = windowChunks.filter((chunk) => {
-      const chunkEndUs = chunk.timestamp + (chunk.duration ?? 0);
-      const chunkCoverage = this.deps.cacheManager.getAudioRangeCoverage(
-        clipId,
-        chunk.timestamp,
-        chunkEndUs,
-        0.95
-        // Stricter threshold for individual chunks
-      );
-      return !chunkCoverage.covered;
-    });
-    if (chunksToDecode.length === 0) {
-      return;
-    }
-    await this.decodeAudioSamples(
-      clipId,
-      chunksToDecode,
-      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, 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;
-      }
-    }
-    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();
-    }
-  }
-  audioBufferToAudioData(buffer, timestampUs) {
-    const sampleRate = buffer.sampleRate;
-    const numberOfChannels = buffer.numberOfChannels;
-    const numberOfFrames = buffer.length;
-    const planes = [];
-    for (let channel = 0; channel < numberOfChannels; channel++) {
-      planes.push(buffer.getChannelData(channel));
-    }
-    return new AudioData({
-      format: "f32-planar",
-      sampleRate,
-      numberOfFrames,
-      numberOfChannels,
-      timestamp: timestampUs,
-      data: this.packPlanarF32Data(planes)
-    });
-  }
-  packPlanarF32Data(planes) {
-    const numberOfChannels = planes.length;
-    const numberOfFrames = planes[0]?.length ?? 0;
-    const totalSamples = numberOfChannels * numberOfFrames;
-    const packed = new Float32Array(totalSamples);
-    for (let channel = 0; channel < numberOfChannels; channel++) {
-      const plane = planes[channel];
-      if (!plane) continue;
-      packed.set(plane, channel * numberOfFrames);
-    }
-    return packed.buffer;
-  }
-}
-export {
-  GlobalAudioSession
-};
-//# sourceMappingURL=GlobalAudioSession.js.map