@meframe/core 0.0.1 → 0.0.3

package/dist/workers/stages/compose/audio-compose.worker.js

@@ -0,0 +1,1063 @@
+import { W as WorkerChannel, a as WorkerMessageType, b as WorkerState } from "../../WorkerChannel.js";
+class AudioMixer {
+  config;
+  tracksMap = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  updateConfig(update) {
+    this.config = { ...this.config, ...update };
+  }
+  get tracks() {
+    return Array.from(this.tracksMap.values());
+  }
+  createMixStream(ducker) {
+    return new TransformStream(
+      {
+        transform: async (request, controller) => {
+          try {
+            const frameCount = this.getFrameCount(request.durationUs);
+            if (ducker && request.duckingConfig?.enabled && frameCount > 0) {
+              const envelope = await ducker.generateDuckingEnvelope(request.tracks, frameCount);
+              for (const track of request.tracks) {
+                if (request.duckingConfig.targetTracks.includes(track.trackId)) {
+                  track.duckingEnvelope = ducker.applyEnvelopeToVolume(1, envelope);
+                }
+              }
+            }
+            const result = await this.mixTracks(request, frameCount);
+            controller.enqueue(result);
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      },
+      {
+        highWaterMark: 2,
+        size: () => 1
+      }
+    );
+  }
+  async mixTracks(request, precomputedFrameCount) {
+    const tracks = request.tracks ?? [];
+    const frameCount = precomputedFrameCount ?? this.getFrameCount(request.durationUs);
+    const requestedChannelCount = this.config.numberOfChannels ?? 0;
+    const inferredChannelCount = tracks.reduce((max, track) => {
+      const trackChannels = track?.numberOfChannels ?? track?.audioData?.numberOfChannels ?? this.config.numberOfChannels ?? 0;
+      return trackChannels > max ? trackChannels : max;
+    }, 0);
+    const channelCount = requestedChannelCount > 0 ? requestedChannelCount : Math.max(inferredChannelCount, 1);
+    const outputChannels = Array.from({ length: channelCount }, () => {
+      return new Float32Array(frameCount);
+    });
+    for (const track of tracks) {
+      if (!track) {
+        continue;
+      }
+      const resolvedAudioData = track.audioData;
+      if (!resolvedAudioData) {
+        continue;
+      }
+      this.mixTrackIntoOutput(
+        outputChannels,
+        {
+          ...track,
+          audioData: resolvedAudioData,
+          numberOfChannels: track.numberOfChannels ?? resolvedAudioData.numberOfChannels ?? this.config.numberOfChannels,
+          sampleRate: track.sampleRate ?? resolvedAudioData.sampleRate ?? this.config.sampleRate
+        },
+        request.timeUs,
+        frameCount
+      );
+    }
+    const { peakLevel, rmsLevel } = this.limitAndMeasure(outputChannels);
+    const audioData = this.createAudioData(outputChannels, request.timeUs);
+    return {
+      audioData,
+      timeUs: request.timeUs,
+      durationUs: request.durationUs,
+      peakLevel,
+      rmsLevel
+    };
+  }
+  addTrack(track) {
+    this.tracksMap.set(track.id, track);
+  }
+  removeTrack(trackId) {
+    this.tracksMap.delete(trackId);
+  }
+  updateTrack(trackId, patch) {
+    const track = this.tracksMap.get(trackId);
+    if (!track) {
+      return;
+    }
+    const { config, ...rest } = patch;
+    if (config) {
+      Object.assign(track.config, config);
+    }
+    Object.assign(track, rest);
+  }
+  mixTrackIntoOutput(outputChannels, track, mixStartUs, totalFrameCount) {
+    if (totalFrameCount === 0) {
+      track.audioData.close();
+      return;
+    }
+    if (track.sampleRate !== this.config.sampleRate) {
+      track.audioData.close();
+      throw new Error("AudioMixer: sample rate mismatch");
+    }
+    const trackChannelCount = track.audioData.numberOfChannels ?? track.numberOfChannels ?? 0;
+    if (trackChannelCount === 0) {
+      track.audioData.close();
+      return;
+    }
+    const trackChannels = this.extractChannels(track.audioData);
+    if (trackChannels.length === 0) {
+      track.audioData.close();
+      return;
+    }
+    const trackFrameCount = track.audioData.numberOfFrames;
+    if (trackFrameCount === 0) {
+      track.audioData.close();
+      return;
+    }
+    const timestampUs = track.audioData.timestamp ?? mixStartUs;
+    const deltaUs = timestampUs - mixStartUs;
+    let outputOffsetFrames = Math.round(deltaUs / 1e6 * this.config.sampleRate);
+    let sourceOffsetFrames = 0;
+    if (outputOffsetFrames < 0) {
+      sourceOffsetFrames = Math.min(trackFrameCount, -outputOffsetFrames);
+      outputOffsetFrames = 0;
+    }
+    if (outputOffsetFrames >= totalFrameCount) {
+      track.audioData.close();
+      return;
+    }
+    const availableFrames = Math.min(
+      trackFrameCount - sourceOffsetFrames,
+      totalFrameCount - outputOffsetFrames
+    );
+    if (availableFrames <= 0) {
+      track.audioData.close();
+      return;
+    }
+    const gains = this.buildGainEnvelope(
+      track,
+      availableFrames,
+      outputOffsetFrames,
+      sourceOffsetFrames,
+      trackFrameCount
+    );
+    const destinationChannelCount = outputChannels.length;
+    const sourceChannelCount = trackChannels.length;
+    for (let channelIndex = 0; channelIndex < destinationChannelCount; channelIndex++) {
+      const destination = outputChannels[channelIndex];
+      const source = trackChannels[channelIndex] ?? trackChannels[sourceChannelCount - 1];
+      if (!destination || !source) continue;
+      for (let frameIndex = 0; frameIndex < availableFrames; frameIndex++) {
+        const sample = source[sourceOffsetFrames + frameIndex] ?? 0;
+        const gain = gains[frameIndex] ?? 0;
+        destination[outputOffsetFrames + frameIndex] = (destination[outputOffsetFrames + frameIndex] ?? 0) + sample * gain;
+      }
+    }
+    track.audioData.close();
+  }
+  buildGainEnvelope(track, length, outputOffsetFrames, sourceOffsetFrames, trackFrameCount) {
+    const gains = new Float32Array(length);
+    const baseVolume = typeof track.config.volume === "number" ? track.config.volume : 1;
+    gains.fill(baseVolume);
+    const fadeInSamples = this.getFadeSampleCount(track.config.fadeIn);
+    const fadeOutSamples = this.getFadeSampleCount(track.config.fadeOut);
+    const clipDurationSamples = this.getClipSampleCount(track.config.durationUs) || trackFrameCount;
+    const trackStartFrame = this.computeTrackStartFrame(track);
+    for (let i = 0; i < length; i++) {
+      const envelopeIndex = outputOffsetFrames + i;
+      const absoluteFrame = trackStartFrame + sourceOffsetFrames + i;
+      let gain = baseVolume;
+      if (fadeInSamples > 0 && absoluteFrame < fadeInSamples) {
+        const progress = Math.min(1, absoluteFrame / fadeInSamples);
+        gain *= this.getCurveValue(progress, track.config.fadeIn?.curve);
+      }
+      if (fadeOutSamples > 0 && clipDurationSamples > 0) {
+        const fadeStart = Math.max(0, clipDurationSamples - fadeOutSamples);
+        if (absoluteFrame >= fadeStart) {
+          const progress = Math.min(1, (absoluteFrame - fadeStart) / fadeOutSamples);
+          const remaining = Math.max(0, 1 - progress);
+          gain *= this.getCurveValue(remaining, track.config.fadeOut?.curve);
+        }
+      }
+      if (track.duckingEnvelope && envelopeIndex < track.duckingEnvelope.length && envelopeIndex >= 0) {
+        gain *= track.duckingEnvelope[envelopeIndex] ?? 1;
+      }
+      gains[i] = gain;
+    }
+    return gains;
+  }
+  extractChannels(audioData) {
+    const configuredChannels = this.config.numberOfChannels ?? 0;
+    const channelCount = audioData.numberOfChannels ?? configuredChannels;
+    const frameCount = audioData.numberOfFrames;
+    const format = audioData.format ?? "f32";
+    if (!channelCount || !frameCount) {
+      return [];
+    }
+    const toFloat = (value) => value / 32768;
+    const zeroChannels = () => Array.from(
+      { length: configuredChannels || channelCount },
+      () => new Float32Array(frameCount)
+    );
+    if (format === "f32") {
+      const interleaved = new Float32Array(frameCount * channelCount);
+      audioData.copyTo(interleaved, { format: "f32", planeIndex: 0 });
+      const channels2 = zeroChannels();
+      for (let frame = 0; frame < frameCount; frame++) {
+        const offset = frame * channelCount;
+        for (let channel = 0; channel < channels2.length; channel++) {
+          const channelArray = channels2[channel];
+          if (!channelArray) continue;
+          const sourceChannel = channel < channelCount ? channel : channelCount - 1;
+          channelArray[frame] = interleaved[offset + sourceChannel] ?? 0;
+        }
+      }
+      return channels2;
+    }
+    if (format === "s16") {
+      const interleaved = new Int16Array(frameCount * channelCount);
+      audioData.copyTo(interleaved, { format: "s16", planeIndex: 0 });
+      const channels2 = zeroChannels();
+      for (let frame = 0; frame < frameCount; frame++) {
+        const offset = frame * channelCount;
+        for (let channel = 0; channel < channels2.length; channel++) {
+          const channelArray = channels2[channel];
+          if (!channelArray) continue;
+          const sourceChannel = channel < channelCount ? channel : channelCount - 1;
+          channelArray[frame] = toFloat(interleaved[offset + sourceChannel] ?? 0);
+        }
+      }
+      return channels2;
+    }
+    if (format === "f32-planar") {
+      const channels2 = zeroChannels();
+      for (let channel = 0; channel < channels2.length; channel++) {
+        const channelArray = channels2[channel];
+        if (!channelArray) continue;
+        const sourceChannel = channel < channelCount ? channel : channelCount - 1;
+        audioData.copyTo(channelArray, { planeIndex: sourceChannel, format: "f32-planar" });
+      }
+      return channels2;
+    }
+    if (format === "s16-planar") {
+      const tmp = new Int16Array(frameCount);
+      const channels2 = zeroChannels();
+      for (let channel = 0; channel < channels2.length; channel++) {
+        const channelArray = channels2[channel];
+        if (!channelArray) continue;
+        const sourceChannel = channel < channelCount ? channel : channelCount - 1;
+        audioData.copyTo(tmp, { planeIndex: sourceChannel, format: "s16-planar" });
+        for (let i = 0; i < frameCount; i++) {
+          channelArray[i] = toFloat(tmp[i] ?? 0);
+        }
+      }
+      return channels2;
+    }
+    const channels = zeroChannels();
+    for (let channel = 0; channel < channels.length; channel++) {
+      const channelArray = channels[channel];
+      if (!channelArray) continue;
+      const sourceChannel = channel < channelCount ? channel : channelCount - 1;
+      audioData.copyTo(channelArray, { planeIndex: sourceChannel });
+    }
+    return channels;
+  }
+  limitAndMeasure(channels) {
+    let peak = 0;
+    let sumSquares = 0;
+    let samples = 0;
+    for (const channel of channels) {
+      for (let i = 0; i < channel.length; i++) {
+        let sample = channel[i] ?? 0;
+        if (sample > 1) {
+          sample = 1;
+        } else if (sample < -1) {
+          sample = -1;
+        }
+        channel[i] = sample;
+        const absSample = Math.abs(sample);
+        if (absSample > peak) {
+          peak = absSample;
+        }
+        sumSquares += sample * sample;
+        samples++;
+      }
+    }
+    const rmsLevel = samples > 0 ? Math.sqrt(sumSquares / samples) : 0;
+    return {
+      peakLevel: peak,
+      rmsLevel
+    };
+  }
+  createAudioData(channels, timestampUs) {
+    const configuredChannels = this.config.numberOfChannels ?? 0;
+    const inferredChannels = channels.length;
+    const numberOfChannels = (inferredChannels > 0 ? inferredChannels : configuredChannels) || 1;
+    const numberOfFrames = channels[0]?.length ?? 0;
+    if (numberOfFrames === 0) {
+      return new AudioData({
+        format: "f32",
+        sampleRate: this.config.sampleRate,
+        numberOfFrames: 0,
+        numberOfChannels,
+        timestamp: timestampUs,
+        data: new Float32Array(0)
+      });
+    }
+    const interleaved = new Float32Array(numberOfFrames * numberOfChannels);
+    for (let frame = 0; frame < numberOfFrames; frame++) {
+      for (let channel = 0; channel < numberOfChannels; channel++) {
+        const sourceChannel = channels[channel] ?? channels[channels.length - 1];
+        interleaved[frame * numberOfChannels + channel] = sourceChannel?.[frame] ?? 0;
+      }
+    }
+    return new AudioData({
+      format: "f32",
+      sampleRate: this.config.sampleRate,
+      numberOfFrames,
+      numberOfChannels,
+      timestamp: timestampUs,
+      data: interleaved
+    });
+  }
+  getFrameCount(durationUs) {
+    if (durationUs <= 0) {
+      return 0;
+    }
+    return Math.ceil(durationUs / 1e6 * this.config.sampleRate);
+  }
+  getFadeSampleCount(fade) {
+    if (!fade || fade.durationUs <= 0) {
+      return 0;
+    }
+    return Math.round(fade.durationUs / 1e6 * this.config.sampleRate);
+  }
+  getClipSampleCount(durationUs) {
+    if (!durationUs || durationUs <= 0) {
+      return 0;
+    }
+    return Math.round(durationUs / 1e6 * this.config.sampleRate);
+  }
+  computeTrackStartFrame(track) {
+    const audioTimestamp = track.audioData.timestamp ?? track.config.startTimeUs;
+    const relativeUs = audioTimestamp - track.config.startTimeUs;
+    const relativeFrames = Math.round(relativeUs / 1e6 * this.config.sampleRate);
+    return relativeFrames > 0 ? relativeFrames : 0;
+  }
+  getCurveValue(progress, curve = "linear") {
+    const clamped = Math.min(Math.max(progress, 0), 1);
+    switch (curve) {
+      case "exponential":
+        return clamped * clamped;
+      case "logarithmic":
+        return Math.log10(clamped * 9 + 1);
+      case "cosine":
+        return (1 - Math.cos(clamped * Math.PI)) / 2;
+      default:
+        return clamped;
+    }
+  }
+}
+class AudioDucker {
+  config = null;
+  sampleRate;
+  constructor(sampleRate) {
+    this.sampleRate = sampleRate;
+  }
+  configure(config) {
+    this.config = config;
+  }
+  /**
+   * Analyze trigger tracks (voice) and generate ducking envelope
+   * Returns gain values (0-1) to apply to target tracks (BGM)
+   */
+  async generateDuckingEnvelope(tracks, frameCount) {
+    if (!this.config?.enabled) {
+      return new Float32Array(frameCount).fill(1);
+    }
+    const envelope = new Float32Array(frameCount);
+    envelope.fill(1);
+    const triggerTracks = tracks.filter((t) => this.config.triggerTracks.includes(t.trackId));
+    if (triggerTracks.length === 0) {
+      return envelope;
+    }
+    for (const track of triggerTracks) {
+      const voiceActivity = await this.detectVoiceActivity(track.audioData);
+      this.applyDuckingToEnvelope(envelope, voiceActivity);
+    }
+    return envelope;
+  }
+  /**
+   * Voice Activity Detection (VAD)
+   * Simple energy-based detection with smoothing
+   * More sophisticated implementations could use:
+   * - Zero-crossing rate (ZCR) for speech/music discrimination
+   * - Spectral centroid for voice frequency detection
+   * - Machine learning models for robust VAD
+   */
+  async detectVoiceActivity(audioData) {
+    const frameCount = audioData.numberOfFrames;
+    const activity = new Float32Array(frameCount);
+    const monoData = new Float32Array(frameCount);
+    const channelData = new Float32Array(frameCount);
+    for (let ch = 0; ch < audioData.numberOfChannels; ch++) {
+      audioData.copyTo(channelData, {
+        planeIndex: ch,
+        format: "f32-planar"
+      });
+      for (let i = 0; i < frameCount; i++) {
+        if (monoData && channelData) {
+          monoData[i] = (monoData[i] || 0) + (channelData[i] || 0) / audioData.numberOfChannels;
+        }
+      }
+    }
+    const windowSize = Math.floor(this.sampleRate * 0.02);
+    const hopSize = Math.floor(windowSize / 2);
+    for (let i = 0; i < frameCount; i += hopSize) {
+      const end = Math.min(i + windowSize, frameCount);
+      let energy = 0;
+      for (let j = i; j < end; j++) {
+        if (monoData && monoData[j] !== void 0) {
+          const sample = monoData[j];
+          if (sample !== void 0) {
+            energy += sample * sample;
+          }
+        }
+      }
+      energy = Math.sqrt(energy / (end - i));
+      const threshold = 0.01;
+      const isVoice = energy > threshold;
+      for (let j = i; j < end; j++) {
+        activity[j] = isVoice ? 1 : 0;
+      }
+    }
+    return this.smoothActivityDetection(activity);
+  }
+  /**
+   * Smooth voice activity detection to avoid choppy ducking
+   * Uses a simple moving average filter
+   */
+  smoothActivityDetection(activity) {
+    const smoothed = new Float32Array(activity.length);
+    const smoothWindow = Math.floor(this.sampleRate * 0.05);
+    for (let i = 0; i < activity.length; i++) {
+      let sum = 0;
+      let count = 0;
+      for (let j = Math.max(0, i - smoothWindow); j <= Math.min(activity.length - 1, i + smoothWindow); j++) {
+        if (activity && activity[j] !== void 0) {
+          const val = activity[j];
+          if (val !== void 0) {
+            sum += val;
+          }
+        }
+        count++;
+      }
+      smoothed[i] = sum / count;
+    }
+    return smoothed;
+  }
+  /**
+   * Apply ducking based on voice activity
+   * Implements attack/release envelope shaping
+   */
+  applyDuckingToEnvelope(envelope, voiceActivity) {
+    if (!this.config) return;
+    const duckingLevel = 1 - this.config.duckingLevel;
+    const attackSamples = Math.floor(this.config.attackTimeMs / 1e3 * this.sampleRate);
+    const releaseSamples = Math.floor(this.config.releaseTimeMs / 1e3 * this.sampleRate);
+    const lookAheadSamples = this.config.lookAheadMs ? Math.floor(this.config.lookAheadMs / 1e3 * this.sampleRate) : 0;
+    let currentGain = 1;
+    let releaseCounter = 0;
+    for (let i = 0; i < envelope.length; i++) {
+      const lookAheadIndex = Math.min(i + lookAheadSamples, voiceActivity.length - 1);
+      const activity = voiceActivity[lookAheadIndex];
+      if (activity !== void 0 && activity > 0.5) {
+        if (currentGain > duckingLevel) {
+          currentGain = Math.max(duckingLevel, currentGain - (1 - duckingLevel) / attackSamples);
+        } else {
+          currentGain = duckingLevel;
+        }
+        releaseCounter = 0;
+      } else if (currentGain < 1) {
+        releaseCounter++;
+        if (releaseCounter > releaseSamples * 0.1) {
+          currentGain = Math.min(1, currentGain + (1 - duckingLevel) / releaseSamples);
+        }
+      }
+      envelope[i] = Math.min(envelope[i] || 1, currentGain);
+    }
+  }
+  /**
+   * Apply ducking envelope to audio buffer
+   * This modulates the volume over time according to the envelope
+   */
+  applyEnvelopeToVolume(baseVolume, envelope) {
+    const result = new Float32Array(envelope.length);
+    for (let i = 0; i < envelope.length; i++) {
+      result[i] = baseVolume * (envelope[i] || 1);
+    }
+    return result;
+  }
+  /**
+   * Calculate dynamic range to avoid over-compression
+   * Returns the difference between peak and RMS levels in dB
+   */
+  calculateDynamicRange(envelope) {
+    let peak = 0;
+    let sumSquares = 0;
+    for (const value of envelope) {
+      peak = Math.max(peak, value);
+      sumSquares += value * value;
+    }
+    const rms = Math.sqrt(sumSquares / envelope.length);
+    const peakDb = 20 * Math.log10(peak);
+    const rmsDb = 20 * Math.log10(rms);
+    return peakDb - rmsDb;
+  }
+}
+class AudioComposeWorker {
+  channel;
+  mixer = null;
+  ducker = null;
+  mixStream = null;
+  // Connections to other workers
+  decoderPort = null;
+  encoderPort = null;
+  // Track buffer map
+  trackBuffers = /* @__PURE__ */ new Map();
+  trackQueueWaiters = /* @__PURE__ */ new Map();
+  encoderStreamAttached = false;
+  mixWindowUs = 4e4;
+  // 40ms window
+  maxQueuedSegments = 8;
+  mixing = false;
+  constructor() {
+    this.channel = new WorkerChannel(self, {
+      name: "AudioComposeWorker",
+      timeout: 3e4
+    });
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.channel.registerHandler("configure", this.handleConfigure.bind(this));
+    this.channel.registerHandler("connect", this.handleConnect.bind(this));
+    this.channel.registerHandler("add_track", this.handleAddTrack.bind(this));
+    this.channel.registerHandler("remove_track", this.handleRemoveTrack.bind(this));
+    this.channel.registerHandler("update_track", this.handleUpdateTrack.bind(this));
+    this.channel.registerHandler("configure_ducking", this.handleConfigureDucking.bind(this));
+    this.channel.registerHandler("get_stats", this.handleGetStats.bind(this));
+    this.channel.registerHandler(WorkerMessageType.Dispose, this.handleDispose.bind(this));
+  }
+  /** Unified connect handler mapping for stream pipeline */
+  async handleConnect(payload) {
+    if (payload.direction === "upstream") {
+      this.decoderPort = payload.port;
+      const decoderChannel = new WorkerChannel(this.decoderPort, {
+        name: "AudioCompose-Decoder",
+        timeout: 3e4
+      });
+      decoderChannel.registerHandler("audio_track:add", this.handleAddTrack.bind(this));
+      decoderChannel.registerHandler("audio_track:remove", this.handleRemoveTrack.bind(this));
+      decoderChannel.registerHandler("audio_track:update", this.handleUpdateTrack.bind(this));
+      decoderChannel.receiveStream(this.handleReceiveStream.bind(this));
+      return { success: true };
+    }
+    if (payload.direction === "downstream") {
+      this.encoderPort = payload.port;
+      return { success: true };
+    }
+    return { success: true };
+  }
+  async handleReceiveStream(stream, metadata) {
+    if (metadata?.streamType !== "audio" || !this.mixStream || !this.mixer) {
+      return;
+    }
+    const update = {};
+    const currentConfig = this.mixer.getConfig();
+    if (typeof metadata?.sampleRate === "number" && metadata.sampleRate > 0) {
+      if (!currentConfig.sampleRate || currentConfig.sampleRate !== metadata.sampleRate) {
+        update.sampleRate = metadata.sampleRate;
+      }
+    }
+    if (typeof metadata?.numberOfChannels === "number" && metadata.numberOfChannels > 0) {
+      if (!currentConfig.numberOfChannels || metadata.numberOfChannels > currentConfig.numberOfChannels) {
+        update.numberOfChannels = metadata.numberOfChannels;
+      }
+    }
+    if (Object.keys(update).length > 0) {
+      this.mixer.updateConfig(update);
+    }
+    const mixerConfig = this.mixer.getConfig();
+    const streamMetadata = {
+      ...metadata,
+      streamType: "audio",
+      sampleRate: mixerConfig.sampleRate,
+      numberOfChannels: mixerConfig.numberOfChannels
+    };
+    await this.attachEncodeStream(streamMetadata);
+    const trackId = metadata?.trackId ?? metadata?.clipId;
+    if (!trackId) {
+      console.warn("[AudioComposeWorker] Missing track identifier in audio stream metadata");
+      await stream.cancel();
+      return;
+    }
+    await this.bufferTrackStream(trackId, stream, streamMetadata);
+    this.scheduleMix();
+  }
+  /**
+   * Configure audio composer
+   * @param payload.config - Audio composition configuration
+   * @param payload.initial - If true, initialize worker state; otherwise just update config
+   */
+  async handleConfigure(payload) {
+    const { config, initial = false } = payload;
+    try {
+      if (initial) {
+        this.channel.state = WorkerState.Ready;
+        this.mixer = new AudioMixer(config);
+        this.ducker = new AudioDucker(config.sampleRate);
+        this.mixStream = this.mixer.createMixStream(this.ducker);
+        this.channel.notify("configured", {
+          sampleRate: config.sampleRate,
+          numberOfChannels: config.numberOfChannels
+        });
+      } else {
+        if (!this.mixer || !this.ducker) {
+          throw {
+            code: "NOT_INITIALIZED",
+            message: "Audio composer not initialized. Call configure with initial=true first"
+          };
+        }
+      }
+      return { success: true };
+    } catch (error) {
+      throw {
+        code: error.code || "CONFIG_ERROR",
+        message: error.message
+      };
+    }
+  }
+  /**
+   * Connect to decoder worker to receive audio streams
+   */
+  /**
+   * Add an audio track
+   */
+  handleAddTrack(payload) {
+    if (!this.mixer) {
+      throw {
+        code: "NOT_CONFIGURED",
+        message: "Mixer not configured"
+      };
+    }
+    const config = this.cloneTrackConfig(payload.config);
+    const track = {
+      id: payload.trackId,
+      clipId: payload.clipId,
+      type: payload.type ?? "other",
+      config
+    };
+    this.mixer.addTrack(track);
+    this.trackBuffers.set(payload.trackId, {
+      clipId: payload.clipId,
+      queue: [],
+      ended: false,
+      config,
+      type: payload.type ?? "other"
+    });
+    this.channel.notify("track_added", {
+      trackId: track.id,
+      trackType: track.type
+    });
+    return { success: true };
+  }
+  /**
+   * Remove an audio track
+   */
+  handleRemoveTrack(payload) {
+    if (!this.mixer) {
+      throw {
+        code: "NOT_CONFIGURED",
+        message: "Mixer not configured"
+      };
+    }
+    this.mixer.removeTrack(payload.trackId);
+    this.disposeTrackBuffer(payload.trackId);
+    this.channel.notify("track_removed", {
+      trackId: payload.trackId
+    });
+    return { success: true };
+  }
+  /**
+   * Update track configuration
+   */
+  handleUpdateTrack(payload) {
+    if (!this.mixer) {
+      throw {
+        code: "NOT_CONFIGURED",
+        message: "Mixer not configured"
+      };
+    }
+    this.mixer.updateTrack(payload.trackId, payload.config);
+    const buffer = this.trackBuffers.get(payload.trackId);
+    if (buffer) {
+      if (payload.config.type) {
+        buffer.type = payload.config.type;
+      }
+      this.applyTrackConfigPatch(buffer.config, payload.config);
+    }
+    this.channel.notify("track_updated", {
+      trackId: payload.trackId
+    });
+    return { success: true };
+  }
+  /**
+   * Configure audio ducking
+   */
+  handleConfigureDucking(config) {
+    if (!this.ducker) {
+      throw {
+        code: "NOT_CONFIGURED",
+        message: "Ducker not configured"
+      };
+    }
+    this.ducker.configure(config);
+    this.channel.notify("ducking_configured", {
+      enabled: config.enabled
+    });
+    return { success: true };
+  }
+  /**
+   * Get mixer statistics
+   */
+  async handleGetStats() {
+    if (!this.mixer) {
+      return { state: this.channel.state };
+    }
+    return {
+      tracks: this.mixer.tracks,
+      ducking: this.ducker ? {
+        configured: this.ducker !== null
+      } : null,
+      state: this.channel.state
+    };
+  }
+  /**
+   * Dispose worker and cleanup resources
+   */
+  async handleDispose() {
+    this.mixer = null;
+    this.ducker = null;
+    this.mixStream = null;
+    this.decoderPort?.close();
+    this.decoderPort = null;
+    this.encoderPort?.close();
+    this.encoderPort = null;
+    this.channel.state = WorkerState.Disposed;
+    return { success: true };
+  }
+  async attachEncodeStream(metadata) {
+    if (!this.mixStream || !this.encoderPort || this.encoderStreamAttached || !this.mixer) {
+      return;
+    }
+    const encoderChannel = new WorkerChannel(this.encoderPort, {
+      name: "AudioCompose-Encoder",
+      timeout: 3e4
+    });
+    const mixerConfig = this.mixer?.getConfig();
+    const streamMetadata = {
+      ...metadata,
+      streamType: "audio",
+      sampleRate: mixerConfig?.sampleRate ?? metadata?.sampleRate,
+      numberOfChannels: mixerConfig?.numberOfChannels ?? metadata?.numberOfChannels
+    };
+    const [encoderResultStream, previewResultStream] = this.mixStream.readable.tee();
+    const createAudioDataStream = (source) => {
+      return new ReadableStream({
+        start: (controller) => {
+          const reader = source.getReader();
+          const pump = async () => {
+            const { done, value } = await reader.read();
+            if (done) {
+              reader.releaseLock();
+              controller.close();
+              return;
+            }
+            try {
+              controller.enqueue(value.audioData);
+            } catch (error) {
+              controller.error(error);
+              reader.releaseLock();
+              return;
+            }
+            await pump();
+          };
+          pump().catch((error) => {
+            reader.releaseLock();
+            controller.error(error);
+          });
+        }
+      });
+    };
+    const encoderStream = createAudioDataStream(encoderResultStream);
+    const previewStream = createAudioDataStream(previewResultStream);
+    await encoderChannel.sendStream(encoderStream, streamMetadata);
+    this.channel.sendStream(previewStream, streamMetadata);
+    this.encoderStreamAttached = true;
+    await this.scheduleMix();
+  }
+  async bufferTrackStream(trackId, stream, metadata) {
+    const buffer = this.trackBuffers.get(trackId);
+    if (!buffer) {
+      await stream.cancel();
+      return;
+    }
+    const reader = stream.getReader();
+    const process = async () => {
+      while (true) {
+        if (buffer.queue.length >= this.maxQueuedSegments) {
+          await this.waitForQueueSpace(trackId);
+        }
+        const { done, value } = await reader.read();
+        if (done) {
+          buffer.ended = true;
+          reader.releaseLock();
+          return;
+        }
+        buffer.queue.push({
+          audioData: value,
+          timestampUs: value.timestamp ?? 0,
+          durationUs: value.duration ?? Math.round(value.numberOfFrames / (metadata.sampleRate ?? 48e3) * 1e6)
+        });
+        this.scheduleMix();
+      }
+    };
+    process().catch((error) => {
+      buffer.ended = true;
+      reader.releaseLock();
+      console.error("[AudioComposeWorker] Track stream error:", error);
+    });
+  }
+  async scheduleMix() {
+    if (this.mixing || !this.mixStream || !this.encoderStreamAttached || !this.mixer) {
+      return;
+    }
+    const window = this.computeNextWindow();
+    if (!window) {
+      return;
+    }
+    this.mixing = true;
+    try {
+      const request = this.buildMixRequest(window.timeUs, window.durationUs);
+      if (!request) {
+        return;
+      }
+      const writer = this.mixStream.writable.getWriter();
+      try {
+        await writer.write(request);
+      } finally {
+        writer.releaseLock();
+      }
+    } catch (error) {
+      console.error("[AudioComposeWorker] Failed to enqueue mix request:", error);
+    } finally {
+      this.mixing = false;
+      if (this.hasBufferedAudio()) {
+        queueMicrotask(() => {
+          void this.scheduleMix();
+        });
+      }
+    }
+  }
+  computeNextWindow() {
+    let earliest = null;
+    for (const buffer of this.trackBuffers.values()) {
+      if (buffer.queue.length === 0) {
+        continue;
+      }
+      const firstFrame = buffer.queue[0];
+      if (!firstFrame) {
+        continue;
+      }
+      const ts = firstFrame.timestampUs;
+      if (earliest === null || ts < earliest) {
+        earliest = ts;
+      }
+    }
+    if (earliest === null) {
+      return null;
+    }
+    return {
+      timeUs: earliest,
+      durationUs: this.mixWindowUs
+    };
+  }
+  buildMixRequest(timeUs, _durationUs) {
+    if (!this.mixer) {
+      return null;
+    }
+    const tracks = [];
+    let resolvedDurationUs = this.mixWindowUs;
+    for (const [trackId, buffer] of this.trackBuffers.entries()) {
+      const segment = this.consumeSegment(trackId, buffer);
+      if (!segment) {
+        continue;
+      }
+      tracks.push({
+        trackId,
+        clipId: buffer.clipId,
+        audioData: segment.audioData,
+        config: segment.config,
+        type: buffer.type,
+        sampleRate: this.mixer.config.sampleRate,
+        numberOfChannels: this.mixer.config.numberOfChannels
+      });
+      resolvedDurationUs = Math.min(resolvedDurationUs, segment.durationUs ?? this.mixWindowUs);
+    }
+    if (tracks.length === 0) {
+      return null;
+    }
+    return {
+      tracks,
+      timeUs,
+      durationUs: resolvedDurationUs
+    };
+  }
+  consumeSegment(trackId, buffer) {
+    if (buffer.queue.length === 0) {
+      return null;
+    }
+    const head = buffer.queue[0];
+    if (!head) {
+      return null;
+    }
+    const queueItem = buffer.queue.shift();
+    if (!queueItem) {
+      return null;
+    }
+    this.resolveQueueWaiter(trackId);
+    return {
+      audioData: queueItem.audioData,
+      config: buffer.config,
+      sampleRate: this.mixer.config.sampleRate,
+      numberOfChannels: this.mixer.config.numberOfChannels,
+      durationUs: queueItem.durationUs
+    };
+  }
+  hasBufferedAudio() {
+    for (const buffer of this.trackBuffers.values()) {
+      if (buffer.queue.length > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  cloneTrackConfig(config) {
+    return {
+      startTimeUs: config.startTimeUs,
+      durationUs: config.durationUs,
+      volume: config.volume,
+      fadeIn: config.fadeIn ? { ...config.fadeIn } : void 0,
+      fadeOut: config.fadeOut ? { ...config.fadeOut } : void 0,
+      effects: config.effects ? config.effects.map((effect) => ({
+        type: effect.type,
+        params: effect.params ?? {}
+      })) : void 0,
+      duckingTag: config.duckingTag
+    };
+  }
+  applyTrackConfigPatch(target, patch) {
+    if (patch.fadeIn) {
+      target.fadeIn = { ...patch.fadeIn };
+    } else if (patch.fadeIn === null) {
+      target.fadeIn = void 0;
+    }
+    if (patch.fadeOut) {
+      target.fadeOut = { ...patch.fadeOut };
+    } else if (patch.fadeOut === null) {
+      target.fadeOut = void 0;
+    }
+    if (patch.effects) {
+      target.effects = patch.effects.map((effect) => ({
+        type: effect.type,
+        params: effect.params ?? {}
+      }));
+    }
+    if (typeof patch.volume === "number") {
+      target.volume = patch.volume;
+    }
+    if (patch.startTimeUs !== void 0) {
+      target.startTimeUs = patch.startTimeUs;
+    }
+    if (patch.durationUs !== void 0) {
+      target.durationUs = patch.durationUs;
+    }
+    if (patch.duckingTag !== void 0) {
+      target.duckingTag = patch.duckingTag;
+    }
+  }
+  async waitForQueueSpace(trackId) {
+    const existing = this.trackQueueWaiters.get(trackId);
+    if (existing && existing.length === 0) {
+      this.trackQueueWaiters.delete(trackId);
+    }
+    await new Promise((resolve) => {
+      const waiters = this.trackQueueWaiters.get(trackId);
+      if (waiters) {
+        waiters.push(resolve);
+      } else {
+        this.trackQueueWaiters.set(trackId, [resolve]);
+      }
+    });
+  }
+  resolveQueueWaiter(trackId) {
+    const waiters = this.trackQueueWaiters.get(trackId);
+    if (!waiters || waiters.length === 0) {
+      return;
+    }
+    const resolve = waiters.shift();
+    resolve?.();
+    if (!waiters.length) {
+      this.trackQueueWaiters.delete(trackId);
+    }
+  }
+  disposeTrackBuffer(trackId) {
+    const buffer = this.trackBuffers.get(trackId);
+    if (!buffer) {
+      return;
+    }
+    for (const item of buffer.queue) {
+      try {
+        item.audioData.close();
+      } catch (error) {
+        console.warn("[AudioComposeWorker] Failed to close AudioData on disposal", error);
+      }
+    }
+    this.trackBuffers.delete(trackId);
+    const waiters = this.trackQueueWaiters.get(trackId);
+    if (waiters) {
+      waiters.forEach((resolve) => resolve());
+      this.trackQueueWaiters.delete(trackId);
+    }
+  }
+}
+const worker = new AudioComposeWorker();
+self.addEventListener("beforeunload", () => {
+  worker["handleDispose"]();
+});
+const audioCompose_worker = null;
+export {
+  AudioComposeWorker,
+  audioCompose_worker as default
+};
+//# sourceMappingURL=audio-compose.worker.js.map