@meframe/core 0.0.2 → 0.0.4

package/dist/{assets/video-demux.worker-D019I7GQ.js → workers/mp4box.all.js}

@@ -1,483 +1,3 @@
-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;
-  }
-}
 var mp4box_all = {};
 (function(exports) {
   var Log = /* @__PURE__ */ function() {
@@ -7523,435 +7043,7 @@ var mp4box_all = {};
     exports.createFile = MP4Box.createFile;
   }
 })(mp4box_all);
-class BackpressureMonitor {
-  metrics = /* @__PURE__ */ new Map();
-  /**
-   * Update metrics for a stage
-   */
-  updateMetrics(stage, desiredSize, queueSize = 0) {
-    const isPaused = desiredSize <= 0;
-    this.metrics.set(stage, {
-      desiredSize,
-      queueSize,
-      isPaused,
-      lastUpdate: Date.now()
-    });
-  }
-  /**
-   * Get current metrics snapshot
-   */
-  getSnapshot() {
-    const now = Date.now();
-    const snapshot = {};
-    for (const [stage, metrics] of this.metrics) {
-      snapshot[stage] = {
-        ...metrics,
-        age: now - metrics.lastUpdate
-      };
-    }
-    return snapshot;
-  }
-  /**
-   * Check if any stage is experiencing backpressure
-   */
-  hasBackpressure() {
-    for (const metrics of this.metrics.values()) {
-      if (metrics.isPaused) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Get stages currently experiencing backpressure
-   */
-  getBottlenecks() {
-    const bottlenecks = [];
-    for (const [stage, metrics] of this.metrics) {
-      if (metrics.isPaused) {
-        bottlenecks.push(stage);
-      }
-    }
-    return bottlenecks;
-  }
-  /**
-   * Clear all metrics
-   */
-  clear() {
-    this.metrics.clear();
-  }
-}
-class MP4Demuxer {
-  mp4boxFile;
-  tracks = /* @__PURE__ */ new Map();
-  isReady = false;
-  videoController;
-  audioController;
-  backpressureMonitor;
-  demuxHighWaterMark;
-  onReadyCallback;
-  fileOffset = 0;
-  videoTimestampOffset = null;
-  audioTimestampOffset = null;
-  constructor(config = {}) {
-    this.mp4boxFile = mp4box_all.createFile();
-    this.backpressureMonitor = new BackpressureMonitor();
-    this.onReadyCallback = config.onReady;
-    const DEFAULT_HIGH_WATER_MARK = 10;
-    this.demuxHighWaterMark = config.highWaterMark ?? DEFAULT_HIGH_WATER_MARK;
-    this.setupHandlers();
-  }
-  updateConfig(config) {
-    this.demuxHighWaterMark = config.highWaterMark ?? this.demuxHighWaterMark;
-  }
-  setupHandlers() {
-    this.mp4boxFile.onError = (error) => {
-      console.error("MP4Box error:", error);
-      this.videoController?.error(new Error(error));
-      this.audioController?.error(new Error(error));
-    };
-    this.mp4boxFile.onReady = (info) => {
-      this.processTracks(info.tracks);
-      this.isReady = true;
-      if (this.onReadyCallback) {
-        this.onReadyCallback();
-      }
-      this.mp4boxFile.start();
-    };
-    this.mp4boxFile.onSamples = (trackId, _user, samples) => {
-      this.processSamples(trackId, samples);
-    };
-  }
-  processTracks(tracks) {
-    for (const track of tracks) {
-      const trackInfo = {
-        id: track.id,
-        type: track.type === "video" ? "video" : "audio",
-        codec: track.codec,
-        timescale: track.timescale
-      };
-      if (track.type === "video") {
-        trackInfo.width = track.video?.width;
-        trackInfo.height = track.video?.height;
-        trackInfo.description = this.getVideoDescription(track);
-      } else if (track.type === "audio") {
-        trackInfo.sampleRate = track.audio?.sample_rate;
-        trackInfo.numberOfChannels = track.audio?.channel_count;
-        trackInfo.description = this.getAudioDescription(track);
-      }
-      this.tracks.set(track.id, trackInfo);
-      this.mp4boxFile.setExtractionOptions(track.id, track, {
-        nbSamples: 30
-        // Batch size per callback (balance between latency and overhead)
-      });
-    }
-  }
-  processSamples(trackId, samples) {
-    const track = this.tracks.get(trackId);
-    if (!track) return;
-    const timescale = track.timescale || 9e4;
-    for (const sample of samples) {
-      const rawTimestamp = sample.cts * 1e6 / timescale;
-      const duration = sample.duration * 1e6 / timescale;
-      if (track.type === "video") {
-        if (!this.videoController) {
-          console.error("[MP4Demuxer] videoController is null when trying to output chunk!");
-          return;
-        }
-        if (this.videoTimestampOffset === null) {
-          this.videoTimestampOffset = rawTimestamp;
-        }
-        const timestamp = rawTimestamp - this.videoTimestampOffset;
-        const chunk = new EncodedVideoChunk({
-          type: sample.is_sync ? "key" : "delta",
-          timestamp,
-          duration,
-          data: sample.data
-        });
-        this.videoController.enqueue(chunk);
-      } else if (track.type === "audio" && this.audioController) {
-        if (this.audioTimestampOffset === null) {
-          this.audioTimestampOffset = rawTimestamp;
-        }
-        const timestamp = rawTimestamp - this.audioTimestampOffset;
-        const chunk = new EncodedAudioChunk({
-          type: "key",
-          timestamp,
-          duration,
-          data: sample.data
-        });
-        this.audioController.enqueue(chunk);
-      }
-    }
-    const last = samples[samples.length - 1].number;
-    this.mp4boxFile.releaseUsedSamples(trackId, last + 1);
-  }
-  getVideoDescription(track) {
-    try {
-      const fullTrack = this.mp4boxFile.getTrackById(track.id);
-      for (const entry of fullTrack.mdia.minf.stbl.stsd.entries) {
-        const box2 = entry.avcC ?? entry.hvcC ?? entry.av1C ?? entry.vpcC;
-        if (box2) {
-          const stream = new mp4box_all.DataStream(
-            void 0,
-            0,
-            mp4box_all.DataStream.BIG_ENDIAN
-            // IMPORTANT: must be BIG_ENDIAN
-          );
-          box2.write(stream);
-          return new Uint8Array(stream.buffer.slice(8)).buffer;
-        }
-      }
-    } catch (error) {
-      console.error("Failed to get video description:", error);
-    }
-    return void 0;
-  }
-  // private getVideoDescription(track: any): ArrayBuffer | undefined {
-  //   if (!this.mp4boxFile) return undefined;
-  //   return getVideoDescription(this.mp4boxFile, track);
-  // }
-  getAudioDescription(track) {
-    try {
-      const fullTrack = this.mp4boxFile.getTrackById(track.id);
-      for (const entry of fullTrack.mdia.minf.stbl.stsd.entries) {
-        if (entry.esds || entry.dOps) {
-          const stream = new mp4box_all.DataStream();
-          (entry.esds || entry.dOps).write(stream);
-          return new Uint8Array(stream.buffer.slice(8)).buffer;
-        }
-      }
-    } catch (error) {
-      console.error("Failed to get audio description:", error);
-    }
-    return void 0;
-  }
-  /**
-   * Create transform stream for video track
-   */
-  createVideoStream() {
-    return new TransformStream(
-      {
-        start: (controller) => {
-          this.videoController = controller;
-        },
-        transform: (chunk, controller) => {
-          const desiredSize = controller.desiredSize ?? this.demuxHighWaterMark;
-          this.backpressureMonitor.updateMetrics("demux-video", desiredSize);
-          const chunkData = new Uint8Array(chunk);
-          this.appendBuffer(chunkData);
-          this.mp4boxFile.flush();
-        },
-        flush: async () => {
-          this.mp4boxFile.flush();
-          await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-      },
-      // Queuing strategy: use configuration
-      {
-        highWaterMark: this.demuxHighWaterMark,
-        size: () => 1
-        // Count-based
-      }
-    );
-  }
-  /**
-   * Create transform stream for audio track
-   */
-  createAudioStream() {
-    const hasAudio = Array.from(this.tracks.values()).some((t) => t.type === "audio");
-    if (!hasAudio) return null;
-    return new TransformStream(
-      {
-        start: (controller) => {
-          this.audioController = controller;
-        },
-        transform: (chunk, controller) => {
-          const desiredSize = controller.desiredSize ?? this.demuxHighWaterMark;
-          this.backpressureMonitor.updateMetrics("demux-audio", desiredSize);
-          const chunkData = new Uint8Array(chunk);
-          this.appendBuffer(chunkData);
-          this.mp4boxFile.flush();
-        },
-        flush: () => {
-          this.mp4boxFile.flush();
-        }
-      },
-      // Queuing strategy: use configuration
-      {
-        highWaterMark: this.demuxHighWaterMark,
-        size: () => 1
-      }
-    );
-  }
-  appendBuffer(chunk) {
-    const buffer = chunk.buffer;
-    buffer.fileStart = this.fileOffset;
-    this.mp4boxFile.appendBuffer(buffer);
-    this.fileOffset += chunk.byteLength;
-  }
-  /**
-   * Get video track info if available
-   */
-  get videoTrackInfo() {
-    return Array.from(this.tracks.values()).find((track) => track.type === "video");
-  }
-  /**
-   * Get audio track info if available
-   */
-  get audioTrackInfo() {
-    return Array.from(this.tracks.values()).find((track) => track.type === "audio");
-  }
-  destroy() {
-    this.mp4boxFile?.stop();
-    this.mp4boxFile = null;
-    this.tracks.clear();
-    this.backpressureMonitor.clear();
-    this.isReady = false;
-    this.videoTimestampOffset = null;
-    this.audioTimestampOffset = null;
-  }
-}
-class VideoDemuxWorker {
-  channel;
-  demuxer = null;
-  clipId = null;
-  downstreamPort = null;
-  constructor() {
-    this.channel = new WorkerChannel(self, {
-      name: "VideoDemuxWorker",
-      timeout: 3e4
-    });
-    this.setupHandlers();
-  }
-  /* @better-ai.mdc For test visibility */
-  setupHandlers() {
-    this.channel.registerHandler("configure", this.handleConfigure.bind(this));
-    this.channel.registerHandler("connect", this.handleConnect.bind(this));
-    this.channel.registerHandler("get_stats", this.handleGetStats.bind(this));
-    this.channel.registerHandler(WorkerMessageType.Dispose, this.handleDispose.bind(this));
-    this.channel.receiveStream(this.handleReceiveStream.bind(this));
-  }
-  /**
-   * Handle connection from orchestrator
-   */
-  async handleConnect(payload) {
-    const { port, clipId } = payload;
-    if (!port) {
-      return { success: false };
-    }
-    this.downstreamPort = port;
-    this.clipId = clipId || null;
-    return { success: true };
-  }
-  /**
-   * Configure demuxer with format settings
-   * @param payload.config - Demuxer configuration
-   * @param payload.initial - If true, initialize worker state; otherwise just update config
-   */
-  async handleConfigure(payload) {
-    const { config, initial = false } = payload;
-    try {
-      if (initial) {
-        this.channel.state = WorkerState.Ready;
-        if (this.demuxer) {
-          this.demuxer.destroy();
-        }
-        this.demuxer = new MP4Demuxer({
-          ...config,
-          skipAudio: true,
-          // Video only
-          onReady: () => this.handleDemuxerReady()
-        });
-        this.channel.notify("configured");
-        return { success: true };
-      } else {
-        this.demuxer?.updateConfig(config);
-        return { success: true };
-      }
-    } catch (error) {
-      throw {
-        code: error.code || "CONFIG_ERROR",
-        message: error.message
-      };
-    }
-  }
-  /**
-   * Handle input stream from ResourceLoader (main thread)
-   * Strategy: Stream immediately, send codec info when ready
-   */
-  async handleReceiveStream(stream, metadata) {
-    this.clipId = metadata?.clipId || this.clipId;
-    if (!this.demuxer) {
-      this.demuxer = new MP4Demuxer({
-        highWaterMark: 10,
-        skipAudio: true,
-        onReady: () => this.handleDemuxerReady()
-      });
-    }
-    if (!this.downstreamPort) {
-      throw new Error("Decoder not connected");
-    }
-    const videoStream = this.demuxer.createVideoStream();
-    const downstreamChannel = new WorkerChannel(this.downstreamPort, {
-      name: "VideoDemux-Decoder",
-      timeout: 3e4
-    });
-    downstreamChannel.sendStream(videoStream.readable, {
-      streamType: "video",
-      clipId: this.clipId
-    });
-    await stream.pipeTo(videoStream.writable);
-  }
-  handleDemuxerReady() {
-    if (!this.demuxer || !this.downstreamPort) {
-      return;
-    }
-    const videoTrackInfo = this.demuxer.videoTrackInfo;
-    if (!videoTrackInfo) {
-      console.error("[VideoDemuxWorker] No video track found after ready");
-      return;
-    }
-    const downstreamChannel = new WorkerChannel(this.downstreamPort, {
-      name: "VideoDemux-Decoder",
-      timeout: 3e4
-    });
-    downstreamChannel.send("configure", {
-      clipId: this.clipId,
-      streamType: "video",
-      codec: videoTrackInfo.codec,
-      width: videoTrackInfo.width,
-      height: videoTrackInfo.height,
-      description: videoTrackInfo.description
-    });
-  }
-  /**
-   * Get demuxer statistics
-   */
-  async handleGetStats() {
-    if (!this.demuxer) {
-      return { state: this.channel.state };
-    }
-    return {
-      tracksInfo: Array.from(this.demuxer.tracks.values()),
-      state: this.channel.state
-    };
-  }
-  /**
-   * Dispose worker and cleanup resources
-   */
-  async handleDispose() {
-    this.demuxer?.destroy();
-    this.demuxer = null;
-    this.clipId = null;
-    this.downstreamPort?.close();
-    this.downstreamPort = null;
-    this.channel.state = WorkerState.Disposed;
-    return { success: true };
-  }
-}
-const worker = new VideoDemuxWorker();
-self.addEventListener("beforeunload", () => {
-  worker["handleDispose"]();
-});
-//# sourceMappingURL=video-demux.worker-D019I7GQ.js.map
+export {
+  mp4box_all as m
+};
+//# sourceMappingURL=mp4box.all.js.map