@meframe/core 0.0.1

package/dist/stages/mux/MP4Muxer.js

@@ -0,0 +1,262 @@
+import "../../node_modules/.pnpm/mp4box@0.5.4/node_modules/mp4box/dist/mp4box.all.js";
+import { calculateTimescale, parseCodecString, usToTimescale } from "./utils.js";
+import { __exports as mp4box_all } from "../../_virtual/mp4box.all.js";
+class MP4Muxer {
+  mp4boxFile;
+  tracks = /* @__PURE__ */ new Map();
+  mp4Tracks = /* @__PURE__ */ new Map();
+  // muxTrackId -> mp4boxTrackId
+  // Expose output chunks directly instead of getter
+  outputChunks = [];
+  // Expose total bytes written as computed property
+  get totalBytesWritten() {
+    return this.outputChunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  }
+  // Expose finalized state
+  isFinalized = false;
+  config;
+  constructor(config = { container: "mp4" }) {
+    this.config = config;
+    this.mp4boxFile = mp4box_all.createFile();
+    this.setupHandlers();
+    this.initializeTracks();
+  }
+  setupHandlers() {
+    this.mp4boxFile.onError = (error) => {
+      console.error("MP4Box error:", error);
+    };
+    this.mp4boxFile.onSegment = (_id, _user, buffer, _sampleNumber, _last) => {
+      const chunk = new Uint8Array(buffer);
+      this.outputChunks.push(chunk);
+    };
+    if (this.config.mp4?.fragmented) {
+      this.mp4boxFile.onInitSegment = (_tracks) => {
+        const initSegment = this.mp4boxFile.getInitializationSegment();
+        if (initSegment) {
+          const chunk = new Uint8Array(initSegment);
+          this.outputChunks.push(chunk);
+        }
+      };
+    }
+  }
+  initializeTracks() {
+    if (this.config.video) {
+      const videoTrack = {
+        id: 1,
+        // Default video track ID
+        type: "video",
+        codec: this.config.video.codec,
+        width: this.config.video.width,
+        height: this.config.video.height,
+        frameRate: this.config.video.frameRate,
+        timescale: calculateTimescale(this.config.video.frameRate),
+        codecConfig: this.config.video.description
+      };
+      this.addTrack(videoTrack);
+    }
+    if (this.config.audio) {
+      const audioTrack = {
+        id: 2,
+        // Default audio track ID
+        type: "audio",
+        codec: this.config.audio.codec,
+        sampleRate: this.config.audio.sampleRate,
+        channelCount: this.config.audio.channelCount,
+        timescale: this.config.audio.sampleRate,
+        codecConfig: this.config.audio.description
+      };
+      this.addTrack(audioTrack);
+    }
+  }
+  addTrack(track) {
+    if (!this.mp4boxFile) {
+      throw new Error("Muxer destroyed");
+    }
+    this.tracks.set(track.id, track);
+    const trackOptions = track.type === "video" ? this.createVideoTrackOptions(track) : this.createAudioTrackOptions(track);
+    const mp4TrackId = this.mp4boxFile.addTrack(trackOptions);
+    this.mp4Tracks.set(track.id, mp4TrackId);
+    if (this.config.mp4?.fragmented) {
+      this.configureFragmentedTrack(mp4TrackId, track);
+    }
+    return track.id;
+  }
+  configureFragmentedTrack(mp4TrackId, track) {
+    const fragmentDuration = this.config.mp4?.fragmentDuration || 1e6;
+    let nbSamples;
+    if (track.type === "video") {
+      const frameRate = track.frameRate || 30;
+      const fragmentDurationInSeconds = fragmentDuration / 1e6;
+      nbSamples = Math.ceil(fragmentDurationInSeconds * frameRate);
+    } else {
+      const sampleRate = track.sampleRate || 48e3;
+      const fragmentDurationInSeconds = fragmentDuration / 1e6;
+      const framesPerSecond = sampleRate / 1024;
+      nbSamples = Math.ceil(fragmentDurationInSeconds * framesPerSecond);
+    }
+    this.mp4boxFile.setSegmentOptions(mp4TrackId, null, {
+      nbSamples,
+      rapAlignement: true
+      // Align segments to keyframes for proper seeking
+    });
+  }
+  createVideoTrackOptions(track) {
+    const options = {
+      timescale: track.timescale || calculateTimescale(track.frameRate),
+      type: "video",
+      nb_samples: 0,
+      width: track.width,
+      height: track.height
+    };
+    const codecInfo = parseCodecString(track.codec);
+    switch (codecInfo.codec) {
+      case "avc1":
+        options.codec = "avc1";
+        options.avcDecoderConfigRecord = track.codecConfig;
+        break;
+      case "hev1":
+      case "hvc1":
+        options.codec = "hvc1";
+        options.hvcDecoderConfigRecord = track.codecConfig;
+        break;
+      case "av01":
+        options.codec = "av01";
+        options.av1DecoderConfigRecord = track.codecConfig;
+        break;
+      case "vp09":
+        options.codec = "vp09";
+        break;
+      default:
+        throw new Error(`Unsupported video codec: ${track.codec}`);
+    }
+    return options;
+  }
+  createAudioTrackOptions(track) {
+    const options = {
+      timescale: track.timescale || track.sampleRate || 48e3,
+      type: "audio",
+      nb_samples: 0,
+      channel_count: track.channelCount,
+      samplerate: track.sampleRate,
+      hdlr: "soun",
+      name: "SoundHandler"
+    };
+    const codecInfo = parseCodecString(track.codec);
+    switch (codecInfo.codec) {
+      case "mp4a":
+        options.codec = "mp4a.40.2";
+        options.audioDecoderConfig = track.codecConfig;
+        break;
+      case "opus":
+        options.codec = "Opus";
+        options.opusDecoderConfig = track.codecConfig;
+        break;
+      case "mp3":
+        options.codec = "mp3";
+        break;
+      case "ac-3":
+        options.codec = "ac-3";
+        break;
+      case "ec-3":
+        options.codec = "ec-3";
+        break;
+      default:
+        throw new Error(`Unsupported audio codec: ${track.codec}`);
+    }
+    return options;
+  }
+  /**
+   * Write video chunk to muxer
+   */
+  writeVideoChunk(chunk, trackId = 1) {
+    const mp4TrackId = this.mp4Tracks.get(trackId);
+    if (!mp4TrackId) {
+      throw new Error(`Track ${trackId} not found`);
+    }
+    const track = this.tracks.get(trackId);
+    if (!track) {
+      throw new Error(`Track info for ${trackId} not found`);
+    }
+    const data = new Uint8Array(chunk.byteLength);
+    chunk.copyTo(data);
+    const pts = usToTimescale(chunk.timestamp, track.timescale);
+    const dts = chunk.timestamp !== void 0 ? usToTimescale(chunk.timestamp, track.timescale) : pts;
+    const duration = usToTimescale(chunk.duration || 0, track.timescale);
+    const mp4Sample = {
+      data,
+      pts,
+      dts,
+      duration,
+      is_sync: chunk.type === "key"
+    };
+    this.mp4boxFile.addSample(mp4TrackId, data, mp4Sample);
+  }
+  /**
+   * Write audio chunk to muxer
+   */
+  writeAudioChunk(chunk, trackId = 2) {
+    const mp4TrackId = this.mp4Tracks.get(trackId);
+    if (!mp4TrackId) {
+      throw new Error(`Track ${trackId} not found`);
+    }
+    const track = this.tracks.get(trackId);
+    if (!track) {
+      throw new Error(`Track info for ${trackId} not found`);
+    }
+    const data = new Uint8Array(chunk.byteLength);
+    chunk.copyTo(data);
+    const pts = usToTimescale(chunk.timestamp, track.timescale);
+    const duration = usToTimescale(chunk.duration || 0, track.timescale);
+    const mp4Sample = {
+      data,
+      pts,
+      dts: pts,
+      duration,
+      is_sync: true
+      // Audio chunks are always sync samples
+    };
+    this.mp4boxFile.addSample(mp4TrackId, data, mp4Sample);
+  }
+  /**
+   * Flush pending samples
+   */
+  flush() {
+    if (this.mp4boxFile) {
+      this.mp4boxFile.flush();
+    }
+  }
+  /**
+   * Finalize and get the output
+   */
+  finalize() {
+    if (this.isFinalized) {
+      throw new Error("Muxer already finalized");
+    }
+    if (!this.mp4boxFile) {
+      throw new Error("Muxer destroyed");
+    }
+    this.flush();
+    if (!this.config.mp4?.fragmented) {
+      this.mp4boxFile.close();
+    }
+    this.isFinalized = true;
+    return new Blob(this.outputChunks, { type: "video/mp4" });
+  }
+  /**
+   * Clear output chunks (after they've been consumed)
+   */
+  clearOutputChunks() {
+    this.outputChunks = [];
+  }
+  destroy() {
+    this.mp4boxFile?.stop?.();
+    this.mp4boxFile = null;
+    this.tracks.clear();
+    this.mp4Tracks.clear();
+    this.outputChunks = [];
+  }
+}
+export {
+  MP4Muxer
+};
+//# sourceMappingURL=MP4Muxer.js.map

