@meframe/core 0.0.2 → 0.0.4

package/dist/assets/encode.worker-nfOb3kw6.js

@@ -1,1026 +0,0 @@
-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 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() {
-    if (this.encoder?.state === "configured") {
-      return;
-    }
-    const isSupported = await this.isConfigSupported(this.config);
-    if (!isSupported.supported) {
-      throw new Error(`Codec not supported: ${this.config.codec}`);
-    }
-    this.encoder = this.createEncoder({
-      output: this.handleOutput.bind(this),
-      error: this.handleError.bind(this)
-    });
-    this.encoder.configure(this.config);
-  }
-  async reconfigure(config) {
-    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);
-  }
-  async flush() {
-    if (!this.encoder) {
-      return;
-    }
-    await this.encoder.flush();
-  }
-  async reset() {
-    if (!this.encoder) {
-      return;
-    }
-    this.encoder.reset();
-    this.onReset();
-  }
-  async close() {
-    if (!this.encoder) {
-      return;
-    }
-    if (this.encoder.state === "configured") {
-      await this.encoder.flush();
-    }
-    this.encoder.close();
-    this.encoder = void 0;
-  }
-  get isReady() {
-    return this.encoder?.state === "configured";
-  }
-  get queueSize() {
-    return this.encoder?.encodeQueueSize ?? 0;
-  }
-  handleOutput(chunk, _metadata) {
-    this.controller?.enqueue(chunk);
-  }
-  handleError(error) {
-    console.error(`${this.getEncoderType()} encoder error:`, error);
-    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;
-          if (!this.isReady) {
-            await this.initialize();
-          }
-        },
-        transform: async (input) => {
-          if (!this.encoder || this.encoder.state !== "configured") {
-            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();
-            });
-          }
-          this.encode(input);
-        },
-        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;
-  keyFrameInterval = 60;
-  // 2 seconds at 30fps
-  constructor(config) {
-    super(config);
-    this.highWaterMark = config.backpressure?.highWaterMark ?? VideoChunkEncoder.DEFAULT_HIGH_WATER_MARK;
-    this.encodeQueueThreshold = config.backpressure?.encodeQueueThreshold ?? VideoChunkEncoder.DEFAULT_ENCODE_QUEUE_THRESHOLD;
-  }
-  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) {
-    const keyFrame = this.shouldGenerateKeyFrame();
-    const encodeOptions = {
-      keyFrame
-    };
-    this.encoder.encode(frame, encodeOptions);
-    this.frameCount++;
-    frame.close();
-  }
-  setKeyFrameInterval(interval) {
-    this.keyFrameInterval = Math.max(1, interval);
-  }
-  shouldGenerateKeyFrame() {
-    if (this.frameCount === 0) {
-      return true;
-    }
-    return this.frameCount % this.keyFrameInterval === 0;
-  }
-}
-class AudioChunkEncoder extends BaseEncoder {
-  static DEFAULT_HIGH_WATER_MARK = 4;
-  static DEFAULT_ENCODE_QUEUE_THRESHOLD = 16;
-  highWaterMark;
-  encodeQueueThreshold;
-  constructor(config) {
-    super(config);
-    this.highWaterMark = config.backpressure?.highWaterMark ?? AudioChunkEncoder.DEFAULT_HIGH_WATER_MARK;
-    this.encodeQueueThreshold = config.backpressure?.encodeQueueThreshold ?? AudioChunkEncoder.DEFAULT_ENCODE_QUEUE_THRESHOLD;
-  }
-  async isConfigSupported(config) {
-    const result = await AudioEncoder.isConfigSupported(config);
-    return { supported: result.supported ?? false };
-  }
-  createEncoder(init) {
-    return new AudioEncoder(init);
-  }
-  getEncoderType() {
-    return "Audio";
-  }
-  encode(data) {
-    if (this.encoder?.state !== "configured") {
-      throw new Error("Audio encoder not configured");
-    }
-    const config = this.getConfig();
-    if (data.sampleRate !== config.sampleRate || data.numberOfChannels !== config.numberOfChannels) {
-      throw new Error("AudioData requires resampling or channel remap before encoding");
-    }
-    this.encoder.encode(data);
-    data.close();
-  }
-}
-class EncodeWorker {
-  channel;
-  videoEncoder = null;
-  audioEncoder = null;
-  // Connections to other workers
-  cachePort = null;
-  muxPort = null;
-  composePorts = /* @__PURE__ */ new Map();
-  // Connections from compose workers
-  constructor() {
-    this.channel = new WorkerChannel(self, {
-      name: "EncodeWorker",
-      timeout: 3e4
-    });
-    this.setupHandlers();
-  }
-  setupHandlers() {
-    this.channel.registerHandler("configure", this.handleConfigure.bind(this));
-    this.channel.registerHandler("connect", this.handleConnect.bind(this));
-    this.channel.registerHandler("configure_video", this.handleConfigureVideo.bind(this));
-    this.channel.registerHandler("configure_audio", this.handleConfigureAudio.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, streamType } = payload;
-    if (streamType === "video") return this.handleConnectComposer({ composeType: "video", port });
-    if (streamType === "audio") return this.handleConnectComposer({ composeType: "audio", port });
-    if (streamType === "chunk") return this.handleConnectMux({ port });
-    return { success: true };
-  }
-  /**
-   * Handle configuration message from orchestrator
-   * @param payload.initial - If true, initialize worker and recreate encoder instances; otherwise just update config
-   */
-  async handleConfigure(payload) {
-    const { config, initial = false } = payload;
-    if (initial) {
-      this.channel.state = WorkerState.Ready;
-    }
-    if (config.video) {
-      if (initial || !this.videoEncoder) {
-        if (this.videoEncoder) {
-          await this.videoEncoder.close();
-        }
-        this.videoEncoder = new VideoChunkEncoder(config.video);
-        await this.videoEncoder.initialize();
-        const videoStream = config.video.stream?.pipeThrough(this.videoEncoder.createStream());
-        if (videoStream && this.cachePort) {
-          const cacheChannel = new WorkerChannel(this.cachePort, {
-            name: "Encode-Cache-Video",
-            timeout: 3e4
-          });
-          await cacheChannel.sendStream(videoStream, {
-            type: "video",
-            width: config.video.width,
-            height: config.video.height,
-            framerate: config.video.framerate
-          });
-        }
-      } else {
-        await this.videoEncoder.reconfigure(config.video);
-      }
-    }
-    if (config.audio) {
-      if (initial || !this.audioEncoder) {
-        if (this.audioEncoder) {
-          await this.audioEncoder.close();
-        }
-        this.audioEncoder = new AudioChunkEncoder(config.audio);
-        await this.audioEncoder.initialize();
-        const audioStream = config.audio.stream?.pipeThrough(this.audioEncoder.createStream());
-        if (audioStream && this.cachePort) {
-          const cacheChannel = new WorkerChannel(this.cachePort, {
-            name: "Encode-Cache-Audio",
-            timeout: 3e4
-          });
-          await cacheChannel.sendStream(audioStream, {
-            type: "audio",
-            sampleRate: config.audio.sampleRate,
-            numberOfChannels: config.audio.numberOfChannels
-          });
-        }
-      } else {
-        await this.audioEncoder.reconfigure(config.audio);
-      }
-    }
-    return { success: true };
-  }
-  /**
-   * Connect to a compose worker to receive frames/audio data
-   */
-  async handleConnectComposer(payload) {
-    const { composeType, port } = payload;
-    this.composePorts.set(composeType, port);
-    const composeChannel = new WorkerChannel(port, {
-      name: `Encode-${composeType}Compose`,
-      timeout: 3e4
-    });
-    composeChannel.receiveStream(async (stream, metadata) => {
-      if (metadata?.streamType === "video" && this.videoEncoder) {
-        const reader = stream.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            const wrappedValue = value;
-            const videoFrame = wrappedValue.frame || wrappedValue;
-            try {
-              const frame = videoFrame.clone();
-              this.videoEncoder.encode(frame);
-            } finally {
-              videoFrame.close();
-            }
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      } else if (metadata?.streamType === "audio" && this.audioEncoder) {
-        const composedConfig = {
-          sampleRate: metadata.sampleRate,
-          numberOfChannels: metadata.numberOfChannels
-        };
-        const currentConfig = this.audioEncoder.getConfig();
-        if (typeof composedConfig.sampleRate === "number" && composedConfig.sampleRate > 0 && composedConfig.sampleRate !== currentConfig.sampleRate) {
-          await this.audioEncoder.reconfigure({ sampleRate: composedConfig.sampleRate });
-        }
-        if (typeof composedConfig.numberOfChannels === "number" && composedConfig.numberOfChannels > 0 && composedConfig.numberOfChannels !== currentConfig.numberOfChannels) {
-          await this.audioEncoder.reconfigure({
-            numberOfChannels: composedConfig.numberOfChannels
-          });
-        }
-        const reader = stream.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            this.audioEncoder.encode(value);
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      }
-    });
-    return { success: true };
-  }
-  /**
-   * Connect to cache manager for output streaming
-   */
-  // private async handleConnectCache(payload: { port: MessagePort }): Promise<{ success: boolean }> {
-  //   this.cachePort = payload.port;
-  //   return { success: true };
-  // }
-  /**
-   * Connect to mux worker for output streaming
-   */
-  async handleConnectMux(payload) {
-    this.muxPort = payload.port;
-    return { success: true };
-  }
-  /**
-   * Configure video encoder with specific settings
-   */
-  async handleConfigureVideo(config) {
-    try {
-      if (!this.videoEncoder) {
-        this.videoEncoder = new VideoChunkEncoder(config);
-        await this.videoEncoder.initialize();
-      } else {
-        await this.videoEncoder.reconfigure(config);
-      }
-      this.channel.notify("video_configured", {
-        codec: config.codec,
-        width: config.width,
-        height: config.height,
-        bitrate: config.bitrate
-      });
-      return { success: true };
-    } catch (error) {
-      throw {
-        code: "VIDEO_CONFIG_ERROR",
-        message: error.message
-      };
-    }
-  }
-  /**
-   * Configure audio encoder with specific settings
-   */
-  async handleConfigureAudio(config) {
-    try {
-      if (!this.audioEncoder) {
-        this.audioEncoder = new AudioChunkEncoder(config);
-        await this.audioEncoder.initialize();
-      } else {
-        await this.audioEncoder.reconfigure(config);
-      }
-      this.channel.notify("audio_configured", {
-        codec: config.codec,
-        sampleRate: config.sampleRate,
-        numberOfChannels: config.numberOfChannels,
-        bitrate: config.bitrate
-      });
-      return { success: true };
-    } catch (error) {
-      throw {
-        code: "AUDIO_CONFIG_ERROR",
-        message: error.message
-      };
-    }
-  }
-  /**
-   * Flush encoders and get buffered chunks
-   */
-  async handleFlush(payload) {
-    try {
-      const result = {};
-      if (!payload?.type || payload.type === "video") {
-        const chunks = await this.videoEncoder?.flush();
-        if (chunks) {
-          result.videoChunks = chunks;
-        }
-      }
-      if (!payload?.type || payload.type === "audio") {
-        const chunks = await this.audioEncoder?.flush();
-        if (chunks) {
-          result.audioChunks = chunks;
-        }
-      }
-      return result;
-    } catch (error) {
-      throw {
-        code: "FLUSH_ERROR",
-        message: error.message
-      };
-    }
-  }
-  /**
-   * Reset encoders
-   */
-  async handleReset(payload) {
-    try {
-      if (!payload?.type || payload.type === "video") {
-        await this.videoEncoder?.reset();
-      }
-      if (!payload?.type || payload.type === "audio") {
-        await this.audioEncoder?.reset();
-      }
-      this.channel.notify("reset_complete", {
-        type: payload?.type || "all"
-      });
-      return { success: true };
-    } catch (error) {
-      throw {
-        code: "RESET_ERROR",
-        message: error.message
-      };
-    }
-  }
-  /**
-   * Get encoder statistics
-   */
-  async handleGetStats() {
-    const stats = {};
-    if (this.videoEncoder) {
-      stats.video = {
-        configured: this.videoEncoder.isReady,
-        queueSize: this.videoEncoder.queueSize
-      };
-    }
-    if (this.audioEncoder) {
-      stats.audio = {
-        configured: this.audioEncoder.isReady,
-        queueSize: this.audioEncoder.queueSize
-      };
-    }
-    return stats;
-  }
-  // Output and error handling is done via streams in the encoder itself
-  // These placeholder methods can be implemented when needed for direct callback handling
-  /**
-   * Dispose worker and cleanup resources
-   */
-  async handleDispose() {
-    await this.videoEncoder?.close();
-    await this.audioEncoder?.close();
-    this.videoEncoder = null;
-    this.audioEncoder = null;
-    this.cachePort?.close();
-    this.cachePort = null;
-    this.muxPort?.close();
-    this.muxPort = null;
-    for (const port of this.composePorts.values()) {
-      port.close();
-    }
-    this.composePorts.clear();
-    this.channel.state = WorkerState.Disposed;
-    return { success: true };
-  }
-}
-const worker = new EncodeWorker();
-self.addEventListener("beforeunload", () => {
-  worker["handleDispose"]();
-});
-//# sourceMappingURL=encode.worker-nfOb3kw6.js.map