@meframe/core 0.0.1 → 0.0.2

package/dist/assets/decode.worker-DpWHsc7R.js

@@ -0,0 +1,1291 @@
+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 BaseDecoder {
+  decoder;
+  config;
+  controller = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async initialize() {
+    if (this.decoder?.state === "configured") {
+      return;
+    }
+    const isSupported = await this.isConfigSupported(this.config);
+    if (!isSupported.supported) {
+      throw new Error(
+        `Codec not supported: ${this.config.codecString || this.config.codec}`
+      );
+    }
+    this.decoder = this.createDecoder({
+      output: this.handleOutput.bind(this),
+      error: this.handleError.bind(this)
+    });
+    await this.configureDecoder(this.config);
+  }
+  async reconfigure(config) {
+    this.config = { ...this.config, ...config };
+    if (!this.decoder) {
+      await this.initialize();
+      return;
+    }
+    if (this.decoder.state === "configured") {
+      await this.decoder.flush();
+    }
+    const isSupported = await this.isConfigSupported(this.config);
+    if (!isSupported.supported) {
+      throw new Error(
+        `New configuration not supported: ${this.config.codecString || this.config.codec}`
+      );
+    }
+    await this.configureDecoder(this.config);
+  }
+  async flush() {
+    if (!this.decoder) return;
+    await this.decoder.flush();
+  }
+  async reset() {
+    if (!this.decoder) return;
+    this.decoder.reset();
+    this.onReset();
+  }
+  async close() {
+    if (!this.decoder) return;
+    if (this.decoder.state === "configured") {
+      await this.decoder.flush();
+    }
+    this.decoder.close();
+    this.decoder = void 0;
+  }
+  get isReady() {
+    return this.decoder?.state === "configured";
+  }
+  get queueSize() {
+    return this.decoder?.decodeQueueSize ?? 0;
+  }
+  handleOutput(data) {
+    if (!this.controller) {
+      this.closeIfPossible(data);
+      return;
+    }
+    try {
+      this.controller.enqueue(data);
+    } catch (error) {
+      if (error instanceof TypeError && /Cannot enqueue a chunk into a readable stream that is closed/.test(error.message)) {
+        this.closeIfPossible(data);
+        return;
+      }
+      throw error;
+    }
+  }
+  handleError(error) {
+    console.error(`${this.getDecoderType()} decoder error:`, error);
+    this.controller?.error(error);
+  }
+  closeIfPossible(data) {
+    data?.close?.();
+    data?.frame?.close?.();
+  }
+  onReset() {
+  }
+  createStream() {
+    return new TransformStream(
+      {
+        start: async (controller) => {
+          this.controller = controller;
+          if (!this.isReady) {
+            await this.initialize();
+          }
+        },
+        transform: async (input) => {
+          if (!this.decoder || this.decoder.state !== "configured") {
+            throw new Error("Decoder not configured");
+          }
+          if (this.decoder.decodeQueueSize >= this.decodeQueueThreshold) {
+            await new Promise((resolve) => {
+              const check = () => {
+                if (!this.decoder || this.decoder.decodeQueueSize < this.decodeQueueThreshold - 1) {
+                  resolve();
+                } else {
+                  setTimeout(check, 10);
+                }
+              };
+              check();
+            });
+          }
+          this.decode(input);
+        },
+        flush: async () => {
+          await this.flush();
+        }
+      },
+      {
+        highWaterMark: this.highWaterMark,
+        size: () => 1
+      }
+    );
+  }
+}
+class VideoChunkDecoder extends BaseDecoder {
+  static DEFAULT_HIGH_WATER_MARK = 4;
+  static DEFAULT_DECODE_QUEUE_THRESHOLD = 16;
+  trackId;
+  highWaterMark;
+  decodeQueueThreshold;
+  // GOP tracking (serial is derived from keyframe timestamp for idempotency)
+  currentGopSerial = -1;
+  isCurrentFrameKeyframe = false;
+  // Buffering support for delayed configuration
+  bufferedChunks = [];
+  isProcessingBuffer = false;
+  constructor(trackId, config) {
+    super(config || {});
+    this.trackId = trackId;
+    this.highWaterMark = config?.backpressure?.highWaterMark ?? VideoChunkDecoder.DEFAULT_HIGH_WATER_MARK;
+    this.decodeQueueThreshold = config?.backpressure?.decodeQueueThreshold ?? VideoChunkDecoder.DEFAULT_DECODE_QUEUE_THRESHOLD;
+  }
+  // Computed properties
+  get isConfigured() {
+    return this.isReady;
+  }
+  get state() {
+    return this.decoder?.state || "unconfigured";
+  }
+  /**
+   * Update configuration - can be called before or after initialization
+   */
+  async updateConfig(config) {
+    if (!this.isReady && config.codec) {
+      await this.configure(config);
+      await this.processBufferedChunks();
+    }
+  }
+  // Override createStream to handle GOP tracking and buffering
+  // Always create new stream for each clip (ReadableStreams can only be consumed once)
+  createStream() {
+    return new TransformStream(
+      {
+        start: async (controller) => {
+          this.controller = controller;
+          if (this.config?.codec && this.config?.description && !this.isReady) {
+            await this.initialize();
+          }
+        },
+        transform: async (chunk) => {
+          if (!this.isReady) {
+            this.bufferedChunks.push(chunk);
+            return;
+          }
+          if (this.isProcessingBuffer) {
+            this.bufferedChunks.push(chunk);
+            return;
+          }
+          await this.processChunk(chunk);
+        },
+        flush: async () => {
+          if (this.isReady) {
+            await this.flush();
+          }
+        }
+      },
+      {
+        highWaterMark: this.highWaterMark,
+        size: () => 1
+      }
+    );
+  }
+  /**
+   * Process a single chunk (extracted from transform for reuse)
+   */
+  async processChunk(chunk) {
+    if (!this.decoder) {
+      throw new Error("Decoder not initialized");
+    }
+    if (this.decoder.state !== "configured") {
+      console.error("[VideoChunkDecoder] Decoder in unexpected state:", this.decoder.state);
+      throw new Error(`Decoder not configured, state: ${this.decoder.state}`);
+    }
+    if (chunk.type === "key") {
+      this.handleKeyFrame(chunk.timestamp);
+    }
+    if (this.decoder.decodeQueueSize >= this.decodeQueueThreshold) {
+      await new Promise((resolve) => {
+        const check = () => {
+          if (!this.decoder || this.decoder.decodeQueueSize < this.decodeQueueThreshold - 1) {
+            resolve();
+          } else {
+            setTimeout(check, 20);
+          }
+        };
+        check();
+      });
+    }
+    try {
+      this.decode(chunk);
+    } catch (error) {
+      console.error(`[VideoChunkDecoder] decode error:`, error);
+      throw error;
+    }
+  }
+  // Override handleOutput to attach GOP metadata
+  handleOutput(frame) {
+    const wrappedFrame = {
+      frame,
+      gopSerial: this.currentGopSerial,
+      isKeyframe: this.isCurrentFrameKeyframe,
+      timestamp: frame.timestamp
+    };
+    this.isCurrentFrameKeyframe = false;
+    super.handleOutput(wrappedFrame);
+  }
+  // Implement abstract methods
+  async isConfigSupported(config) {
+    const result = await VideoDecoder.isConfigSupported({
+      codec: config.codec,
+      codedWidth: config.width,
+      codedHeight: config.height
+    });
+    return { supported: result.supported ?? false };
+  }
+  createDecoder(init) {
+    return new VideoDecoder(init);
+  }
+  getDecoderType() {
+    return "Video";
+  }
+  async configureDecoder(config) {
+    if (!this.decoder) return;
+    const decoderConfig = {
+      codec: config.codec,
+      codedWidth: config.width,
+      codedHeight: config.height,
+      hardwareAcceleration: config.hardwareAcceleration || "prefer-hardware",
+      optimizeForLatency: false,
+      ...config.description && { description: config.description },
+      ...config.displayAspectWidth && { displayAspectWidth: config.displayAspectWidth },
+      ...config.displayAspectHeight && { displayAspectHeight: config.displayAspectHeight }
+    };
+    this.decoder.configure(decoderConfig);
+  }
+  decode(chunk) {
+    this.decoder?.decode(chunk);
+  }
+  // Override reset to clear GOP data
+  onReset() {
+    this.currentGopSerial = -1;
+    this.isCurrentFrameKeyframe = false;
+  }
+  // GOP management methods
+  handleKeyFrame(timestamp) {
+    this.currentGopSerial = timestamp;
+    this.isCurrentFrameKeyframe = true;
+  }
+  /**
+   * Configure the decoder with codec info (can be called after creation)
+   */
+  async configure(config) {
+    if (this.isReady) {
+      await this.reconfigure(config);
+      return;
+    }
+    this.config = config;
+    await this.initialize();
+  }
+  /**
+   * Process any buffered chunks after configuration
+   */
+  async processBufferedChunks() {
+    if (!this.isReady || this.bufferedChunks.length === 0) {
+      return;
+    }
+    this.isProcessingBuffer = true;
+    const chunks = [...this.bufferedChunks];
+    this.bufferedChunks = [];
+    for (const chunk of chunks) {
+      try {
+        await this.processChunk(chunk);
+      } catch (error) {
+        console.error("[VideoChunkDecoder] Error processing buffered chunk:", error);
+      }
+    }
+    this.isProcessingBuffer = false;
+    if (this.bufferedChunks.length > 0) {
+      await this.processBufferedChunks();
+    }
+  }
+  // Override close to clean up GOP data
+  async close() {
+    this.bufferedChunks = [];
+    this.onReset();
+    await super.close();
+  }
+}
+class AudioChunkDecoder extends BaseDecoder {
+  // Default values
+  static DEFAULT_HIGH_WATER_MARK = 20;
+  static DEFAULT_DECODE_QUEUE_THRESHOLD = 16;
+  // Exposed properties
+  trackId;
+  // Backpressure configuration
+  highWaterMark;
+  decodeQueueThreshold;
+  constructor(trackId, config) {
+    super(config);
+    this.trackId = trackId;
+    this.highWaterMark = config?.backpressure?.highWaterMark ?? AudioChunkDecoder.DEFAULT_HIGH_WATER_MARK;
+    this.decodeQueueThreshold = AudioChunkDecoder.DEFAULT_DECODE_QUEUE_THRESHOLD;
+  }
+  // Computed properties
+  get isConfigured() {
+    return this.isReady;
+  }
+  get state() {
+    return this.decoder?.state || "unconfigured";
+  }
+  /**
+   * Update configuration - can be called before or after initialization
+   */
+  async updateConfig(config) {
+    if (!this.isReady && config.codec) {
+      await this.configure(config);
+      await this.processBufferedChunks();
+      return;
+    }
+  }
+  // Implement abstract methods
+  async isConfigSupported(config) {
+    const result = await AudioDecoder.isConfigSupported({
+      codec: config.codec,
+      sampleRate: config.sampleRate,
+      numberOfChannels: config.numberOfChannels
+    });
+    return { supported: result.supported ?? false };
+  }
+  createDecoder(init) {
+    return new AudioDecoder(init);
+  }
+  getDecoderType() {
+    return "Audio";
+  }
+  async configureDecoder(config) {
+    if (!this.decoder) return;
+    await this.decoder.configure({
+      codec: config.codec,
+      sampleRate: config.sampleRate,
+      numberOfChannels: config.numberOfChannels,
+      ...config.description && { description: config.description }
+    });
+  }
+  decode(chunk) {
+    this.decoder?.decode(chunk);
+  }
+  /**
+   * Configure the decoder with codec info (can be called after creation)
+   */
+  async configure(config) {
+    if (this.isReady) {
+      await this.reconfigure(config);
+      return;
+    }
+    this.config = config;
+    await this.initialize();
+  }
+  /**
+   * Process any buffered chunks after configuration
+   * Note: Audio doesn't buffer in current implementation, but keeping for interface consistency
+   */
+  async processBufferedChunks() {
+  }
+}
+const normalizeDescription = (desc) => {
+  if (!desc) return void 0;
+  if (desc instanceof ArrayBuffer) return desc;
+  const view = desc;
+  return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+};
+class DecodeWorker {
+  channel;
+  // Map of clipId -> decoder instance
+  videoDecoders = /* @__PURE__ */ new Map();
+  audioDecoders = /* @__PURE__ */ new Map();
+  registeredAudioTracks = /* @__PURE__ */ new Set();
+  deliveredAudioTracks = /* @__PURE__ */ new Set();
+  audioTrackMetadata = /* @__PURE__ */ new Map();
+  /** Maximum number of active decoder pairs allowed at the same time */
+  static MAX_ACTIVE_DECODERS = 8;
+  // Cached default configs merged from orchestrator
+  defaultVideoConfig = {};
+  defaultAudioConfig = {};
+  // Connections to other workers
+  composePorts = /* @__PURE__ */ new Map();
+  audioDownstreamPort = null;
+  demuxPorts = /* @__PURE__ */ new Map();
+  // Connections from demux workers
+  constructor() {
+    this.channel = new WorkerChannel(self, {
+      name: "DecodeWorker",
+      timeout: 3e4
+    });
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.channel.registerHandler("configure", this.handleConfigure.bind(this));
+    this.channel.registerHandler("connect", this.handleConnect.bind(this));
+    this.channel.registerHandler("flush", this.handleFlush.bind(this));
+    this.channel.registerHandler("reset", this.handleReset.bind(this));
+    this.channel.registerHandler("get_stats", this.handleGetStats.bind(this));
+    this.channel.registerHandler(WorkerMessageType.Dispose, this.handleDispose.bind(this));
+  }
+  /**
+   * Connect handler used by stream pipeline
+   */
+  async handleConnect(payload) {
+    const { port, direction, clipId } = payload;
+    if (direction === "upstream") {
+      this.demuxPorts.set(clipId || "default", port);
+      const channel = new WorkerChannel(port, {
+        name: "Demux-Decode",
+        timeout: 3e4
+      });
+      channel.receiveStream((stream, metadata) => {
+        this.handleReceiveStream(stream, {
+          ...metadata,
+          clipStartUs: payload.clipStartUs,
+          clipDurationUs: payload.clipDurationUs
+        });
+      });
+      channel.registerHandler("configure", this.handleConfigure.bind(this));
+    }
+    if (direction === "downstream") {
+      if (payload.streamType === "audio") {
+        this.audioDownstreamPort?.close();
+        this.audioDownstreamPort = port;
+      } else {
+        this.composePorts.set(clipId || "default", port);
+      }
+    }
+    return { success: true };
+  }
+  /**
+   * Handle configuration message from orchestrator
+   * @param payload.initial - If true, initialize worker and recreate decoder instances; otherwise just update config
+   */
+  async handleConfigure(payload) {
+    const { clipId, streamType, codec, width, height, sampleRate, numberOfChannels, description } = payload;
+    if (clipId && streamType) {
+      try {
+        if (streamType === "video") {
+          const decoder = this.videoDecoders.get(clipId);
+          if (decoder) {
+            await decoder.updateConfig({
+              codec,
+              width,
+              height,
+              description: normalizeDescription(description)
+            });
+          }
+        } else if (streamType === "audio") {
+          const decoder = this.audioDecoders.get(clipId);
+          if (decoder) {
+            await decoder.updateConfig({
+              codec,
+              sampleRate,
+              numberOfChannels,
+              description: normalizeDescription(description)
+            });
+          }
+        }
+      } catch (error) {
+        console.error("[DecodeWorker] Failed to configure decoder:", error);
+        throw {
+          code: "CODEC_CONFIG_ERROR",
+          message: error.message
+        };
+      }
+      return { success: true };
+    }
+    const { config } = payload;
+    if (!config) {
+      return { success: true };
+    }
+    this.channel.state = WorkerState.Ready;
+    if (config.video) {
+      Object.assign(this.defaultVideoConfig, config.video);
+    }
+    if (config.audio) {
+      Object.assign(this.defaultAudioConfig, config.audio);
+    }
+    if (config.video) {
+      for (const dec of this.videoDecoders.values()) {
+        await dec.updateConfig(config.video);
+      }
+    }
+    if (config.audio) {
+      for (const dec of this.audioDecoders.values()) {
+        await dec.updateConfig(config.audio);
+      }
+    }
+    return { success: true };
+  }
+  async handleReceiveStream(stream, metadata) {
+    const clipId = metadata?.clipId || "default";
+    const streamType = metadata?.streamType;
+    if (streamType === "video") {
+      const decoder = await this.getOrCreateDecoder("video", clipId, metadata);
+      const transform = decoder.createStream();
+      const composePort = this.composePorts.get(clipId);
+      if (composePort) {
+        const channel = new WorkerChannel(composePort, {
+          name: "Decode-Compose",
+          timeout: 3e4
+        });
+        channel.sendStream(transform.readable, {
+          streamType: "video",
+          clipId
+        });
+        stream.pipeTo(transform.writable).catch(
+          (error) => console.error("[DecodeWorker] Video stream pipe error:", clipId, error)
+        );
+      }
+    } else if (streamType === "audio") {
+      const decoder = await this.getOrCreateDecoder("audio", clipId, metadata);
+      const transform = decoder.createStream();
+      stream.pipeTo(transform.writable).catch((error) => {
+        console.error("[DecodeWorker] Audio stream pipe error:", error);
+      });
+      const trackId = metadata?.trackId ?? clipId;
+      await this.registerAudioTrack(trackId, clipId, metadata);
+      this.channel.sendStream(transform.readable, {
+        streamType: "audio",
+        clipId,
+        trackId,
+        clipStartUs: metadata?.clipStartUs ?? 0,
+        clipDurationUs: metadata?.clipDurationUs ?? 0
+      });
+      this.deliveredAudioTracks.add(trackId);
+    }
+  }
+  /**
+   * Flush decoders
+   */
+  async handleFlush(payload) {
+    try {
+      if (!payload?.type || payload.type === "video") {
+        for (const dec of this.videoDecoders.values()) {
+          await dec.flush();
+        }
+      }
+      if (!payload?.type || payload.type === "audio") {
+        for (const dec of this.audioDecoders.values()) {
+          await dec.flush();
+        }
+      }
+      return { success: true };
+    } catch (error) {
+      throw {
+        code: "FLUSH_ERROR",
+        message: error.message
+      };
+    }
+  }
+  /**
+   * Reset decoders
+   */
+  async handleReset(payload) {
+    try {
+      if (!payload?.type || payload.type === "video") {
+        for (const dec of this.videoDecoders.values()) {
+          await dec.reset();
+        }
+      }
+      if (!payload?.type || payload.type === "audio") {
+        for (const dec of this.audioDecoders.values()) {
+          await dec.reset();
+        }
+      }
+      this.channel.notify("reset_complete", {
+        type: payload?.type || "all"
+      });
+      return { success: true };
+    } catch (error) {
+      throw {
+        code: "RESET_ERROR",
+        message: error.message
+      };
+    }
+  }
+  /**
+   * Get decoder statistics
+   */
+  async handleGetStats() {
+    const stats = {};
+    if (this.videoDecoders.size) {
+      stats.video = Array.from(this.videoDecoders.entries()).map(([clipId, dec]) => ({
+        clipId,
+        configured: dec.isConfigured,
+        queueSize: dec.queueSize,
+        state: dec.state
+      }));
+    }
+    if (this.audioDecoders.size) {
+      stats.audio = Array.from(this.audioDecoders.entries()).map(([clipId, dec]) => ({
+        clipId,
+        configured: dec.isConfigured,
+        queueSize: dec.queueSize,
+        state: dec.state
+      }));
+    }
+    return stats;
+  }
+  /**
+   * Dispose worker and cleanup resources
+   */
+  async handleDispose() {
+    for (const dec of this.videoDecoders.values()) {
+      await dec.close();
+    }
+    for (const dec of this.audioDecoders.values()) {
+      await dec.close();
+    }
+    this.videoDecoders.clear();
+    this.audioDecoders.clear();
+    for (const port of this.composePorts.values()) {
+      port.close();
+    }
+    this.composePorts.clear();
+    if (this.audioDownstreamPort) {
+      this.audioDownstreamPort.close();
+      this.audioDownstreamPort = null;
+    }
+    this.registeredAudioTracks.clear();
+    this.deliveredAudioTracks.clear();
+    this.audioTrackMetadata.clear();
+    for (const port of this.demuxPorts.values()) {
+      port.close();
+    }
+    this.demuxPorts.clear();
+    this.channel.state = WorkerState.Disposed;
+    return { success: true };
+  }
+  /**
+   * Get existing decoder for clip or create a new one (with LRU eviction)
+   */
+  async getOrCreateDecoder(kind, clipId, metadata) {
+    if (kind === "video") {
+      let decoder = this.videoDecoders.get(clipId);
+      if (!decoder) {
+        decoder = new VideoChunkDecoder(
+          clipId,
+          metadata ? {
+            ...this.defaultVideoConfig,
+            codec: metadata.codec,
+            width: metadata.width,
+            height: metadata.height,
+            description: normalizeDescription(metadata.description)
+          } : void 0
+        );
+        this.evictIfNeeded("video");
+        this.videoDecoders.set(clipId, decoder);
+      }
+      this.videoDecoders.delete(clipId);
+      this.videoDecoders.set(clipId, decoder);
+      return decoder;
+    } else {
+      let decoder = this.audioDecoders.get(clipId);
+      if (!decoder) {
+        decoder = new AudioChunkDecoder(
+          clipId,
+          metadata ? {
+            ...this.defaultAudioConfig,
+            codec: metadata.codec,
+            sampleRate: metadata.sampleRate,
+            numberOfChannels: metadata.numberOfChannels,
+            description: normalizeDescription(metadata.description)
+          } : void 0
+        );
+        this.evictIfNeeded("audio");
+        this.audioDecoders.set(clipId, decoder);
+      }
+      this.audioDecoders.delete(clipId);
+      this.audioDecoders.set(clipId, decoder);
+      return decoder;
+    }
+  }
+  /**
+   * Evict least-recently-used decoder if we exceed MAX_ACTIVE_DECODERS.
+   */
+  evictIfNeeded(kind) {
+    const map = kind === "video" ? this.videoDecoders : this.audioDecoders;
+    if (map.size < DecodeWorker.MAX_ACTIVE_DECODERS) return;
+    const [lrucId, lruDecoder] = map.entries().next().value;
+    lruDecoder.close().catch(() => void 0);
+    map.delete(lrucId);
+  }
+  async registerAudioTrack(trackId, clipId, metadata) {
+    const record = {
+      clipId,
+      config: this.extractTrackConfig(metadata?.runtimeConfig),
+      sampleRate: metadata?.sampleRate,
+      numberOfChannels: metadata?.numberOfChannels,
+      type: metadata?.trackType ?? "other"
+    };
+    this.audioTrackMetadata.set(trackId, record);
+    if (this.registeredAudioTracks.has(trackId)) {
+      await this.sendAudioTrackUpdate(trackId, record);
+      return;
+    }
+    this.registeredAudioTracks.add(trackId);
+    await this.sendAudioTrackAdd(trackId, record);
+  }
+  // private unregisterAudioTrack(trackId: string): void {
+  //   if (!this.registeredAudioTracks.delete(trackId)) {
+  //     return;
+  //   }
+  //   const record = this.audioTrackMetadata.get(trackId);
+  //   this.audioTrackMetadata.delete(trackId);
+  //   if (!record) {
+  //     return;
+  //   }
+  //   const channel = this.ensureComposeChannel();
+  //   channel
+  //     ?.send(WorkerMessageType.AudioTrackRemove, {
+  //       clipId: record.clipId,
+  //       trackId,
+  //     })
+  //     .catch((error) => {
+  //       console.warn('[DecodeWorker] Failed to notify track removal', error);
+  //     });
+  // }
+  extractTrackConfig(config) {
+    return {
+      startTimeUs: config?.startTimeUs ?? 0,
+      durationUs: config?.durationUs,
+      volume: config?.volume ?? 1,
+      fadeIn: config?.fadeIn,
+      fadeOut: config?.fadeOut,
+      effects: config?.effects ?? [],
+      duckingTag: config?.duckingTag
+    };
+  }
+  async sendAudioTrackAdd(trackId, record) {
+    const channel = this.ensureComposeChannel();
+    if (!channel) {
+      return;
+    }
+    await channel.send(WorkerMessageType.AudioTrackAdd, {
+      clipId: record.clipId,
+      trackId,
+      config: record.config,
+      sampleRate: record.sampleRate,
+      numberOfChannels: record.numberOfChannels,
+      type: record.type
+    });
+  }
+  async sendAudioTrackUpdate(trackId, record) {
+    const channel = this.ensureComposeChannel();
+    if (!channel) {
+      return;
+    }
+    if (!channel) {
+      return;
+    }
+    await channel.send(WorkerMessageType.AudioTrackUpdate, {
+      clipId: record.clipId,
+      trackId,
+      config: record.config,
+      type: record.type
+    });
+  }
+  ensureComposeChannel() {
+    if (!this.audioDownstreamPort) {
+      return null;
+    }
+    return new WorkerChannel(this.audioDownstreamPort, {
+      name: "Decode-AudioCompose",
+      timeout: 3e4
+    });
+  }
+}
+const worker = new DecodeWorker();
+self.addEventListener("beforeunload", () => {
+  worker["handleDispose"]();
+});
+//# sourceMappingURL=decode.worker-DpWHsc7R.js.map