package/dist/stages/mux/MP4Muxer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MP4Muxer.js","sources":["../../../src/stages/mux/MP4Muxer.ts"],"sourcesContent":["// @ts-ignore - mp4box doesn't have proper TypeScript definitions\nimport * as MP4Box from 'mp4box';\nimport type { MuxConfig, MuxTrack } from './types';\nimport { usToTimescale, calculateTimescale, parseCodecString } from './utils';\n\ninterface MP4TrackOptions {\n  timescale: number;\n  type: string;\n  nb_samples: number;\n  width?: number;\n  height?: number;\n  channel_count?: number;\n  samplerate?: number;\n  hdlr?: string;\n  name?: string;\n  codec?: string;\n  avcDecoderConfigRecord?: Uint8Array;\n  hvcDecoderConfigRecord?: Uint8Array;\n  av1DecoderConfigRecord?: Uint8Array;\n  audioDecoderConfig?: Uint8Array;\n  opusDecoderConfig?: Uint8Array;\n}\n\n/**\n * MP4 Muxer - Multiplex encoded chunks into MP4 container\n * Terminal stage that consumes encoded chunks and produces MP4 file\n */\nexport class MP4Muxer {\n  private mp4boxFile: any;\n  tracks = new Map<number, MuxTrack>();\n  private mp4Tracks = new Map<number, number>(); // muxTrackId -> mp4boxTrackId\n\n  // Expose output chunks directly instead of getter\n  outputChunks: Uint8Array[] = [];\n\n  // Expose total bytes written as computed property\n  get totalBytesWritten(): number {\n    return this.outputChunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);\n  }\n\n  // Expose finalized state\n  isFinalized = false;\n\n  private config: MuxConfig;\n\n  constructor(config: MuxConfig = { container: 'mp4' }) {\n    this.config = config;\n    this.mp4boxFile = MP4Box.createFile();\n    this.setupHandlers();\n    this.initializeTracks();\n  }\n\n  private setupHandlers(): void {\n    this.mp4boxFile.onError = (error: string) => {\n      console.error('MP4Box error:', error);\n    };\n\n    // Called when MP4Box has data to write\n    this.mp4boxFile.onSegment = (\n      _id: number,\n      _user: any,\n      buffer: ArrayBuffer,\n      _sampleNumber: number,\n      _last: boolean\n    ) => {\n      const chunk = new Uint8Array(buffer);\n      this.outputChunks.push(chunk);\n    };\n\n    // Handle initialization segment for fragmented MP4\n    if (this.config.mp4?.fragmented) {\n      this.mp4boxFile.onInitSegment = (_tracks: any[]) => {\n        const initSegment = this.mp4boxFile.getInitializationSegment();\n        if (initSegment) {\n          const chunk = new Uint8Array(initSegment);\n          this.outputChunks.push(chunk);\n        }\n      };\n    }\n  }\n\n  private initializeTracks(): void {\n    // Add video track if configured\n    if (this.config.video) {\n      const videoTrack: MuxTrack = {\n        id: 1, // Default video track ID\n        type: 'video',\n        codec: this.config.video.codec,\n        width: this.config.video.width,\n        height: this.config.video.height,\n        frameRate: this.config.video.frameRate,\n        timescale: calculateTimescale(this.config.video.frameRate),\n        codecConfig: this.config.video.description,\n      };\n      this.addTrack(videoTrack);\n    }\n\n    // Add audio track if configured\n    if (this.config.audio) {\n      const audioTrack: MuxTrack = {\n        id: 2, // Default audio track ID\n        type: 'audio',\n        codec: this.config.audio.codec,\n        sampleRate: this.config.audio.sampleRate,\n        channelCount: this.config.audio.channelCount,\n        timescale: this.config.audio.sampleRate,\n        codecConfig: this.config.audio.description,\n      };\n      this.addTrack(audioTrack);\n    }\n  }\n\n  private addTrack(track: MuxTrack): number {\n    if (!this.mp4boxFile) {\n      throw new Error('Muxer destroyed');\n    }\n\n    // Store track info\n    this.tracks.set(track.id, track);\n\n    // Create track options based on type\n    const trackOptions =\n      track.type === 'video'\n        ? this.createVideoTrackOptions(track)\n        : this.createAudioTrackOptions(track);\n\n    // Add track to MP4Box\n    const mp4TrackId = this.mp4boxFile.addTrack(trackOptions);\n    this.mp4Tracks.set(track.id, mp4TrackId);\n\n    // Configure track for fragmented mode if enabled\n    if (this.config.mp4?.fragmented) {\n      this.configureFragmentedTrack(mp4TrackId, track);\n    }\n\n    return track.id;\n  }\n\n  private configureFragmentedTrack(mp4TrackId: number, track: MuxTrack): void {\n    const fragmentDuration = this.config.mp4?.fragmentDuration || 1_000_000; // 1 second default in microseconds\n\n    let nbSamples: number;\n\n    if (track.type === 'video') {\n      // For video: calculate number of frames per fragment based on frame rate\n      // nbSamples = fragment_duration_in_seconds * frame_rate\n      const frameRate = track.frameRate || 30;\n      const fragmentDurationInSeconds = fragmentDuration / 1_000_000;\n      nbSamples = Math.ceil(fragmentDurationInSeconds * frameRate);\n    } else {\n      // For audio: calculate number of samples per fragment\n      // Audio typically has many more samples (e.g., 48000 Hz sample rate)\n      // A reasonable fragment might contain ~1 second of audio samples\n      const sampleRate = track.sampleRate || 48000;\n      const fragmentDurationInSeconds = fragmentDuration / 1_000_000;\n      // For compressed audio (AAC, Opus), each \"sample\" is actually a frame containing multiple PCM samples\n      // AAC frame typically contains 1024 PCM samples, so at 48kHz: 48000/1024 ≈ 47 frames per second\n      const framesPerSecond = sampleRate / 1024; // Assuming AAC-like frame size\n      nbSamples = Math.ceil(fragmentDurationInSeconds * framesPerSecond);\n    }\n\n    /**\n     * setSegmentOptions parameters:\n     * @param trackId - The track ID to configure\n     * @param user - User data (passed to callbacks, we don't use it)\n     * @param options - Segmentation options:\n     *   - nbSamples: Number of samples per segment/fragment\n     *   - rapAlignement: Random Access Point alignment - ensures segments start with keyframes\n     *                    This is critical for seeking and adaptive streaming (HLS/DASH)\n     */\n    this.mp4boxFile.setSegmentOptions(mp4TrackId, null, {\n      nbSamples,\n      rapAlignement: true, // Align segments to keyframes for proper seeking\n    });\n  }\n\n  private createVideoTrackOptions(track: MuxTrack): MP4TrackOptions {\n    const options: MP4TrackOptions = {\n      timescale: track.timescale || calculateTimescale(track.frameRate),\n      type: 'video',\n      nb_samples: 0,\n      width: track.width,\n      height: track.height,\n    };\n\n    // Configure codec-specific options\n    const codecInfo = parseCodecString(track.codec);\n\n    switch (codecInfo.codec) {\n      case 'avc1':\n        options.codec = 'avc1';\n        options.avcDecoderConfigRecord = track.codecConfig;\n        break;\n      case 'hev1':\n      case 'hvc1':\n        options.codec = 'hvc1';\n        options.hvcDecoderConfigRecord = track.codecConfig;\n        break;\n      case 'av01':\n        options.codec = 'av01';\n        options.av1DecoderConfigRecord = track.codecConfig;\n        break;\n      case 'vp09':\n        options.codec = 'vp09';\n        // VP9 specific configuration\n        break;\n      default:\n        throw new Error(`Unsupported video codec: ${track.codec}`);\n    }\n\n    return options;\n  }\n\n  private createAudioTrackOptions(track: MuxTrack): MP4TrackOptions {\n    const options: MP4TrackOptions = {\n      timescale: track.timescale || track.sampleRate || 48000,\n      type: 'audio',\n      nb_samples: 0,\n      channel_count: track.channelCount,\n      samplerate: track.sampleRate,\n      hdlr: 'soun',\n      name: 'SoundHandler',\n    };\n\n    // Configure codec-specific options\n    const codecInfo = parseCodecString(track.codec);\n\n    switch (codecInfo.codec) {\n      case 'mp4a':\n        options.codec = 'mp4a.40.2'; // AAC-LC\n        options.audioDecoderConfig = track.codecConfig;\n        break;\n      case 'opus':\n        options.codec = 'Opus';\n        options.opusDecoderConfig = track.codecConfig;\n        break;\n      case 'mp3':\n        options.codec = 'mp3';\n        break;\n      case 'ac-3':\n        options.codec = 'ac-3';\n        break;\n      case 'ec-3':\n        options.codec = 'ec-3';\n        break;\n      default:\n        throw new Error(`Unsupported audio codec: ${track.codec}`);\n    }\n\n    return options;\n  }\n\n  /**\n   * Write video chunk to muxer\n   */\n  writeVideoChunk(chunk: EncodedVideoChunk, trackId: number = 1): void {\n    const mp4TrackId = this.mp4Tracks.get(trackId);\n    if (!mp4TrackId) {\n      throw new Error(`Track ${trackId} not found`);\n    }\n\n    const track = this.tracks.get(trackId);\n    if (!track) {\n      throw new Error(`Track info for ${trackId} not found`);\n    }\n\n    // Create buffer for chunk data\n    const data = new Uint8Array(chunk.byteLength);\n    chunk.copyTo(data);\n\n    // Convert timestamps to timescale units\n    const pts = usToTimescale(chunk.timestamp, track.timescale);\n    const dts =\n      chunk.timestamp !== undefined ? usToTimescale(chunk.timestamp, track.timescale) : pts;\n    const duration = usToTimescale(chunk.duration || 0, track.timescale);\n\n    // Create MP4Box sample\n    const mp4Sample: any = {\n      data: data,\n      pts: pts,\n      dts: dts,\n      duration: duration,\n      is_sync: chunk.type === 'key',\n    };\n\n    // Add sample to track\n    this.mp4boxFile.addSample(mp4TrackId, data, mp4Sample);\n  }\n\n  /**\n   * Write audio chunk to muxer\n   */\n  writeAudioChunk(chunk: EncodedAudioChunk, trackId: number = 2): void {\n    const mp4TrackId = this.mp4Tracks.get(trackId);\n    if (!mp4TrackId) {\n      throw new Error(`Track ${trackId} not found`);\n    }\n\n    const track = this.tracks.get(trackId);\n    if (!track) {\n      throw new Error(`Track info for ${trackId} not found`);\n    }\n\n    // Create buffer for chunk data\n    const data = new Uint8Array(chunk.byteLength);\n    chunk.copyTo(data);\n\n    // Convert timestamps to timescale units\n    const pts = usToTimescale(chunk.timestamp, track.timescale);\n    const duration = usToTimescale(chunk.duration || 0, track.timescale);\n\n    // Create MP4Box sample\n    const mp4Sample: any = {\n      data: data,\n      pts: pts,\n      dts: pts,\n      duration: duration,\n      is_sync: true, // Audio chunks are always sync samples\n    };\n\n    // Add sample to track\n    this.mp4boxFile.addSample(mp4TrackId, data, mp4Sample);\n  }\n\n  /**\n   * Flush pending samples\n   */\n  flush(): void {\n    if (this.mp4boxFile) {\n      this.mp4boxFile.flush();\n    }\n  }\n\n  /**\n   * Finalize and get the output\n   */\n  finalize(): Blob {\n    if (this.isFinalized) {\n      throw new Error('Muxer already finalized');\n    }\n\n    if (!this.mp4boxFile) {\n      throw new Error('Muxer destroyed');\n    }\n\n    // Flush any remaining samples\n    this.flush();\n\n    // For non-fragmented mode, close to write moov box\n    if (!this.config.mp4?.fragmented) {\n      this.mp4boxFile.close();\n    }\n\n    this.isFinalized = true;\n\n    // Return the muxed MP4 as a Blob\n    return new Blob(this.outputChunks as BlobPart[], { type: 'video/mp4' });\n  }\n\n  /**\n   * Clear output chunks (after they've been consumed)\n   */\n  clearOutputChunks(): void {\n    this.outputChunks = [];\n  }\n\n  destroy(): void {\n    this.mp4boxFile?.stop?.();\n    this.mp4boxFile = null;\n    this.tracks.clear();\n    this.mp4Tracks.clear();\n    this.outputChunks = [];\n  }\n}\n"],"names":["MP4Box.createFile"],"mappings":"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"}

