@meframe/core 0.3.6 → 0.3.8

package/dist/workers/stages/{compose/video-compose.worker.KMZjuJuY.js → export/export.worker.SahP9aVK.js}

@@ -1,4 +1,513 @@
-import { W as WorkerChannel, a as WorkerMessageType, b as WorkerState } from "../../WorkerChannel.DQK8rAab.js";
+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["AddChunk"] = "add_chunk";
+  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;
+}
+function encodedVideoChunkToTransferable(chunk) {
+  const data = new ArrayBuffer(chunk.byteLength);
+  chunk.copyTo(new Uint8Array(data));
+  return {
+    data,
+    type: chunk.type,
+    timestamp: chunk.timestamp,
+    duration: chunk.duration
+  };
+}
+function encodedAudioChunkToTransferable(chunk) {
+  const data = new ArrayBuffer(chunk.byteLength);
+  chunk.copyTo(new Uint8Array(data));
+  return {
+    data,
+    type: chunk.type,
+    timestamp: chunk.timestamp,
+    duration: chunk.duration
+  };
+}
+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();
+    const forceChunkTransfer = metadata?.forceChunkTransfer === true || metadata?.streamType === "video" || metadata?.streamType === "audio";
+    if (!forceChunkTransfer && 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 });
+          break;
+        }
+        const transfer = [];
+        let chunkValue = value;
+        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 EncodedVideoChunk !== "undefined" && value instanceof EncodedVideoChunk) {
+          const serialized = encodedVideoChunkToTransferable(value);
+          transfer.push(serialized.data);
+          chunkValue = serialized;
+        } else if (typeof EncodedAudioChunk !== "undefined" && value instanceof EncodedAudioChunk) {
+          const serialized = encodedAudioChunkToTransferable(value);
+          transfer.push(serialized.data);
+          chunkValue = serialized;
+        } else if (typeof value === "object" && value !== null) {
+          const extracted = extractTransferables(value);
+          transfer.push(...extracted);
+        }
+        this.post("stream_chunk", { streamId, chunk: chunkValue }, transfer);
+        for (const t of transfer) {
+          if (typeof VideoFrame !== "undefined" && t instanceof VideoFrame) {
+            try {
+              t.close();
+            } catch {
+            }
+            continue;
+          }
+          if (typeof AudioData !== "undefined" && t instanceof AudioData) {
+            try {
+              t.close();
+            } catch {
+            }
+          }
+        }
+      }
+    } catch (error) {
+      this.post("stream_error", {
+        streamId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      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;
+  }
+}
 function measureTextWidth(ctx, text, fontSize, fontFamily, fontWeight = 400) {
   ctx.save();
   ctx.font = `${fontWeight} ${fontSize}px ${fontFamily}`;
@@ -1515,6 +2024,7 @@ class VideoComposer {
   // Cached frame duration
   fontsLoadingPromise = null;
   loadedFonts = /* @__PURE__ */ new Set();
+  static FONT_LOAD_TIMEOUT_MS = 1e4;
   constructor(config) {
     this.config = this.applyDefaults(config);
     this.frameDurationUs = Math.round(1e6 / this.config.fps);
@@ -1602,7 +2112,10 @@ class VideoComposer {
   }
   async composeFrame(request) {
     if (this.fontsLoadingPromise) {
-      await this.fontsLoadingPromise;
+      try {
+        await this.withTimeout(this.fontsLoadingPromise, VideoComposer.FONT_LOAD_TIMEOUT_MS);
+      } catch {
+      }
       this.fontsLoadingPromise = null;
     }
     if (request.layers.length > this.config.maxLayers) {
@@ -1702,7 +2215,10 @@ class VideoComposer {
       }
       try {
         const fontFace = new FontFace(font.family, `url(${font.url})`);
-        const loadedFont = await fontFace.load();
+        const loadedFont = await this.withTimeout(
+          fontFace.load(),
+          VideoComposer.FONT_LOAD_TIMEOUT_MS
+        );
         if ("fonts" in self) {
           self.fonts.add(loadedFont);
         }
@@ -1711,6 +2227,38 @@ class VideoComposer {
       }
     }
   }
+  async withTimeout(promise, timeoutMs) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      return promise;
+    }
+    let timeoutId = null;
+    try {
+      const safe = promise.then(
+        (value) => ({ ok: true, value }),
+        (error) => ({ ok: false, error })
+      );
+      const result = await Promise.race([
+        safe,
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(
+            () => reject(new Error(`Timeout after ${timeoutMs}ms`)),
+            timeoutMs
+          );
+        })
+      ]);
+      if (result?.ok === true) {
+        return result.value;
+      }
+      if (result?.ok === false) {
+        throw result.error;
+      }
+      return result;
+    } finally {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
   updateConfig(config) {
     Object.assign(this.config, this.applyDefaults({ ...this.config, ...config }));
     if (config.fps !== void 0) {
@@ -1733,6 +2281,272 @@ class VideoComposer {
     this.filterProcessor.clearCache();
   }
 }
+class BaseEncoder {
+  encoder;
+  config;
+  controller = null;
+  constructor(config) {
+    this.config = config;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  get currentConfig() {
+    return this.config;
+  }
+  shouldReconfigure(partial) {
+    const next = { ...this.config, ...partial };
+    const keys = Object.keys(partial ?? {});
+    for (const key of keys) {
+      if (partial[key] !== void 0 && next[key] !== this.config[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  hasConfigChanged(next) {
+    const currentEntries = Object.entries(this.config);
+    for (const [key, value] of currentEntries) {
+      if (next[key] !== value) {
+        return true;
+      }
+    }
+    for (const key of Object.keys(next)) {
+      if (this.config[key] !== next[key]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  configsEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+  }
+  async initialize() {
+    console.info("Encoder is initializing...");
+    if (this.encoder?.state === "configured") {
+      console.warn("Encoder is already initialized, skipping initialization");
+      return;
+    }
+    const isSupported = await this.isConfigSupported(this.config);
+    if (!isSupported.supported) {
+      console.warn("Codec not supported:", JSON.stringify(this.config));
+      throw new Error(`Codec not supported: ${JSON.stringify(this.config)}`);
+    }
+    this.encoder = this.createEncoder({
+      output: this.handleOutput.bind(this),
+      error: this.handleError.bind(this)
+    });
+    this.encoder.configure(this.config);
+    console.info("Encoder is initialized");
+  }
+  async reconfigure(config) {
+    console.info("Encoder is reconfiguring...");
+    if (!config || Object.keys(config).length === 0) {
+      return;
+    }
+    const nextConfig = { ...this.config, ...config };
+    if (this.configsEqual(this.config, nextConfig)) {
+      return;
+    }
+    if (!this.encoder) {
+      this.config = nextConfig;
+      await this.initialize();
+      return;
+    }
+    if (this.encoder.state === "configured") {
+      await this.encoder.flush();
+    }
+    const isSupported = await this.isConfigSupported(nextConfig);
+    if (!isSupported.supported) {
+      throw new Error(`New configuration not supported: ${nextConfig.codec}`);
+    }
+    this.config = nextConfig;
+    this.encoder.configure(this.config);
+    console.info("Encoder is reconfigured");
+  }
+  async flush() {
+    if (!this.encoder) {
+      return;
+    }
+    await this.encoder.flush();
+  }
+  async reset() {
+    console.info("Encoder is resetting...");
+    if (!this.encoder) {
+      console.warn("Encoder is not initialized, skipping reset");
+      return;
+    }
+    this.encoder.reset();
+    this.onReset();
+    console.info("Encoder is resetted");
+  }
+  async close() {
+    console.info("Encoder is closing...");
+    if (!this.encoder) {
+      return;
+    }
+    if (this.encoder.state === "configured") {
+      await this.encoder.flush();
+    }
+    this.encoder.close();
+    this.encoder = void 0;
+    console.info("Encoder is closed");
+  }
+  get isReady() {
+    return this.encoder?.state === "configured";
+  }
+  get queueSize() {
+    return this.encoder?.encodeQueueSize ?? 0;
+  }
+  handleOutput(chunk, metadata) {
+    if (this.controller) {
+      try {
+        this.controller.enqueue({ chunk, metadata });
+      } catch (error) {
+        console.error("Encoder output error:", error);
+        if (!(error instanceof TypeError && error.message.includes("closed"))) {
+          throw error;
+        }
+      }
+    }
+  }
+  handleError(error) {
+    if (error.message.includes("reclaimed")) {
+      console.warn("Encoder reclaimed by browser due to inactivity, skipping error handling");
+      return;
+    }
+    console.error(`[${this.getEncoderType()}Encoder] Encode error:`, {
+      name: error.name,
+      message: error.message,
+      encoderState: this.encoder?.state,
+      queueSize: this.queueSize,
+      platform: typeof navigator !== "undefined" ? navigator.platform : "unknown"
+    });
+    this.controller?.error(error);
+  }
+  // Hook for subclasses to handle reset
+  onReset() {
+  }
+  /**
+   * Create transform stream for encoding
+   * Implements common stream logic with backpressure handling
+   */
+  createStream() {
+    return new TransformStream(
+      {
+        start: async (controller) => {
+          this.controller = controller;
+        },
+        transform: async (input) => {
+          if (!this.isReady) {
+            console.warn("Encoder is not ready, initializing...");
+            await this.initialize();
+          }
+          if (!this.encoder || this.encoder.state !== "configured") {
+            console.error("Encoder not configured, throwing error");
+            throw new Error("Encoder not configured");
+          }
+          if (this.encoder.encodeQueueSize >= this.encodeQueueThreshold) {
+            await new Promise((resolve) => {
+              const check = () => {
+                if (!this.encoder || this.encoder.encodeQueueSize < this.encodeQueueThreshold - 1) {
+                  resolve();
+                } else {
+                  setTimeout(check, 10);
+                }
+              };
+              check();
+            });
+          }
+          const frame = input.frame || input;
+          try {
+            this.encode(frame);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error("Encoder error:", msg);
+            if (err instanceof DOMException && msg.includes("reclaimed")) {
+              console.warn("Codec reclaimed due to inactivity, reset encoder...");
+              this.encoder = void 0;
+              await this.initialize();
+              this.encode(frame);
+            } else {
+              throw err;
+            }
+          }
+        },
+        flush: async () => {
+          await this.flush();
+        }
+      },
+      // Queuing strategy with backpressure configuration
+      {
+        highWaterMark: this.highWaterMark,
+        size: () => 1
+        // Count-based
+      }
+    );
+  }
+}
+class VideoChunkEncoder extends BaseEncoder {
+  static DEFAULT_HIGH_WATER_MARK = 2;
+  static DEFAULT_ENCODE_QUEUE_THRESHOLD = 8;
+  highWaterMark;
+  encodeQueueThreshold;
+  frameCount = 0;
+  // Default 1 second at 30fps for better social media compatibility
+  keyFrameInterval = 30;
+  constructor(config) {
+    super(config);
+    this.highWaterMark = config.backpressure?.highWaterMark ?? VideoChunkEncoder.DEFAULT_HIGH_WATER_MARK;
+    this.encodeQueueThreshold = config.backpressure?.encodeQueueThreshold ?? VideoChunkEncoder.DEFAULT_ENCODE_QUEUE_THRESHOLD;
+    if (config.keyFrameInterval !== void 0) {
+      this.keyFrameInterval = Math.max(1, config.keyFrameInterval);
+    }
+    console.info(
+      "VideoChunkEncoder initialized with encodeQueueThreshold:",
+      this.encodeQueueThreshold,
+      " highWaterMark:",
+      this.highWaterMark,
+      " keyFrameInterval:",
+      this.keyFrameInterval
+    );
+  }
+  async isConfigSupported(config) {
+    const result = await VideoEncoder.isConfigSupported(config);
+    return { supported: result.supported ?? false };
+  }
+  createEncoder(init) {
+    return new VideoEncoder(init);
+  }
+  getEncoderType() {
+    return "Video";
+  }
+  onReset() {
+    this.frameCount = 0;
+  }
+  encode(frame) {
+    try {
+      const keyFrame = this.shouldGenerateKeyFrame();
+      const encodeOptions = {
+        keyFrame
+      };
+      this.encoder.encode(frame, encodeOptions);
+      this.frameCount++;
+    } finally {
+      frame.close();
+    }
+  }
+  setKeyFrameInterval(interval) {
+    this.keyFrameInterval = Math.max(1, interval);
+    console.info("Key frame interval set to:", this.keyFrameInterval);
+  }
+  shouldGenerateKeyFrame() {
+    if (this.frameCount === 0) {
+      return true;
+    }
+    return this.frameCount % this.keyFrameInterval === 0;
+  }
+}
 const MICROSECONDS_PER_SECOND = 1e6;
 const DEFAULT_FPS = 30;
 function normalizeFps(value) {
@@ -2203,217 +3017,109 @@ function computeAnimationState(animation, globalTimeUs) {
     visible: true
   };
 }
-class VideoComposeWorker {
+class ExportWorker {
   channel;
   composer = null;
-  composeStream = null;
-  sessionId = null;
-  downstreamPort = null;
-  upstreamPort = null;
+  encoder = null;
   instructions = null;
   imageMap = /* @__PURE__ */ new Map();
   constructor() {
     this.channel = new WorkerChannel(self, {
-      name: "VideoComposeWorker",
-      timeout: 3e4
+      name: "ExportWorker",
+      timeout: 6e4
     });
     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("get_stats", this.handleGetStats.bind(this));
     this.channel.registerHandler("install_instructions", this.handleInstallInstructions.bind(this));
     this.channel.registerHandler("receive_image", this.handleReceiveImage.bind(this));
     this.channel.registerHandler("dispose_clip", this.handleDisposeClip.bind(this));
+    this.channel.registerHandler("flush", this.handleFlush.bind(this));
     this.channel.registerHandler(WorkerMessageType.Dispose, this.handleDispose.bind(this));
     this.channel.receiveStream(this.handleReceiveStream.bind(this));
   }
-  /**
-   * Unified connect handler used by stream pipeline
-   */
-  async handleConnect(payload) {
-    const { port, direction, sessionId } = payload;
-    if (sessionId && !this.sessionId) {
-      this.sessionId = sessionId;
-    }
-    if (direction === "upstream") {
-      this.upstreamPort = port;
-      const channel = new WorkerChannel(port, {
-        name: "VideoCompose-Decode",
-        timeout: 3e4
-      });
-      channel.receiveStream(this.handleReceiveStream.bind(this));
-    }
-    if (direction === "downstream") {
-      this.downstreamPort = port;
-    }
-    return { success: true };
-  }
-  /**
-   * Configure composer
-   * According to docs/impl/14-config, only reinitialize when initial=true
-   */
   async handleConfigure(payload) {
-    const { config, initial } = payload;
-    const hasValidDimensions = config.width > 0 && config.height > 0;
-    const hasValidFps = config.fps > 0;
-    if (!hasValidDimensions || !hasValidFps) {
+    const { compose, encode } = payload;
+    if (compose.width <= 0 || compose.height <= 0 || compose.fps <= 0) {
       throw new Error(
-        `VideoComposeWorker: invalid canvas config width=${config.width}, height=${config.height}, fps=${config.fps}`
+        `ExportWorker: invalid config width=${compose.width}, height=${compose.height}, fps=${compose.fps}`
       );
     }
-    if (initial) {
-      this.channel.state = WorkerState.Ready;
-    }
-    if (initial || !this.composer) {
-      if (this.composer) {
-        this.composer.dispose();
-        this.composeStream = null;
-      }
-      this.composer = new VideoComposer(config);
-    } else {
-      this.composer.updateConfig(config);
+    if (this.composer) {
+      this.composer.dispose();
     }
-    this.channel.notify("configured", {
-      config: this.composer.config,
-      initialized: initial || false
-    });
-    return {
-      success: true,
-      config: this.composer.config
-    };
+    this.composer = new VideoComposer(compose);
+    this.encoder = new VideoChunkEncoder(encode);
+    await this.encoder.initialize();
+    this.channel.state = WorkerState.Ready;
+    return { success: true };
   }
   async handleReceiveStream(stream, metadata) {
-    if (!this.composer) {
-      console.error("[VideoComposeWorker] Composer not configured");
+    if (!this.composer || !this.encoder) {
+      console.error("[ExportWorker] Not configured");
       return;
     }
     if (metadata?.instructions) {
-      await this.handleInstallInstructions(metadata.instructions);
+      this.handleInstallInstructions(metadata.instructions);
     }
     if (!this.instructions) {
-      console.error("[VideoComposeWorker] No instructions available after metadata check");
+      console.error("[ExportWorker] No instructions");
       return;
     }
     const mainLayer = this.instructions.layers.find(
       (l) => l.type === "video" && !l.payload.attachmentId
     );
-    const trimStartUs = mainLayer?.type === "video" ? mainLayer.payload.trimStartUs ?? 0 : 0;
+    const clipTrimStartUs = mainLayer?.type === "video" ? mainLayer.payload.trimStartUs ?? 0 : 0;
     const timeline = this.instructions.baseConfig.timeline;
-    const fpsConverter = new FrameRateConverter(
-      timeline?.compositionFps ?? 30,
-      timeline?.clipDurationUs ?? Infinity,
-      trimStartUs
-    );
+    const fps = timeline?.compositionFps ?? 30;
+    const windowStartUs = metadata?.windowStartUs ?? clipTrimStartUs;
+    const windowEndUs = metadata?.windowEndUs ?? clipTrimStartUs + (timeline?.clipDurationUs ?? Infinity);
+    const windowDurationUs = windowEndUs - windowStartUs;
+    const windowToClipOffsetUs = windowStartUs - clipTrimStartUs;
+    const fpsConverter = new FrameRateConverter(fps, windowDurationUs, windowStartUs);
     const cfrStream = stream.pipeThrough(fpsConverter.createStream());
-    const filteredStream = cfrStream.pipeThrough(
+    const composeRequestStream = cfrStream.pipeThrough(
       new TransformStream({
         transform: (frame, controller) => {
-          try {
-            const request = this.buildComposeRequest(this.instructions, frame);
-            if (!request) {
-              frame.close();
-              return;
-            }
-            controller.enqueue(request);
-          } catch (error) {
-            console.error("[VideoComposeWorker] buildComposeRequest error:", error);
-            frame?.close?.();
-            throw error;
+          let composeFrame = frame;
+          if (windowToClipOffsetUs > 0) {
+            composeFrame = new VideoFrame(frame, {
+              timestamp: (frame.timestamp ?? 0) + windowToClipOffsetUs
+            });
+            frame.close();
+          }
+          const request = this.buildComposeRequest(this.instructions, composeFrame);
+          if (!request) {
+            composeFrame.close();
+            return;
           }
+          controller.enqueue(request);
         }
       })
     );
     const composeStream = this.composer.createStreams();
-    filteredStream.pipeTo(composeStream.writable).catch((error) => {
-      console.error("[VideoComposeWorker] compose stream error", this.sessionId, error);
+    const encodingTransform = this.encoder.createStream();
+    composeRequestStream.pipeTo(composeStream.writable).catch((error) => {
+      console.error("[ExportWorker] compose pipe error:", error);
+    });
+    const encodedStream = composeStream.readable.pipeThrough(encodingTransform);
+    this.channel.sendStream(encodedStream, {
+      streamType: "video"
     });
-    const meta = {
-      ...metadata,
-      streamType: "video",
-      sessionId: this.sessionId
-    };
-    if (this.downstreamPort) {
-      const encodeChannel = new WorkerChannel(this.downstreamPort, {
-        name: "VideoCompose-Encode",
-        timeout: 3e4
-      });
-      encodeChannel.sendStream(composeStream.readable, meta);
-    } else {
-      this.channel.sendStream(composeStream.readable, meta);
-    }
-  }
-  // private handleGetStream(): ReadableStream<VideoFrame> | undefined {
-  //   return this.composer?.createStreams()?.cacheStream;
-  // }
-  /**
-   * Flush the composition pipeline
-   */
-  async handleFlush() {
-    try {
-      this.channel.notify("flush_complete", {});
-      return { success: true };
-    } catch (error) {
-      throw {
-        code: "FLUSH_ERROR",
-        message: error.message
-      };
-    }
-  }
-  /**
-   * Get composer statistics
-   */
-  async handleGetStats() {
-    return {
-      configured: this.composer !== null,
-      config: this.composer?.config,
-      streaming: this.composeStream !== null
-    };
-  }
-  /**
-   * Dispose worker and cleanup resources
-   */
-  async handleDispose() {
-    if (this.composer) {
-      this.composer.dispose();
-      this.composer = null;
-    }
-    this.composeStream = null;
-    this.downstreamPort?.close();
-    this.upstreamPort?.close();
-    this.downstreamPort = null;
-    this.upstreamPort = null;
-    this.imageMap.forEach((bitmap) => bitmap.close());
-    this.imageMap.clear();
-    this.instructions = null;
-    this.channel.state = WorkerState.Disposed;
-    return { success: true };
   }
-  async handleInstallInstructions(payload) {
-    const { clipId, revision } = payload;
-    if (!this.sessionId) {
-      this.sessionId = clipId;
-    }
+  handleInstallInstructions(payload) {
+    const { revision } = payload;
     if (this.instructions && this.instructions.revision > revision) {
       return { success: false };
     }
     this.instructions = payload;
     return { success: true };
   }
-  /**
-   * Receive image data with instructions (aligned with video pipeline)
-   * Note: ImageBitmap is required because VideoFrame constructor in Worker context
-   * only accepts ImageBitmap/OffscreenCanvas, not HTMLImageElement or Blob
-   */
   async handleReceiveImage(payload) {
-    const { resourceId, sessionId, imageBitmap, instructions } = payload;
-    if (!this.sessionId) {
-      this.sessionId = sessionId;
-    }
+    const { resourceId, imageBitmap, instructions } = payload;
     if (instructions) {
-      await this.handleInstallInstructions(instructions);
+      this.handleInstallInstructions(instructions);
     }
     const existing = this.imageMap.get(resourceId);
     if (existing) {
@@ -2429,33 +3135,19 @@ class VideoComposeWorker {
     }
     return { success: true };
   }
-  async handleDisposeClip() {
-    this.instructions = null;
-    this.downstreamPort?.close();
-    this.upstreamPort?.close();
-    this.downstreamPort = null;
-    this.upstreamPort = null;
-    this.imageMap.forEach((bitmap) => bitmap.close());
-    this.imageMap.clear();
-    return { success: true };
-  }
   async startImageFrameStream() {
-    if (!this.instructions || !this.composer) {
+    if (!this.instructions || !this.composer || !this.encoder) {
       return;
     }
     const timeline = this.instructions.baseConfig.timeline;
-    if (!timeline) {
-      return;
-    }
+    if (!timeline) return;
     const mainLayer = this.instructions.layers.find((l) => !l.payload.attachmentId);
     if (!mainLayer) return;
     const mainResourceId = mainLayer.payload.resourceId;
     const imageBitmap = this.imageMap.get(mainResourceId);
-    if (!imageBitmap) {
-      console.warn("[VideoComposeWorker] Main track ImageBitmap not found:", mainResourceId);
-      return;
-    }
+    if (!imageBitmap) return;
     const composeStream = this.composer.createStreams();
+    const encodingTransform = this.encoder.createStream();
     const { clipDurationUs, compositionFps } = timeline;
     let currentTimeUs = 0;
     const readableStream = new ReadableStream({
@@ -2468,36 +3160,49 @@ class VideoComposeWorker {
           timestamp: currentTimeUs,
           duration: frameDurationFromFps(compositionFps)
         });
-        try {
-          const request = this.buildComposeRequest(this.instructions, videoFrame);
-          if (request) {
-            controller.enqueue(request);
-          } else {
-            videoFrame.close();
-          }
-          currentTimeUs += frameDurationFromFps(compositionFps);
-        } catch (error) {
+        const request = this.buildComposeRequest(this.instructions, videoFrame);
+        if (request) {
+          controller.enqueue(request);
+        } else {
           videoFrame.close();
-          throw error;
         }
+        currentTimeUs += frameDurationFromFps(compositionFps);
       }
     });
     readableStream.pipeTo(composeStream.writable).catch((error) => {
-      console.error("[VideoComposeWorker] image frame stream error", this.sessionId, error);
+      console.error("[ExportWorker] image frame stream error:", error);
     });
-    const meta = {
-      streamType: "video",
-      sessionId: this.sessionId
-    };
-    if (this.downstreamPort) {
-      const encodeChannel = new WorkerChannel(this.downstreamPort, {
-        name: "VideoCompose-Encode",
-        timeout: 3e4
-      });
-      encodeChannel.sendStream(composeStream.readable, meta);
-    } else {
-      this.channel.sendStream(composeStream.readable, meta);
+    const encodedStream = composeStream.readable.pipeThrough(encodingTransform);
+    this.channel.sendStream(encodedStream, {
+      streamType: "video"
+    });
+  }
+  async handleDisposeClip() {
+    this.instructions = null;
+    this.imageMap.forEach((bitmap) => bitmap.close());
+    this.imageMap.clear();
+    return { success: true };
+  }
+  async handleFlush() {
+    if (this.encoder) {
+      await this.encoder.flush();
+    }
+    return { success: true };
+  }
+  async handleDispose() {
+    if (this.composer) {
+      this.composer.dispose();
+      this.composer = null;
     }
+    if (this.encoder) {
+      await this.encoder.close();
+      this.encoder = null;
+    }
+    this.imageMap.forEach((bitmap) => bitmap.close());
+    this.imageMap.clear();
+    this.instructions = null;
+    this.channel.state = WorkerState.Disposed;
+    return { success: true };
   }
   buildComposeRequest(instruction, frame) {
     const clipRelativeTime = frame.timestamp ?? 0;
@@ -2506,20 +3211,16 @@ class VideoComposeWorker {
       return null;
     }
     const activeLayers = resolveActiveLayers(instruction.layers, clipRelativeTime);
-    if (!activeLayers.length) {
-      return null;
-    }
+    if (!activeLayers.length) return null;
     const clipStartUs = instruction.baseConfig.timeline?.clipStartUs ?? 0;
     const globalTimeUs = clipStartUs + clipRelativeTime;
     const layers = activeLayers.map((layer) => materializeLayer(layer, frame, this.imageMap, globalTimeUs)).filter((layer) => layer !== null);
-    if (!layers.length) {
-      return null;
-    }
+    if (!layers.length) return null;
     return {
       timeUs: clipRelativeTime,
       globalTimeUs,
       layers,
-      transition: VideoComposeWorker.buildTransition(
+      transition: ExportWorker.buildTransition(
         instruction.transitions,
         clipRelativeTime,
         instruction.baseConfig.timeline
@@ -2531,9 +3232,7 @@ class VideoComposeWorker {
       const { startUs, endUs } = transition.range;
       return timeUs >= startUs && timeUs < endUs;
     });
-    if (!entry) {
-      return void 0;
-    }
+    if (!entry) return void 0;
     const durationUs = entry.range.endUs - entry.range.startUs;
     const progress = durationUs > 0 ? (timeUs - entry.range.startUs) / durationUs : 0;
     return {
@@ -2545,13 +3244,12 @@ class VideoComposeWorker {
     };
   }
 }
-const worker = new VideoComposeWorker();
+const worker = new ExportWorker();
 self.addEventListener("beforeunload", () => {
   worker["handleDispose"]();
 });
-const videoCompose_worker = null;
+const export_worker = null;
 export {
-  VideoComposeWorker,
-  videoCompose_worker as default
+  export_worker as default
 };
-//# sourceMappingURL=video-compose.worker.KMZjuJuY.js.map
+//# sourceMappingURL=export.worker.SahP9aVK.js.map