@meframe/core 0.0.1 → 0.0.2

package/dist/assets/audio-compose.worker-nGVvHD5Q.js

@@ -0,0 +1,1537 @@
+var WorkerMessageType = /* @__PURE__ */ ((WorkerMessageType2) => {
+  WorkerMessageType2["Ready"] = "ready";
+  WorkerMessageType2["Error"] = "error";
+  WorkerMessageType2["Dispose"] = "dispose";
+  WorkerMessageType2["Configure"] = "configure";
+  WorkerMessageType2["LoadResource"] = "load_resource";
+  WorkerMessageType2["ResourceLoaded"] = "resource_loaded";
+  WorkerMessageType2["ResourceProgress"] = "resource_progress";
+  WorkerMessageType2["ConfigureDemux"] = "configure_demux";
+  WorkerMessageType2["AppendBuffer"] = "append_buffer";
+  WorkerMessageType2["DemuxSamples"] = "demux_samples";
+  WorkerMessageType2["FlushDemux"] = "flush_demux";
+  WorkerMessageType2["ConfigureDecode"] = "configure_decode";
+  WorkerMessageType2["DecodeChunk"] = "decode_chunk";
+  WorkerMessageType2["DecodedFrame"] = "decoded_frame";
+  WorkerMessageType2["SeekGop"] = "seek_gop";
+  WorkerMessageType2["SetComposition"] = "set_composition";
+  WorkerMessageType2["ApplyPatch"] = "apply_patch";
+  WorkerMessageType2["RenderFrame"] = "render_frame";
+  WorkerMessageType2["ComposeFrameReady"] = "compose_frame_ready";
+  WorkerMessageType2["ConfigureEncode"] = "configure_encode";
+  WorkerMessageType2["EncodeFrame"] = "encode_frame";
+  WorkerMessageType2["EncodeAudio"] = "encode_audio";
+  WorkerMessageType2["EncodedChunk"] = "encoded_chunk";
+  WorkerMessageType2["FlushEncode"] = "flush_encode";
+  WorkerMessageType2["ConfigureMux"] = "configure_mux";
+  WorkerMessageType2["AddChunk"] = "add_chunk";
+  WorkerMessageType2["FinishMux"] = "finish_mux";
+  WorkerMessageType2["MuxComplete"] = "mux_complete";
+  WorkerMessageType2["PerformanceStats"] = "performance_stats";
+  WorkerMessageType2["RenderWindow"] = "renderWindow";
+  WorkerMessageType2["AudioTrackAdd"] = "audio_track:add";
+  WorkerMessageType2["AudioTrackRemove"] = "audio_track:remove";
+  WorkerMessageType2["AudioTrackUpdate"] = "audio_track:update";
+  return WorkerMessageType2;
+})(WorkerMessageType || {});
+var WorkerState = /* @__PURE__ */ ((WorkerState2) => {
+  WorkerState2["Idle"] = "idle";
+  WorkerState2["Initializing"] = "initializing";
+  WorkerState2["Ready"] = "ready";
+  WorkerState2["Processing"] = "processing";
+  WorkerState2["Error"] = "error";
+  WorkerState2["Disposed"] = "disposed";
+  return WorkerState2;
+})(WorkerState || {});
+const defaultRetryConfig = {
+  maxRetries: 3,
+  initialDelay: 100,
+  maxDelay: 5e3,
+  backoffFactor: 2,
+  retryableErrors: ["TIMEOUT", "NETWORK_ERROR", "WORKER_BUSY"]
+};
+function calculateRetryDelay(attempt, config) {
+  const { initialDelay = 100, maxDelay = 5e3, backoffFactor = 2 } = config;
+  const delay = initialDelay * Math.pow(backoffFactor, attempt - 1);
+  return Math.min(delay, maxDelay);
+}
+function isRetryableError(error, config) {
+  const { retryableErrors = defaultRetryConfig.retryableErrors } = config;
+  if (!error) return false;
+  const errorCode = error.code || error.name;
+  if (errorCode && retryableErrors.includes(errorCode)) {
+    return true;
+  }
+  const message = error.message || "";
+  if (message.includes("timeout") || message.includes("Timeout")) {
+    return true;
+  }
+  return false;
+}
+async function withRetry(fn, config) {
+  const { maxRetries } = config;
+  let lastError;
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!isRetryableError(error, config)) {
+        throw error;
+      }
+      if (attempt === maxRetries) {
+        throw error;
+      }
+      const delay = calculateRetryDelay(attempt, config);
+      await sleep(delay);
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isTransferable(obj) {
+  return obj instanceof ArrayBuffer || obj instanceof MessagePort || typeof ImageBitmap !== "undefined" && obj instanceof ImageBitmap || typeof OffscreenCanvas !== "undefined" && obj instanceof OffscreenCanvas || typeof ReadableStream !== "undefined" && obj instanceof ReadableStream || typeof WritableStream !== "undefined" && obj instanceof WritableStream || typeof TransformStream !== "undefined" && obj instanceof TransformStream;
+}
+function findTransferables(obj, transferables) {
+  if (!obj || typeof obj !== "object") {
+    return;
+  }
+  if (isTransferable(obj)) {
+    transferables.push(obj);
+    return;
+  }
+  if (obj instanceof VideoFrame) {
+    transferables.push(obj);
+    return;
+  }
+  if (typeof AudioData !== "undefined" && obj instanceof AudioData) {
+    transferables.push(obj);
+    return;
+  }
+  if (typeof EncodedVideoChunk !== "undefined" && obj instanceof EncodedVideoChunk || typeof EncodedAudioChunk !== "undefined" && obj instanceof EncodedAudioChunk) {
+    return;
+  }
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      findTransferables(item, transferables);
+    }
+  } else {
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        findTransferables(obj[key], transferables);
+      }
+    }
+  }
+}
+function extractTransferables(payload) {
+  const transferables = [];
+  findTransferables(payload, transferables);
+  return transferables;
+}
+class WorkerChannel {
+  name;
+  port;
+  pendingRequests = /* @__PURE__ */ new Map();
+  messageHandlers = {};
+  state = WorkerState.Idle;
+  defaultTimeout;
+  defaultMaxRetries;
+  constructor(port, config) {
+    this.name = config.name;
+    this.port = port;
+    this.defaultTimeout = config.timeout ?? 3e4;
+    this.defaultMaxRetries = config.maxRetries ?? 3;
+    this.setupMessageHandler();
+    this.state = WorkerState.Ready;
+  }
+  /**
+   * Send a message and wait for response with retry support
+   */
+  async send(type, payload, options) {
+    const maxRetries = options?.maxRetries ?? this.defaultMaxRetries;
+    const retryConfig = {
+      ...defaultRetryConfig,
+      maxRetries,
+      ...options?.retryConfig
+    };
+    return withRetry(() => this.sendOnce(type, payload, options), retryConfig);
+  }
+  /**
+   * Send a message once (without retry)
+   */
+  async sendOnce(type, payload, options) {
+    const id = this.generateMessageId();
+    const timeout = options?.timeout ?? this.defaultTimeout;
+    const message = {
+      type,
+      id,
+      payload,
+      timestamp: Date.now()
+    };
+    return new Promise((resolve, reject) => {
+      const request = {
+        id,
+        type,
+        timestamp: Date.now(),
+        timeout,
+        resolve,
+        reject
+      };
+      this.pendingRequests.set(id, request);
+      const timeoutId = setTimeout(() => {
+        const pending = this.pendingRequests.get(id);
+        if (pending) {
+          this.pendingRequests.delete(id);
+          const error = new Error(`Request timeout: ${id} ${type} (${timeout}ms)`);
+          error.code = "TIMEOUT";
+          pending.reject(error);
+        }
+      }, timeout);
+      request.timeoutId = timeoutId;
+      if (options?.transfer) {
+        this.port.postMessage(message, options.transfer);
+      } else {
+        this.port.postMessage(message);
+      }
+    });
+  }
+  /**
+   * Send a message without waiting for response
+   */
+  post(type, payload, transfer) {
+    const message = {
+      type,
+      id: this.generateMessageId(),
+      payload,
+      timestamp: Date.now()
+    };
+    if (transfer) {
+      this.port.postMessage(message, transfer);
+    } else {
+      this.port.postMessage(message);
+    }
+  }
+  /**
+   * Register a message handler
+   */
+  on(type, handler) {
+    this.messageHandlers[type] = handler;
+  }
+  /**
+   * Unregister a message handler
+   */
+  off(type) {
+    delete this.messageHandlers[type];
+  }
+  /**
+   * Dispose the channel
+   */
+  dispose() {
+    this.state = WorkerState.Disposed;
+    for (const [, request] of this.pendingRequests) {
+      if (request.timeoutId) {
+        clearTimeout(request.timeoutId);
+      }
+      request.reject(new Error("Channel disposed"));
+    }
+    this.pendingRequests.clear();
+    this.port.onmessage = null;
+  }
+  /**
+   * Setup message handler for incoming messages
+   */
+  setupMessageHandler() {
+    this.port.onmessage = async (event) => {
+      const data = event.data;
+      if (this.isResponse(data)) {
+        this.handleResponse(data);
+        return;
+      }
+      if (this.isRequest(data)) {
+        await this.handleRequest(data);
+        return;
+      }
+    };
+  }
+  /**
+   * Handle incoming request
+   */
+  async handleRequest(message) {
+    const handler = this.messageHandlers[message.type];
+    if (!handler) {
+      this.sendResponse(message.id, false, null, {
+        code: "NO_HANDLER",
+        message: `No handler registered for message type: ${message.type}`
+      });
+      return;
+    }
+    this.state = WorkerState.Processing;
+    Promise.resolve().then(() => handler(message.payload, message.transfer)).then((result) => {
+      this.sendResponse(message.id, true, result);
+      this.state = WorkerState.Ready;
+    }).catch((error) => {
+      const workerError = {
+        code: "HANDLER_ERROR",
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      };
+      this.sendResponse(message.id, false, null, workerError);
+      this.state = WorkerState.Ready;
+    });
+  }
+  /**
+   * Handle incoming response
+   */
+  handleResponse(response) {
+    const request = this.pendingRequests.get(response.id);
+    if (!request) {
+      return;
+    }
+    this.pendingRequests.delete(response.id);
+    if (request.timeoutId) {
+      clearTimeout(request.timeoutId);
+    }
+    if (response.success) {
+      request.resolve(response.result);
+    } else {
+      const error = new Error(response.error?.message || "Unknown error");
+      if (response.error) {
+        Object.assign(error, response.error);
+      }
+      request.reject(error);
+    }
+  }
+  /**
+   * Send a response message
+   */
+  sendResponse(id, success, result, error) {
+    let transfer = [];
+    if (isTransferable(result)) {
+      transfer.push(result);
+    }
+    const response = {
+      id,
+      success,
+      result,
+      error,
+      timestamp: Date.now()
+    };
+    this.port.postMessage(response, transfer);
+  }
+  /**
+   * Check if message is a response
+   */
+  isResponse(data) {
+    return data && typeof data === "object" && "id" in data && "success" in data && !("type" in data);
+  }
+  /**
+   * Check if message is a request
+   */
+  isRequest(data) {
+    return data && typeof data === "object" && "id" in data && "type" in data;
+  }
+  /**
+   * Generate unique message ID
+   */
+  generateMessageId() {
+    return `${this.name}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+  /**
+   * Send a notification message without waiting for response
+   * Alias for post() method for compatibility
+   */
+  notify(type, payload, transfer) {
+    this.post(type, payload, transfer);
+  }
+  /**
+   * Register a message handler
+   * Alias for on() method for compatibility
+   */
+  registerHandler(type, handler) {
+    this.on(type, handler);
+  }
+  /**
+   * Send a ReadableStream to another worker
+   * Automatically handles transferable streams vs chunk-by-chunk fallback
+   */
+  async sendStream(stream, metadata) {
+    const streamId = metadata?.streamId || this.generateMessageId();
+    if (isTransferable(stream)) {
+      this.port.postMessage(
+        {
+          type: "stream_transfer",
+          ...metadata,
+          stream,
+          streamId
+        },
+        [stream]
+        // Transfer ownership
+      );
+    } else {
+      await this.streamChunks(stream, streamId, metadata);
+    }
+  }
+  /**
+   * Stream chunks from a ReadableStream (fallback when transfer is not supported)
+   */
+  async streamChunks(stream, streamId, metadata) {
+    const reader = stream.getReader();
+    this.post("stream_start", {
+      streamId,
+      ...metadata,
+      mode: "chunk_transfer"
+    });
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          this.post("stream_end", {
+            streamId,
+            ...metadata
+          });
+          break;
+        }
+        const transfer = [];
+        if (value instanceof ArrayBuffer) {
+          transfer.push(value);
+        } else if (value instanceof Uint8Array) {
+          transfer.push(value.buffer);
+        } else if (typeof AudioData !== "undefined" && value instanceof AudioData) {
+          transfer.push(value);
+        } else if (typeof VideoFrame !== "undefined" && value instanceof VideoFrame) {
+          transfer.push(value);
+        } else if (typeof value === "object" && value !== null) {
+          const extracted = extractTransferables(value);
+          transfer.push(...extracted);
+        }
+        this.post(
+          "stream_chunk",
+          {
+            streamId,
+            chunk: value,
+            ...metadata
+          },
+          transfer
+        );
+      }
+    } catch (error) {
+      this.post("stream_error", {
+        streamId,
+        error: error instanceof Error ? error.message : String(error),
+        ...metadata
+      });
+      throw error;
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Receive a stream from another worker
+   * Handles both transferable streams and chunk-by-chunk reconstruction
+   */
+  async receiveStream(onStream) {
+    const chunkedStreams = /* @__PURE__ */ new Map();
+    const prev = this.port.onmessage;
+    const handler = (event) => {
+      const raw = event.data;
+      const envelopeType = raw?.type;
+      const hasPayload = raw && typeof raw === "object" && "payload" in raw;
+      const payload = hasPayload ? raw.payload : raw;
+      if (envelopeType === "stream_transfer" && payload?.stream) {
+        onStream(payload.stream, payload);
+        return;
+      }
+      if (envelopeType === "stream_start" && payload?.streamId) {
+        const stream = new ReadableStream({
+          start(controller) {
+            chunkedStreams.set(payload.streamId, { controller, metadata: payload });
+          }
+        });
+        onStream(stream, payload);
+        return;
+      }
+      if (envelopeType === "stream_chunk" && payload?.streamId && chunkedStreams.has(payload.streamId)) {
+        const s = chunkedStreams.get(payload.streamId);
+        if (s) s.controller.enqueue(payload.chunk);
+        return;
+      }
+      if (envelopeType === "stream_end" && payload?.streamId && chunkedStreams.has(payload.streamId)) {
+        const s = chunkedStreams.get(payload.streamId);
+        if (s) {
+          s.controller.close();
+          chunkedStreams.delete(payload.streamId);
+        }
+        return;
+      }
+      if (envelopeType === "stream_error" && payload?.streamId && chunkedStreams.has(payload.streamId)) {
+        const s = chunkedStreams.get(payload.streamId);
+        if (s) {
+          s.controller.error(new Error(String(payload.error || "stream error")));
+          chunkedStreams.delete(payload.streamId);
+        }
+        return;
+      }
+      if (typeof prev === "function") prev.call(this.port, event);
+    };
+    this.port.onmessage = handler;
+  }
+}
+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"]();
+});
+//# sourceMappingURL=audio-compose.worker-nGVvHD5Q.js.map