package/dist/stages/mux/OPFSWriter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * OPFS (Origin Private File System) Writer
+ * Provides streaming file writing capabilities for large media files
+ */
+export declare class OPFSWriter {
+    private fileHandle;
+    private writable;
+    private bytesWritten;
+    /**
+     * Open or create a file in OPFS
+     * @param filePath - Path relative to OPFS root (e.g., "exports/video.mp4")
+     */
+    open(filePath: string): Promise<void>;
+    /**
+     * Write data to the file
+     */
+    write(data: Uint8Array): Promise<void>;
+    /**
+     * Write multiple chunks efficiently
+     */
+    writeChunks(chunks: Uint8Array[]): Promise<void>;
+    /**
+     * Close the file and finalize writing
+     */
+    close(): Promise<FileSystemFileHandle>;
+    /**
+     * Get current file size
+     */
+    get totalBytesWritten(): number;
+    /**
+     * Check if OPFS is supported
+     */
+    static isSupported(): boolean;
+    /**
+     * Get available storage quota
+     */
+    static getQuota(): Promise<{
+        usage: number;
+        quota: number;
+    }>;
+    /**
+     * Clean up old files in a directory
+     */
+    static cleanupDirectory(dirPath: string, keepCount?: number): Promise<void>;
+}
+//# sourceMappingURL=OPFSWriter.d.ts.map

