@meframe/core 0.0.2 → 0.0.4

package/dist/{assets/video-compose.worker-DPzsC21d.js → workers/stages/compose/video-compose.worker.js}

@@ -1,483 +1,4 @@
-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;
-  }
-}
+import { W as WorkerChannel, a as WorkerMessageType, b as WorkerState } from "../../WorkerChannel.js";
 const MICROSECONDS_PER_SECOND = 1e6;
 const DEFAULT_FPS = 30;
 function normalizeFps(value) {
@@ -1311,8 +832,11 @@ class VideoComposer {
     this.filterProcessor.clearCache();
   }
 }
-function resolveActiveLayers(layers, timestamp, _frame) {
+function resolveActiveLayers(layers, timestamp) {
   return layers.filter((layer) => {
+    if (layer.layerId.includes("base-video")) {
+      return true;
+    }
     if (layer.status !== "ready") {
       return false;
     }
@@ -1371,11 +895,12 @@ class VideoComposeWorker {
   channel;
   composer = null;
   composeStream = null;
-  downstreamPorts = /* @__PURE__ */ new Map();
-  upstreamPorts = /* @__PURE__ */ new Map();
-  instructionRegistry = /* @__PURE__ */ new Map();
-  pendingReplay = /* @__PURE__ */ new Map();
-  streamState = /* @__PURE__ */ new Map();
+  clipId = null;
+  downstreamPort = null;
+  upstreamPort = null;
+  instructions = null;
+  streamState = null;
+  imageBitmap = null;
   constructor() {
     this.channel = new WorkerChannel(self, {
       name: "VideoComposeWorker",
@@ -1389,7 +914,7 @@ class VideoComposeWorker {
     this.channel.registerHandler("flush", this.handleFlush.bind(this));
     this.channel.registerHandler("get_stats", this.handleGetStats.bind(this));
     this.channel.registerHandler("install_instructions", this.handleInstallInstructions.bind(this));
-    this.channel.registerHandler("sync_clip", this.handleSyncClip.bind(this));
+    this.channel.registerHandler("receive_image", this.handleReceiveImage.bind(this));
     this.channel.registerHandler("dispose_clip", this.handleDisposeClip.bind(this));
     this.channel.registerHandler(WorkerMessageType.Dispose, this.handleDispose.bind(this));
   }
@@ -1397,9 +922,12 @@ class VideoComposeWorker {
    * Unified connect handler used by stream pipeline
    */
   async handleConnect(payload) {
-    const { port, direction, clipId = "default" } = payload;
+    const { port, direction, clipId } = payload;
+    if (clipId && !this.clipId) {
+      this.clipId = clipId;
+    }
     if (direction === "upstream") {
-      this.upstreamPorts.set(clipId, port);
+      this.upstreamPort = port;
       const channel = new WorkerChannel(port, {
         name: "VideoCompose-Decode",
         timeout: 3e4
@@ -1407,7 +935,7 @@ class VideoComposeWorker {
       channel.receiveStream(this.handleReceiveStream.bind(this));
     }
     if (direction === "downstream") {
-      this.downstreamPorts.set(clipId, port);
+      this.downstreamPort = port;
     }
     return { success: true };
   }
@@ -1446,14 +974,12 @@ class VideoComposeWorker {
     };
   }
   async handleReceiveStream(stream, metadata) {
-    const { clipId = "default" } = metadata || {};
     if (!this.composer) {
       console.error("[VideoComposeWorker] Composer not configured");
       return;
     }
-    const instruction = this.instructionRegistry.get(clipId);
-    if (!instruction) {
-      console.warn("[VideoComposeWorker] No instructions for clip", clipId);
+    if (!this.instructions) {
+      console.warn("[VideoComposeWorker] No instructions installed");
       return;
     }
     const filteredStream = stream.pipeThrough(
@@ -1463,12 +989,7 @@ class VideoComposeWorker {
             const frame = wrappedFrame.frame || wrappedFrame;
             const gopSerial = wrappedFrame.gopSerial;
             const isKeyframe = wrappedFrame.isKeyframe;
-            const timestamp = frame.timestamp ?? 0;
-            if (this.shouldSkipFrame(clipId, timestamp)) {
-              frame.close();
-              return;
-            }
-            const request = this.buildComposeRequest(clipId, instruction, frame, timestamp);
+            const request = this.buildComposeRequest(this.instructions, frame);
             if (!request) {
               frame.close();
               return;
@@ -1487,7 +1008,7 @@ class VideoComposeWorker {
     const { composeStream, cacheStream } = this.composer.createStreams();
     this.channel.sendStream(cacheStream, metadata);
     filteredStream.pipeTo(composeStream).catch((error) => {
-      console.error("[VideoComposeWorker] compose stream error", clipId, error);
+      console.error("[VideoComposeWorker] compose stream error", this.clipId, error);
     });
   }
   // private handleGetStream(): ReadableStream<VideoFrame> | undefined {
@@ -1526,61 +1047,96 @@ class VideoComposeWorker {
       this.composer = null;
     }
     this.composeStream = null;
-    this.downstreamPorts.get("default")?.close();
-    this.upstreamPorts.get("default")?.close();
-    this.downstreamPorts.clear();
-    this.upstreamPorts.clear();
+    this.downstreamPort?.close();
+    this.upstreamPort?.close();
+    this.downstreamPort = null;
+    this.upstreamPort = null;
+    this.imageBitmap?.close();
+    this.imageBitmap = null;
+    this.instructions = null;
+    this.streamState = null;
     this.channel.state = WorkerState.Disposed;
     return { success: true };
   }
-  async handleInstallInstructions(data) {
-    const { clipId, revision } = data;
-    const current = this.instructionRegistry.get(clipId);
-    if (current && current.revision > revision) {
+  async handleInstallInstructions(payload) {
+    const { clipId, revision } = payload;
+    if (!this.clipId) {
+      this.clipId = clipId;
+    }
+    if (this.instructions && this.instructions.revision > revision) {
       return { success: false };
     }
-    this.instructionRegistry.set(clipId, data);
+    this.instructions = payload;
     return { success: true };
   }
-  async handleSyncClip(payload) {
-    const { clipId, revision, range } = payload;
-    const current = this.instructionRegistry.get(clipId);
-    if (!current || current.revision > revision) {
-      return { success: false };
+  /**
+   * Receive image data from ResourceLoader
+   * Note: ImageBitmap is required because VideoFrame constructor in Worker context
+   * only accepts ImageBitmap/OffscreenCanvas, not HTMLImageElement or Blob
+   */
+  async handleReceiveImage(payload) {
+    const { clipId, imageBitmap } = payload;
+    if (!this.clipId) {
+      this.clipId = clipId;
+    }
+    if (this.imageBitmap) {
+      this.imageBitmap.close();
+    }
+    this.imageBitmap = imageBitmap;
+    if (this.instructions) {
+      await this.startImageFrameStream();
     }
-    this.pendingReplay.set(clipId, { ...range, revision });
-    this.channel.notify("sync_ack", { clipId, revision });
     return { success: true };
   }
-  async handleDisposeClip(payload) {
-    const { clipId } = payload;
-    this.instructionRegistry.delete(clipId);
-    this.pendingReplay.delete(clipId);
-    this.downstreamPorts.get(clipId)?.close();
-    this.upstreamPorts.get(clipId)?.close();
-    this.downstreamPorts.delete(clipId);
-    this.upstreamPorts.delete(clipId);
+  async handleDisposeClip() {
+    this.instructions = null;
+    this.streamState = null;
+    this.downstreamPort?.close();
+    this.upstreamPort?.close();
+    this.downstreamPort = null;
+    this.upstreamPort = null;
+    this.imageBitmap?.close();
+    this.imageBitmap = null;
     return { success: true };
   }
-  /**
-   * Check if frame should be skipped (outside dirty range)
-   * Returns true if frame is NOT in the dirty range and should use cached version
-   */
-  shouldSkipFrame(clipId, timestamp) {
-    const dirtyRange = this.pendingReplay.get(clipId);
-    if (!dirtyRange) {
-      return false;
-    }
-    if (timestamp >= dirtyRange.startUs && timestamp <= dirtyRange.endUs) {
-      return false;
+  async startImageFrameStream() {
+    if (!this.instructions || !this.composer) {
+      return;
     }
-    if (timestamp > dirtyRange.endUs) {
-      this.pendingReplay.delete(clipId);
+    const timeline = this.instructions.baseConfig.timeline;
+    if (!timeline) {
+      return;
     }
-    return true;
+    const { composeStream, cacheStream } = this.composer.createStreams();
+    const { clipDurationUs, compositionFps } = timeline;
+    let currentTimeUs = 0;
+    const readableStream = new ReadableStream({
+      pull: (controller) => {
+        if (currentTimeUs >= clipDurationUs) {
+          controller.close();
+          return;
+        }
+        const videoFrame = new VideoFrame(this.imageBitmap, {
+          timestamp: currentTimeUs,
+          duration: frameDurationFromFps(compositionFps)
+        });
+        const request = this.buildComposeRequest(this.instructions, videoFrame);
+        if (request) {
+          controller.enqueue(request);
+        }
+        currentTimeUs += frameDurationFromFps(compositionFps);
+      }
+    });
+    this.channel.sendStream(cacheStream, {
+      streamType: "video",
+      clipId: this.clipId
+    });
+    readableStream.pipeTo(composeStream).catch((error) => {
+      console.error("[VideoComposeWorker] image frame stream error", this.clipId, error);
+    });
   }
-  buildComposeRequest(clipId, instruction, frame, _timestamp) {
-    const normalizedTime = this.computeTimelineTimestamp(clipId, frame, instruction.baseConfig);
+  buildComposeRequest(instruction, frame) {
+    const normalizedTime = this.computeTimelineTimestamp(frame, instruction.baseConfig);
     const clipStartUs = instruction.baseConfig.timeline?.clipStartUs ?? 0;
     const clipDurationUs = instruction.baseConfig.timeline?.clipDurationUs ?? Infinity;
     const clipEndUs = clipStartUs + clipDurationUs;
@@ -1621,43 +1177,40 @@ class VideoComposeWorker {
       direction: entry.params.payload?.direction
     };
   }
-  computeTimelineTimestamp(clipId, frame, config) {
-    const key = clipId;
-    let state = this.streamState.get(key);
-    if (!state) {
-      state = {
+  computeTimelineTimestamp(frame, config) {
+    if (!this.streamState) {
+      this.streamState = {
         baseTimestamp: null,
         lastSourceTimestamp: null,
         nextFrameIndex: 0
       };
-      this.streamState.set(key, state);
     }
     const timeline = config.timeline;
     if (!timeline) {
       const ts = frame.timestamp ?? 0;
-      state.lastSourceTimestamp = frame.timestamp ?? null;
+      this.streamState.lastSourceTimestamp = frame.timestamp ?? null;
       return ts;
     }
     const { clipStartUs, compositionFps } = timeline;
     const sourceTimestamp = frame.timestamp ?? null;
-    if (sourceTimestamp !== null && state.lastSourceTimestamp !== null && sourceTimestamp < state.lastSourceTimestamp) {
-      state.baseTimestamp = null;
-      state.nextFrameIndex = 0;
-    }
-    if (state.baseTimestamp === null) {
-      state.baseTimestamp = sourceTimestamp ?? 0;
-      state.nextFrameIndex = 0;
-      if (state.baseTimestamp > 1e3) {
+    if (sourceTimestamp !== null && this.streamState.lastSourceTimestamp !== null && sourceTimestamp < this.streamState.lastSourceTimestamp) {
+      this.streamState.baseTimestamp = null;
+      this.streamState.nextFrameIndex = 0;
+    }
+    if (this.streamState.baseTimestamp === null) {
+      this.streamState.baseTimestamp = sourceTimestamp ?? 0;
+      this.streamState.nextFrameIndex = 0;
+      if (this.streamState.baseTimestamp > 1e3) {
         console.warn(
-          `[VideoComposeWorker] First frame timestamp is ${state.baseTimestamp}us, expected ~0. Check MP4Demuxer normalization.`
+          `[VideoComposeWorker] First frame timestamp is ${this.streamState.baseTimestamp}us, expected ~0. Check MP4Demuxer normalization.`
         );
       }
     }
     const frameDuration = frameDurationFromFps(compositionFps);
-    let frameIndex = state.nextFrameIndex;
+    let frameIndex = this.streamState.nextFrameIndex;
     if (sourceTimestamp !== null) {
       const approxIndex = frameIndexFromTimestamp(
-        state.baseTimestamp,
+        this.streamState.baseTimestamp,
         sourceTimestamp,
         compositionFps,
         "nearest"
@@ -1671,8 +1224,8 @@ class VideoComposeWorker {
       compositionFps,
       "nearest"
     );
-    state.nextFrameIndex = frameIndex + 1;
-    state.lastSourceTimestamp = sourceTimestamp;
+    this.streamState.nextFrameIndex = frameIndex + 1;
+    this.streamState.lastSourceTimestamp = sourceTimestamp;
     return timelineTime;
   }
 }
@@ -1680,4 +1233,9 @@ const worker = new VideoComposeWorker();
 self.addEventListener("beforeunload", () => {
   worker["handleDispose"]();
 });
-//# sourceMappingURL=video-compose.worker-DPzsC21d.js.map
+const videoCompose_worker = null;
+export {
+  VideoComposeWorker,
+  videoCompose_worker as default
+};
+//# sourceMappingURL=video-compose.worker.js.map