package/dist/stages/mux/OPFSWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OPFSWriter.d.ts","sourceRoot":"","sources":["../../../src/stages/mux/OPFSWriter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAqC;IACvD,OAAO,CAAC,QAAQ,CAA6C;IAC7D,OAAO,CAAC,YAAY,CAAK;IAEzB;;;OAGG;IACG,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B3C;;OAEG;IACG,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAS5C;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAMtD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAc5C;;OAEG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;IAED;;OAEG;IACH,MAAM,CAAC,WAAW,IAAI,OAAO;IAI7B;;OAEG;WACU,QAAQ,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAWlE;;OAEG;WACU,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,GAAE,MAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAqCrF"}

package/dist/stages/mux/index.d.ts

@@ -0,0 +1,5 @@
+export { MP4Muxer } from './MP4Muxer';
+export { OPFSWriter } from './OPFSWriter';
+export * from './types';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/stages/mux/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/stages/mux/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/dist/stages/mux/mux.worker.d.ts

@@ -0,0 +1,65 @@
+/**
+ * MuxWorker - Final stage for video/audio multiplexing
+ * Combines encoded video and audio tracks into container format (MP4)
+ *
+ * Pipeline: CacheManager → MuxWorker → Export (Blob/OPFS)
+ *
+ * Features:
+ * - MP4 container muxing with mp4box.js
+ * - Stream-based processing from L2 cache
+ * - Support for fragmented MP4 (fMP4) for streaming
+ * - Direct blob output for download
+ */
+export declare class MuxWorkerImpl {
+    private channel;
+    private muxer;
+    private config;
+    constructor();
+    private setupHandlers;
+    /**
+     * Unified connect handler used by stream pipeline
+     */
+    private handleUnifiedConnect;
+    /**
+     * Connect to encoder worker to receive encoded chunks
+     */
+    /**
+     * Configure muxer with container settings
+     * @param payload.config - Muxer configuration including tracks and output format
+     * @param payload.initial - If true, initialize worker state; otherwise just update config
+     */
+    private handleConfigure;
+    /**
+     * Write single video chunk
+     */
+    private handleWriteVideoChunk;
+    /**
+     * Write single audio chunk
+     */
+    private handleWriteAudioChunk;
+    /**
+     * Handle input stream from CacheManager (L2 encoded chunks)
+     * This is the main export path where CacheManager sends encoded chunks
+     */
+    private handleInputStream;
+    /**
+     * Flush pending samples
+     */
+    private handleFlush;
+    /**
+     * Finalize muxing and get output
+     * This completes the export process
+     */
+    private handleFinalize;
+    /**
+     * Get muxer statistics
+     */
+    private handleGetStats;
+    /**
+     * Dispose worker and cleanup resources
+     */
+    private handleDispose;
+}
+declare const _default: null;
+export default _default;
+//# sourceMappingURL=mux.worker.d.ts.map

package/dist/stages/mux/mux.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mux.worker.d.ts","sourceRoot":"","sources":["../../../src/stages/mux/mux.worker.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,MAAM,CAA0B;;IAYxC,OAAO,CAAC,aAAa;IAiBrB;;OAEG;YACW,oBAAoB;IASlC;;OAEG;IAUH;;;;OAIG;YACW,eAAe;IAsD7B;;OAEG;YACW,qBAAqB;IAgBnC;;OAEG;YACW,qBAAqB;IAgBnC;;;OAGG;YACW,iBAAiB;IAwD/B;;OAEG;YACW,WAAW;IAYzB;;;OAGG;YACW,cAAc;IA2B5B;;OAEG;YACW,cAAc;IAkB5B;;OAEG;YACW,aAAa;CAU5B;;AAUD,wBAAoB"}

package/dist/stages/mux/mux.worker.js

@@ -0,0 +1,219 @@
+import { WorkerChannel } from "../../worker/WorkerChannel.js";
+import { WorkerMessageType, WorkerState } from "../../worker/types.js";
+import { MP4Muxer } from "./MP4Muxer.js";
+class MuxWorkerImpl {
+  channel;
+  muxer = null;
+  config = null;
+  constructor() {
+    this.channel = new WorkerChannel(self, {
+      name: "MuxWorker",
+      timeout: 6e4
+      // 60s for export operations
+    });
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.channel.registerHandler("configure", this.handleConfigure.bind(this));
+    this.channel.registerHandler("connect", this.handleUnifiedConnect.bind(this));
+    this.channel.registerHandler("write_video_chunk", this.handleWriteVideoChunk.bind(this));
+    this.channel.registerHandler("write_audio_chunk", this.handleWriteAudioChunk.bind(this));
+    this.channel.registerHandler("flush", this.handleFlush.bind(this));
+    this.channel.registerHandler("finalize", this.handleFinalize.bind(this));
+    this.channel.registerHandler("get_stats", this.handleGetStats.bind(this));
+    this.channel.registerHandler(WorkerMessageType.Dispose, this.handleDispose.bind(this));
+    this.channel.receiveStream(this.handleInputStream.bind(this));
+  }
+  /**
+   * Unified connect handler used by stream pipeline
+   */
+  async handleUnifiedConnect(_payload) {
+    return { success: true };
+  }
+  /**
+   * Connect to encoder worker to receive encoded chunks
+   */
+  // private async handleConnectEncoder(_payload: {
+  //   port: MessagePort;
+  // }): Promise<{ success: boolean }> {
+  //   // Store the port for receiving encoded chunks
+  //   // The actual stream handling is done via receiveStream in handleInputStream
+  //   // This connection allows direct communication with the encoder worker
+  //   return { success: true };
+  // }
+  /**
+   * Configure muxer with container settings
+   * @param payload.config - Muxer configuration including tracks and output format
+   * @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.muxer) {
+          this.muxer.destroy();
+        }
+        this.config = config;
+        this.muxer = new MP4Muxer(config);
+        const trackCount = (config.video ? 1 : 0) + (config.audio ? 1 : 0);
+        this.channel.notify("configured", {
+          container: config.container,
+          hasVideo: !!config.video,
+          hasAudio: !!config.audio,
+          fragmented: !!config.mp4?.fragmented,
+          trackCount
+        });
+        return { success: true, tracks: trackCount };
+      } else {
+        if (!this.muxer) {
+          throw {
+            code: "NOT_INITIALIZED",
+            message: "Muxer not initialized. Call configure with initial=true first"
+          };
+        }
+        this.config = { ...this.config, ...config };
+        return { success: true };
+      }
+    } catch (error) {
+      throw {
+        code: error.code || "CONFIG_ERROR",
+        message: error.message
+      };
+    }
+  }
+  /**
+   * Write single video chunk
+   */
+  async handleWriteVideoChunk(payload) {
+    if (!this.muxer) {
+      throw {
+        code: "NOT_INITIALIZED",
+        message: "Muxer not initialized"
+      };
+    }
+    this.muxer.writeVideoChunk(payload.chunk, payload.trackId);
+    return { bytesWritten: this.muxer.totalBytesWritten };
+  }
+  /**
+   * Write single audio chunk
+   */
+  async handleWriteAudioChunk(payload) {
+    if (!this.muxer) {
+      throw {
+        code: "NOT_INITIALIZED",
+        message: "Muxer not initialized"
+      };
+    }
+    this.muxer.writeAudioChunk(payload.chunk, payload.trackId);
+    return { bytesWritten: this.muxer.totalBytesWritten };
+  }
+  /**
+   * Handle input stream from CacheManager (L2 encoded chunks)
+   * This is the main export path where CacheManager sends encoded chunks
+   */
+  async handleInputStream(stream, metadata) {
+    if (!this.muxer) {
+      throw new Error("Muxer not configured");
+    }
+    const reader = stream.getReader();
+    let chunksProcessed = 0;
+    try {
+      this.channel.state = WorkerState.Processing;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const isVideoChunk = metadata?.type === "video" || value.type === "key" || value.type === "delta";
+        if (isVideoChunk) {
+          this.muxer.writeVideoChunk(value, metadata?.trackId || 1);
+        } else {
+          this.muxer.writeAudioChunk(value, metadata?.trackId || 2);
+        }
+        chunksProcessed++;
+        if (chunksProcessed % 100 === 0) {
+          this.channel.notify("mux_progress", {
+            chunksProcessed,
+            bytesWritten: this.muxer.totalBytesWritten
+          });
+        }
+      }
+      this.muxer.flush();
+      this.channel.state = WorkerState.Ready;
+      this.channel.notify("mux_complete", {
+        chunksProcessed,
+        bytesWritten: this.muxer.totalBytesWritten
+      });
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Flush pending samples
+   */
+  async handleFlush() {
+    if (!this.muxer) {
+      throw {
+        code: "NOT_INITIALIZED",
+        message: "Muxer not initialized"
+      };
+    }
+    this.muxer.flush();
+    return { success: true };
+  }
+  /**
+   * Finalize muxing and get output
+   * This completes the export process
+   */
+  async handleFinalize() {
+    if (!this.muxer) {
+      throw {
+        code: "NOT_INITIALIZED",
+        message: "Muxer not initialized"
+      };
+    }
+    const blob = this.muxer.finalize();
+    this.channel.notify("export_done", {
+      blob,
+      totalBytes: blob.size
+    });
+    return {
+      success: true,
+      blob,
+      totalBytes: blob.size
+    };
+  }
+  /**
+   * Get muxer statistics
+   */
+  async handleGetStats() {
+    if (!this.muxer) {
+      return { state: this.channel.state };
+    }
+    return {
+      bytesWritten: this.muxer.totalBytesWritten,
+      chunksCount: this.muxer.outputChunks.length,
+      isFinalized: this.muxer.isFinalized,
+      state: this.channel.state
+    };
+  }
+  /**
+   * Dispose worker and cleanup resources
+   */
+  async handleDispose() {
+    this.muxer?.destroy();
+    this.muxer = null;
+    this.config = null;
+    this.channel.state = WorkerState.Disposed;
+    return { success: true };
+  }
+}
+const worker = new MuxWorkerImpl();
+self.addEventListener("beforeunload", () => {
+  worker["handleDispose"]();
+});
+const mux_worker = null;
+export {
+  MuxWorkerImpl,
+  mux_worker as default
+};
+//# sourceMappingURL=mux.worker.js.map

package/dist/stages/mux/mux.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mux.worker.js","sources":["../../../src/stages/mux/mux.worker.ts"],"sourcesContent":["import { WorkerChannel } from '../../worker/WorkerChannel';\nimport { WorkerMessageType, WorkerState } from '../../worker/types';\nimport { MP4Muxer } from './MP4Muxer';\nimport type { MuxConfig } from './types';\n\n/**\n * MuxWorker - Final stage for video/audio multiplexing\n * Combines encoded video and audio tracks into container format (MP4)\n *\n * Pipeline: CacheManager → MuxWorker → Export (Blob/OPFS)\n *\n * Features:\n * - MP4 container muxing with mp4box.js\n * - Stream-based processing from L2 cache\n * - Support for fragmented MP4 (fMP4) for streaming\n * - Direct blob output for download\n */\nexport class MuxWorkerImpl {\n  private channel: WorkerChannel;\n  private muxer: MP4Muxer | null = null;\n  private config: MuxConfig | null = null;\n\n  constructor() {\n    // Initialize WorkerChannel\n    this.channel = new WorkerChannel(self as any, {\n      name: 'MuxWorker',\n      timeout: 60000, // 60s for export operations\n    });\n\n    this.setupHandlers();\n  }\n\n  private setupHandlers(): void {\n    // Register message handlers\n    this.channel.registerHandler('configure', this.handleConfigure.bind(this));\n    // Unified stream connect (feature-flagged)\n    this.channel.registerHandler('connect' as any, this.handleUnifiedConnect.bind(this));\n    // Unified stream connect only\n    this.channel.registerHandler('write_video_chunk', this.handleWriteVideoChunk.bind(this));\n    this.channel.registerHandler('write_audio_chunk', this.handleWriteAudioChunk.bind(this));\n    this.channel.registerHandler('flush', this.handleFlush.bind(this));\n    this.channel.registerHandler('finalize', this.handleFinalize.bind(this));\n    this.channel.registerHandler('get_stats', this.handleGetStats.bind(this));\n    this.channel.registerHandler(WorkerMessageType.Dispose, this.handleDispose.bind(this));\n\n    // Setup stream receiver from CacheManager (L2 encoded chunks)\n    this.channel.receiveStream(this.handleInputStream.bind(this));\n  }\n\n  /**\n   * Unified connect handler used by stream pipeline\n   */\n  private async handleUnifiedConnect(_payload: {\n    direction: 'upstream';\n    port: MessagePort;\n    streamType: 'video' | 'audio' | 'frame' | 'chunk';\n  }): Promise<{ success: boolean }> {\n    // Mux receives encoded chunks via receiveStream already\n    return { success: true };\n  }\n\n  /**\n   * Connect to encoder worker to receive encoded chunks\n   */\n  // private async handleConnectEncoder(_payload: {\n  //   port: MessagePort;\n  // }): Promise<{ success: boolean }> {\n  //   // Store the port for receiving encoded chunks\n  //   // The actual stream handling is done via receiveStream in handleInputStream\n  //   // This connection allows direct communication with the encoder worker\n  //   return { success: true };\n  // }\n\n  /**\n   * Configure muxer with container settings\n   * @param payload.config - Muxer configuration including tracks and output format\n   * @param payload.initial - If true, initialize worker state; otherwise just update config\n   */\n  private async handleConfigure(payload: {\n    config: MuxConfig;\n    initial?: boolean;\n  }): Promise<{ success: boolean; tracks?: number }> {\n    const { config, initial = false } = payload;\n\n    try {\n      if (initial) {\n        // Initial setup - set worker state to ready\n        this.channel.state = WorkerState.Ready;\n\n        // Create new muxer instance\n        if (this.muxer) {\n          this.muxer.destroy();\n        }\n\n        this.config = config;\n        this.muxer = new MP4Muxer(config);\n\n        const trackCount = (config.video ? 1 : 0) + (config.audio ? 1 : 0);\n\n        // Notify configuration complete\n        this.channel.notify('configured', {\n          container: config.container,\n          hasVideo: !!config.video,\n          hasAudio: !!config.audio,\n          fragmented: !!config.mp4?.fragmented,\n          trackCount,\n        });\n\n        return { success: true, tracks: trackCount };\n      } else {\n        // Update configuration only\n        if (!this.muxer) {\n          throw {\n            code: 'NOT_INITIALIZED',\n            message: 'Muxer not initialized. Call configure with initial=true first',\n          };\n        }\n\n        // MP4Muxer doesn't support runtime config updates\n        // Would need to recreate for changes\n        this.config = { ...this.config, ...config };\n\n        return { success: true };\n      }\n    } catch (error: any) {\n      throw {\n        code: error.code || 'CONFIG_ERROR',\n        message: error.message,\n      };\n    }\n  }\n\n  /**\n   * Write single video chunk\n   */\n  private async handleWriteVideoChunk(payload: {\n    chunk: EncodedVideoChunk;\n    trackId?: number;\n  }): Promise<{ bytesWritten: number }> {\n    if (!this.muxer) {\n      throw {\n        code: 'NOT_INITIALIZED',\n        message: 'Muxer not initialized',\n      };\n    }\n\n    this.muxer.writeVideoChunk(payload.chunk, payload.trackId);\n\n    return { bytesWritten: this.muxer.totalBytesWritten };\n  }\n\n  /**\n   * Write single audio chunk\n   */\n  private async handleWriteAudioChunk(payload: {\n    chunk: EncodedAudioChunk;\n    trackId?: number;\n  }): Promise<{ bytesWritten: number }> {\n    if (!this.muxer) {\n      throw {\n        code: 'NOT_INITIALIZED',\n        message: 'Muxer not initialized',\n      };\n    }\n\n    this.muxer.writeAudioChunk(payload.chunk, payload.trackId);\n\n    return { bytesWritten: this.muxer.totalBytesWritten };\n  }\n\n  /**\n   * Handle input stream from CacheManager (L2 encoded chunks)\n   * This is the main export path where CacheManager sends encoded chunks\n   */\n  private async handleInputStream(\n    stream: ReadableStream<EncodedVideoChunk | EncodedAudioChunk>,\n    metadata?: Record<string, any>\n  ): Promise<void> {\n    if (!this.muxer) {\n      throw new Error('Muxer not configured');\n    }\n\n    const reader = stream.getReader();\n    let chunksProcessed = 0;\n\n    try {\n      this.channel.state = WorkerState.Processing;\n\n      while (true) {\n        const { done, value } = await reader.read();\n        if (done) break;\n\n        // Determine chunk type and write accordingly\n        const isVideoChunk =\n          metadata?.type === 'video' ||\n          (value as any).type === 'key' ||\n          (value as any).type === 'delta';\n\n        if (isVideoChunk) {\n          this.muxer.writeVideoChunk(value as EncodedVideoChunk, metadata?.trackId || 1);\n        } else {\n          this.muxer.writeAudioChunk(value as EncodedAudioChunk, metadata?.trackId || 2);\n        }\n\n        chunksProcessed++;\n\n        // Report progress periodically\n        if (chunksProcessed % 100 === 0) {\n          this.channel.notify('mux_progress', {\n            chunksProcessed,\n            bytesWritten: this.muxer.totalBytesWritten,\n          });\n        }\n      }\n\n      // Flush after stream processing\n      this.muxer.flush();\n\n      this.channel.state = WorkerState.Ready;\n\n      // Notify muxing complete\n      this.channel.notify('mux_complete', {\n        chunksProcessed,\n        bytesWritten: this.muxer.totalBytesWritten,\n      });\n    } finally {\n      reader.releaseLock();\n    }\n  }\n\n  /**\n   * Flush pending samples\n   */\n  private async handleFlush(): Promise<{ success: boolean }> {\n    if (!this.muxer) {\n      throw {\n        code: 'NOT_INITIALIZED',\n        message: 'Muxer not initialized',\n      };\n    }\n\n    this.muxer.flush();\n    return { success: true };\n  }\n\n  /**\n   * Finalize muxing and get output\n   * This completes the export process\n   */\n  private async handleFinalize(): Promise<{\n    success: boolean;\n    blob: Blob;\n    totalBytes: number;\n  }> {\n    if (!this.muxer) {\n      throw {\n        code: 'NOT_INITIALIZED',\n        message: 'Muxer not initialized',\n      };\n    }\n\n    const blob = this.muxer.finalize();\n\n    // Notify export completion as per architecture doc\n    this.channel.notify('export_done', {\n      blob,\n      totalBytes: blob.size,\n    });\n\n    return {\n      success: true,\n      blob,\n      totalBytes: blob.size,\n    };\n  }\n\n  /**\n   * Get muxer statistics\n   */\n  private async handleGetStats(): Promise<{\n    bytesWritten?: number;\n    chunksCount?: number;\n    isFinalized?: boolean;\n    state?: WorkerState;\n  }> {\n    if (!this.muxer) {\n      return { state: this.channel.state };\n    }\n\n    return {\n      bytesWritten: this.muxer.totalBytesWritten,\n      chunksCount: this.muxer.outputChunks.length,\n      isFinalized: this.muxer.isFinalized,\n      state: this.channel.state,\n    };\n  }\n\n  /**\n   * Dispose worker and cleanup resources\n   */\n  private async handleDispose(): Promise<{ success: boolean }> {\n    // Destroy muxer\n    this.muxer?.destroy();\n    this.muxer = null;\n    this.config = null;\n\n    this.channel.state = WorkerState.Disposed;\n\n    return { success: true };\n  }\n}\n\n// Initialize worker\nconst worker = new MuxWorkerImpl();\n\n// Handle worker termination\nself.addEventListener('beforeunload', () => {\n  worker['handleDispose']();\n});\n\nexport default null; // Required for TypeScript worker compilation\n"],"names":[],"mappings":"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"}