@meframe/core 0.0.1

package/dist/stages/demux/audio-demux.worker.js

@@ -0,0 +1,312 @@
+import { WorkerChannel } from "../../worker/WorkerChannel.js";
+import { WorkerMessageType, WorkerState } from "../../worker/types.js";
+import { MP4Demuxer } from "./MP4Demuxer.js";
+import { MP3FrameParser } from "./MP3FrameParser.js";
+class AudioDemuxWorker {
+  channel;
+  demuxer = null;
+  audioStream = null;
+  mp3Parser = null;
+  currentFormat = null;
+  // Connection to decoder worker
+  decoderPort = null;
+  constructor() {
+    this.channel = new WorkerChannel(self, {
+      name: "AudioDemuxWorker",
+      timeout: 3e4
+    });
+    this.setupHandlers();
+  }
+  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.handleInputStream.bind(this));
+  }
+  /**
+   * Unified connect handler used by stream pipeline
+   */
+  async handleConnect(payload) {
+    this.decoderPort = payload.port;
+    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;
+        const format = config.container || this.detectFormat(config);
+        if (format === "mp3") {
+          this.mp3Parser = new MP3FrameParser();
+          this.demuxer?.destroy();
+          this.demuxer = null;
+          this.audioStream = null;
+          this.currentFormat = "mp3";
+          const mp3Track = { id: 1, type: "audio", codec: "mp3" };
+          this.channel.notify("configured", {
+            tracks: [mp3Track],
+            format,
+            codec: "mp3"
+          });
+          return { success: true, tracks: [mp3Track] };
+        } else if (format === "mp4" || format === "m4a") {
+          if (this.demuxer) {
+            this.demuxer.destroy();
+          }
+          this.demuxer = new MP4Demuxer({
+            ...config,
+            skipVideo: true
+            // Audio only
+          });
+          this.audioStream = this.demuxer.createAudioStream();
+          this.mp3Parser = null;
+          this.currentFormat = "mp4";
+        } else {
+          throw {
+            code: "UNSUPPORTED_FORMAT",
+            message: `Unsupported audio format: ${format}`
+          };
+        }
+        if (!this.audioStream) {
+          throw {
+            code: "NO_AUDIO_TRACK",
+            message: "No audio track found in container"
+          };
+        }
+        const tracks = Array.from(this.demuxer.tracks.values());
+        this.channel.notify("configured", {
+          tracks,
+          format,
+          codec: tracks[0]?.codec
+        });
+        return { success: true, tracks };
+      } else {
+        if (!this.demuxer) {
+          throw {
+            code: "NOT_INITIALIZED",
+            message: "Demuxer not initialized. Call configure with initial=true first"
+          };
+        }
+        return { success: true };
+      }
+    } catch (error) {
+      throw {
+        code: error.code || "CONFIG_ERROR",
+        message: error.message
+      };
+    }
+  }
+  /**
+   * Detect audio format from configuration
+   */
+  detectFormat(config) {
+    if (config.codec?.includes("mp3")) return "mp3";
+    if (config.codec?.includes("aac")) return "mp4";
+    if (config.codec?.includes("opus")) return "webm";
+    return "mp3";
+  }
+  /**
+   * Handle input stream from ResourceLoader (main thread)
+   */
+  async handleInputStream(stream, metadata) {
+    if (this.currentFormat === "mp3" && !this.mp3Parser) {
+      this.mp3Parser = new MP3FrameParser();
+    }
+    if (this.currentFormat === "mp4" && (!this.demuxer || !this.audioStream)) {
+      await this.handleConfigure({
+        config: { container: "mp4", highWaterMark: 10 },
+        initial: true
+      });
+    }
+    if (!this.decoderPort) {
+      throw new Error("Decoder not connected");
+    }
+    const decoderChannel = new WorkerChannel(this.decoderPort, {
+      name: "AudioDemux-Decoder",
+      timeout: 3e4
+    });
+    if (this.currentFormat === "mp3") {
+      await this.pipeMp3Stream(stream, decoderChannel, metadata);
+    } else if (this.demuxer && this.audioStream) {
+      const transformed = stream.pipeThrough(this.audioStream);
+      const trackInfo = Array.from(this.demuxer.tracks.values())[0];
+      await decoderChannel.sendStream(transformed, {
+        streamType: "audio",
+        clipId: metadata?.clipId ?? "default",
+        trackId: metadata?.trackId ?? "main",
+        codec: trackInfo?.codec ?? "mp4a.40.2",
+        sampleRate: trackInfo?.sampleRate ?? 44100,
+        numberOfChannels: trackInfo?.numberOfChannels ?? 2,
+        description: trackInfo?.description
+      });
+      this.channel.notify("demux_complete", {
+        tracksProcessed: this.demuxer?.tracks.size || 0
+      });
+    } else {
+      throw new Error("Audio demuxer not initialized");
+    }
+  }
+  async pipeMp3Stream(stream, decoderChannel, metadata) {
+    if (!this.mp3Parser) {
+      this.mp3Parser = new MP3FrameParser();
+    }
+    const reader = stream.getReader();
+    let currentConfig = null;
+    let configured = false;
+    const bufferedFrames = [];
+    let writer = null;
+    const ensureWriter = async () => {
+      if (!writer) {
+        const cfg = currentConfig;
+        if (!cfg) {
+          throw new Error("MP3 config missing while creating writer");
+        }
+        const transform = new TransformStream();
+        writer = transform.writable.getWriter();
+        await decoderChannel.sendStream(transform.readable, {
+          streamType: "audio",
+          clipId: metadata?.clipId ?? "default",
+          trackId: metadata?.trackId ?? "main",
+          codec: "mp3",
+          sampleRate: cfg.sampleRate,
+          numberOfChannels: cfg.channels,
+          description: void 0
+        });
+      }
+      return writer;
+    };
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        if (!value) {
+          continue;
+        }
+        const { frames, config } = this.mp3Parser.push(value);
+        if (config) {
+          currentConfig = config;
+        }
+        if (config && !configured) {
+          await decoderChannel.send("configure", {
+            streamType: "audio",
+            clipId: metadata?.clipId ?? "default",
+            codec: "mp3",
+            sampleRate: config.sampleRate,
+            numberOfChannels: config.channels,
+            description: void 0
+          });
+          this.channel.notify("demux_configured", {
+            clipId: metadata?.clipId ?? "default",
+            codec: "mp3",
+            sampleRate: config.sampleRate,
+            numberOfChannels: config.channels
+          });
+          configured = true;
+        }
+        if (config) {
+          this.currentFormat = "mp3";
+        }
+        if (!configured) {
+          bufferedFrames.push(...frames);
+          continue;
+        }
+        const targetWriter = await ensureWriter();
+        const readyFrames = bufferedFrames.splice(0, bufferedFrames.length);
+        readyFrames.push(...frames);
+        for (const frame of readyFrames) {
+          const chunk = new EncodedAudioChunk({
+            type: "key",
+            timestamp: frame.timestampUs,
+            duration: frame.durationUs,
+            data: frame.data.buffer.slice(
+              frame.data.byteOffset,
+              frame.data.byteOffset + frame.data.byteLength
+            )
+          });
+          await targetWriter.write(chunk);
+        }
+      }
+      const remaining = this.mp3Parser.flush();
+      if (remaining.length) {
+        if (!configured) {
+          throw new Error("MP3 stream ended before configuration");
+        }
+        const targetWriter = await ensureWriter();
+        for (const frame of remaining) {
+          const chunk = new EncodedAudioChunk({
+            type: "key",
+            timestamp: frame.timestampUs,
+            duration: frame.durationUs,
+            data: frame.data.buffer.slice(
+              frame.data.byteOffset,
+              frame.data.byteOffset + frame.data.byteLength
+            )
+          });
+          await targetWriter.write(chunk);
+        }
+      }
+      if (writer) {
+        await writer.close();
+      }
+      this.channel.notify("demux_complete", {
+        tracksProcessed: 1
+      });
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Get demuxer statistics
+   */
+  async handleGetStats() {
+    if (this.currentFormat === "mp3") {
+      return {
+        tracksInfo: this.mp3Parser ? [{ id: 1, type: "audio", codec: "mp3" }] : [],
+        format: "mp3",
+        state: this.channel.state
+      };
+    }
+    if (this.demuxer) {
+      return {
+        tracksInfo: Array.from(this.demuxer.tracks.values()),
+        format: "mp4",
+        state: this.channel.state
+      };
+    }
+    return { state: this.channel.state };
+  }
+  /**
+   * Dispose worker and cleanup resources
+   */
+  async handleDispose() {
+    if (this.demuxer) {
+      this.demuxer.destroy();
+    }
+    this.demuxer = null;
+    this.audioStream = null;
+    this.mp3Parser = null;
+    this.currentFormat = null;
+    this.decoderPort?.close();
+    this.decoderPort = null;
+    this.channel.state = WorkerState.Disposed;
+    return { success: true };
+  }
+}
+const worker = new AudioDemuxWorker();
+self.addEventListener("beforeunload", () => {
+  worker["handleDispose"]();
+});
+const audioDemux_worker = null;
+export {
+  AudioDemuxWorker,
+  audioDemux_worker as default
+};
+//# sourceMappingURL=audio-demux.worker.js.map

package/dist/stages/demux/audio-demux.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-demux.worker.js","sources":["../../../src/stages/demux/audio-demux.worker.ts"],"sourcesContent":["import { WorkerChannel } from '../../worker/WorkerChannel';\nimport { WorkerMessageType, WorkerState } from '../../worker/types';\nimport { MP4Demuxer } from './MP4Demuxer';\nimport { MP3FrameParser, type MP3Config, type MP3Frame } from './MP3FrameParser';\nimport type { DemuxConfig } from './types';\n\n/**\n * AudioDemuxWorker - First stage for audio processing\n * Extracts audio tracks from various container formats (MP3, MP4/M4A, etc.)\n *\n * Pipeline: ResourceLoader (Main Thread) → AudioDemuxWorker → DecodeWorker\n *\n * Features:\n * - Multi-format support (MP3, AAC in MP4/M4A)\n * - Stream-based processing with backpressure\n * - Direct streaming to DecodeWorker\n */\nexport class AudioDemuxWorker {\n  private channel: WorkerChannel;\n  private demuxer: MP4Demuxer | null = null;\n  private audioStream: TransformStream<Uint8Array, EncodedAudioChunk> | null = null;\n  private mp3Parser: MP3FrameParser | null = null;\n  private currentFormat: 'mp3' | 'mp4' | null = null;\n\n  // Connection to decoder worker\n  private decoderPort: MessagePort | null = null;\n\n  constructor() {\n    // Initialize WorkerChannel\n    this.channel = new WorkerChannel(self as any, {\n      name: 'AudioDemuxWorker',\n      timeout: 30000,\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.handleConnect.bind(this));\n    // Unified stream connect only\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 ResourceLoader (main thread)\n    this.channel.receiveStream(this.handleInputStream.bind(this));\n  }\n\n  /**\n   * Unified connect handler used by stream pipeline\n   */\n  private async handleConnect(payload: {\n    direction: 'upstream';\n    port: MessagePort;\n    streamType: 'video' | 'audio' | 'frame' | 'chunk';\n  }): Promise<{ success: boolean }> {\n    this.decoderPort = payload.port;\n    // Demux connects upstream to decoder\n    return { success: true };\n  }\n\n  /**\n   * Configure demuxer with format settings\n   * @param payload.config - Demuxer configuration\n   * @param payload.initial - If true, initialize worker state; otherwise just update config\n   */\n  private async handleConfigure(payload: {\n    config: DemuxConfig;\n    initial?: boolean;\n  }): Promise<{ success: boolean; tracks?: any[] }> {\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        // Detect format and create appropriate demuxer\n        const format = config.container || this.detectFormat(config);\n\n        if (format === 'mp3') {\n          this.mp3Parser = new MP3FrameParser();\n          this.demuxer?.destroy();\n          this.demuxer = null;\n          this.audioStream = null;\n          this.currentFormat = 'mp3';\n\n          const mp3Track = { id: 1, type: 'audio', codec: 'mp3' };\n          this.channel.notify('configured', {\n            tracks: [mp3Track],\n            format,\n            codec: 'mp3',\n          });\n\n          return { success: true, tracks: [mp3Track] };\n        } else if (format === 'mp4' || format === 'm4a') {\n          if (this.demuxer) {\n            this.demuxer.destroy();\n          }\n\n          this.demuxer = new MP4Demuxer({\n            ...config,\n            skipVideo: true, // Audio only\n          });\n          this.audioStream = this.demuxer.createAudioStream();\n          this.mp3Parser = null;\n          this.currentFormat = 'mp4';\n        } else {\n          throw {\n            code: 'UNSUPPORTED_FORMAT',\n            message: `Unsupported audio format: ${format}`,\n          };\n        }\n\n        if (!this.audioStream) {\n          throw {\n            code: 'NO_AUDIO_TRACK',\n            message: 'No audio track found in container',\n          };\n        }\n\n        const tracks = Array.from(this.demuxer.tracks.values());\n\n        // Notify configuration complete\n        this.channel.notify('configured', {\n          tracks,\n          format,\n          codec: tracks[0]?.codec,\n        });\n\n        return { success: true, tracks };\n      } else {\n        // Update configuration only (e.g., backpressure settings)\n        if (!this.demuxer) {\n          throw {\n            code: 'NOT_INITIALIZED',\n            message: 'Demuxer not initialized. Call configure with initial=true first',\n          };\n        }\n\n        // Demuxers don't support runtime config updates\n        // Would need initial=true for changes\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   * Detect audio format from configuration\n   */\n  private detectFormat(config: DemuxConfig): string {\n    // Simple format detection based on codec or file extension\n    if (config.codec?.includes('mp3')) return 'mp3';\n    if (config.codec?.includes('aac')) return 'mp4';\n    if (config.codec?.includes('opus')) return 'webm';\n\n    return 'mp3';\n  }\n\n  /**\n   * Handle input stream from ResourceLoader (main thread)\n   */\n  private async handleInputStream(\n    stream: ReadableStream<Uint8Array>,\n    metadata?: Record<string, any>\n  ): Promise<void> {\n    // Initialize demuxer if not configured\n    if (this.currentFormat === 'mp3' && !this.mp3Parser) {\n      this.mp3Parser = new MP3FrameParser();\n    }\n\n    if (this.currentFormat === 'mp4' && (!this.demuxer || !this.audioStream)) {\n      await this.handleConfigure({\n        config: { container: 'mp4', highWaterMark: 10 },\n        initial: true,\n      });\n    }\n\n    if (!this.decoderPort) {\n      throw new Error('Decoder not connected');\n    }\n\n    // Setup channel to decoder\n    const decoderChannel = new WorkerChannel(this.decoderPort, {\n      name: 'AudioDemux-Decoder',\n      timeout: 30000,\n    });\n\n    if (this.currentFormat === 'mp3') {\n      await this.pipeMp3Stream(stream, decoderChannel, metadata);\n    } else if (this.demuxer && this.audioStream) {\n      const transformed = stream.pipeThrough(this.audioStream);\n      const trackInfo = Array.from(this.demuxer.tracks.values())[0];\n\n      await decoderChannel.sendStream(transformed, {\n        streamType: 'audio',\n        clipId: metadata?.clipId ?? 'default',\n        trackId: metadata?.trackId ?? 'main',\n        codec: trackInfo?.codec ?? 'mp4a.40.2',\n        sampleRate: trackInfo?.sampleRate ?? 44_100,\n        numberOfChannels: trackInfo?.numberOfChannels ?? 2,\n        description: trackInfo?.description,\n      });\n\n      this.channel.notify('demux_complete', {\n        tracksProcessed: this.demuxer?.tracks.size || 0,\n      });\n    } else {\n      throw new Error('Audio demuxer not initialized');\n    }\n  }\n\n  private async pipeMp3Stream(\n    stream: ReadableStream<Uint8Array>,\n    decoderChannel: WorkerChannel,\n    metadata?: Record<string, any>\n  ): Promise<void> {\n    if (!this.mp3Parser) {\n      this.mp3Parser = new MP3FrameParser();\n    }\n\n    const reader = stream.getReader();\n    let currentConfig: MP3Config | null = null;\n    let configured = false;\n    const bufferedFrames: MP3Frame[] = [];\n    let writer: WritableStreamDefaultWriter<EncodedAudioChunk> | null = null;\n\n    const ensureWriter = async (): Promise<WritableStreamDefaultWriter<EncodedAudioChunk>> => {\n      if (!writer) {\n        const cfg = currentConfig;\n        if (!cfg) {\n          throw new Error('MP3 config missing while creating writer');\n        }\n        const transform = new TransformStream<EncodedAudioChunk, EncodedAudioChunk>();\n        writer = transform.writable.getWriter();\n        await decoderChannel.sendStream(transform.readable, {\n          streamType: 'audio',\n          clipId: metadata?.clipId ?? 'default',\n          trackId: metadata?.trackId ?? 'main',\n          codec: 'mp3',\n          sampleRate: cfg.sampleRate,\n          numberOfChannels: cfg.channels,\n          description: undefined,\n        });\n      }\n      return writer!;\n    };\n\n    try {\n      while (true) {\n        const { done, value } = await reader.read();\n        if (done) {\n          break;\n        }\n\n        if (!value) {\n          continue;\n        }\n\n        const { frames, config } = this.mp3Parser.push(value);\n\n        if (config) {\n          currentConfig = config;\n        }\n\n        if (config && !configured) {\n          await decoderChannel.send('configure' as any, {\n            streamType: 'audio',\n            clipId: metadata?.clipId ?? 'default',\n            codec: 'mp3',\n            sampleRate: config.sampleRate,\n            numberOfChannels: config.channels,\n            description: undefined,\n          });\n          this.channel.notify('demux_configured', {\n            clipId: metadata?.clipId ?? 'default',\n            codec: 'mp3',\n            sampleRate: config.sampleRate,\n            numberOfChannels: config.channels,\n          });\n          configured = true;\n        }\n\n        if (config) {\n          this.currentFormat = 'mp3';\n        }\n\n        if (!configured) {\n          bufferedFrames.push(...frames);\n          continue;\n        }\n\n        const targetWriter = await ensureWriter();\n        const readyFrames = bufferedFrames.splice(0, bufferedFrames.length);\n        readyFrames.push(...frames);\n        for (const frame of readyFrames) {\n          const chunk = new EncodedAudioChunk({\n            type: 'key',\n            timestamp: frame.timestampUs,\n            duration: frame.durationUs,\n            data: frame.data.buffer.slice(\n              frame.data.byteOffset,\n              frame.data.byteOffset + frame.data.byteLength\n            ),\n          });\n          await targetWriter.write(chunk);\n        }\n      }\n\n      const remaining = this.mp3Parser.flush();\n      if (remaining.length) {\n        if (!configured) {\n          throw new Error('MP3 stream ended before configuration');\n        }\n        const targetWriter = await ensureWriter();\n        for (const frame of remaining) {\n          const chunk = new EncodedAudioChunk({\n            type: 'key',\n            timestamp: frame.timestampUs,\n            duration: frame.durationUs,\n            data: frame.data.buffer.slice(\n              frame.data.byteOffset,\n              frame.data.byteOffset + frame.data.byteLength\n            ),\n          });\n          await targetWriter.write(chunk);\n        }\n      }\n\n      if (writer) {\n        await (writer as WritableStreamDefaultWriter<EncodedAudioChunk>).close();\n      }\n\n      this.channel.notify('demux_complete', {\n        tracksProcessed: 1,\n      });\n    } finally {\n      reader.releaseLock();\n    }\n  }\n\n  /**\n   * Get demuxer statistics\n   */\n  private async handleGetStats(): Promise<{\n    queueSize?: number;\n    tracksInfo?: any[];\n    format?: string;\n    state?: WorkerState;\n  }> {\n    if (this.currentFormat === 'mp3') {\n      return {\n        tracksInfo: this.mp3Parser ? [{ id: 1, type: 'audio', codec: 'mp3' }] : [],\n        format: 'mp3',\n        state: this.channel.state,\n      };\n    }\n\n    if (this.demuxer) {\n      return {\n        tracksInfo: Array.from(this.demuxer.tracks.values()),\n        format: 'mp4',\n        state: this.channel.state,\n      };\n    }\n\n    return { state: this.channel.state };\n  }\n\n  /**\n   * Dispose worker and cleanup resources\n   */\n  private async handleDispose(): Promise<{ success: boolean }> {\n    if (this.demuxer) {\n      this.demuxer.destroy();\n    }\n    this.demuxer = null;\n    this.audioStream = null;\n    this.mp3Parser = null;\n    this.currentFormat = null;\n\n    this.decoderPort?.close();\n    this.decoderPort = null;\n\n    this.channel.state = WorkerState.Disposed;\n\n    return { success: true };\n  }\n}\n\n// Initialize worker\nconst worker = new AudioDemuxWorker();\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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"}

package/dist/stages/demux/types.d.ts

@@ -0,0 +1,77 @@
+export interface DemuxConfig {
+    codec?: string;
+    trackId?: string;
+    container?: 'mp4' | 'webm';
+    highWaterMark?: number;
+    streaming?: {
+        batchSize?: number;
+        highWaterMark?: number;
+        sizeStrategy?: 'count' | 'bytes';
+        progressive?: boolean;
+        minBufferSize?: number;
+    };
+    performance?: {
+        immediateRelease?: boolean;
+        maxMemory?: number;
+        hardwareAcceleration?: boolean;
+    };
+    tracks?: {
+        videoTracks?: number[];
+        audioTracks?: number[];
+    };
+    skipVideo?: boolean;
+    skipAudio?: boolean;
+}
+export interface DemuxSample {
+    timestamp: number;
+    duration: number;
+    data: ArrayBuffer;
+    isKeyFrame: boolean;
+    trackId: string;
+}
+export interface TrackInfo {
+    id: number;
+    type: 'video' | 'audio';
+    codec: string;
+    width?: number;
+    height?: number;
+    sampleRate?: number;
+    numberOfChannels?: number;
+    bitrate?: number;
+    duration?: number;
+    timescale?: number;
+    description?: ArrayBuffer;
+}
+export interface DemuxerEvents {
+    onReady: (info: {
+        tracks: TrackInfo[];
+    }) => void;
+    onSamples: (samples: DemuxSample[]) => void;
+    onError: (error: Error) => void;
+    onComplete: () => void;
+}
+export interface BaseDemuxer {
+    configure(config: DemuxConfig): Promise<void>;
+    appendBuffer(buffer: ArrayBuffer): void;
+    flush(): void;
+    reset(): void;
+    destroy(): void;
+}
+export interface MP4DemuxInfo {
+    duration: number;
+    timescale: number;
+    isFragmented: boolean;
+    isProgressive: boolean;
+    hasIOD: boolean;
+    brands: string[];
+    created: Date;
+    modified: Date;
+    tracks: TrackInfo[];
+}
+export interface AudioDemuxConfig extends DemuxConfig {
+    codec: 'aac' | 'opus';
+}
+export interface VideoDemuxConfig extends DemuxConfig {
+    codec: 'h264' | 'h265' | 'vp9' | 'av1';
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/stages/demux/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/stages/demux/types.ts"],"names":[],"mappings":"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"}

package/dist/stages/demux/video-demux.worker.d.ts

@@ -0,0 +1,48 @@
+/**
+ * VideoDemuxWorker - First stage for video processing
+ * Extracts video tracks from container formats (MP4, etc.)
+ *
+ * Pipeline: ResourceLoader (Main Thread) → VideoDemuxWorker → DecodeWorker
+ *
+ * Features:
+ * - MP4 container demuxing with mp4box.js
+ * - Stream-based processing with backpressure
+ * - Direct streaming to DecodeWorker
+ */
+export declare class VideoDemuxWorker {
+    private channel;
+    private demuxer;
+    private resourceId;
+    private clipId?;
+    private downstreamPort;
+    private range?;
+    constructor();
+    protected setupHandlers(): void;
+    /**
+     * Handle connection from orchestrator
+     */
+    private handleConnect;
+    /**
+     * Configure demuxer with format settings
+     * @param payload.config - Demuxer configuration
+     * @param payload.initial - If true, initialize worker state; otherwise just update config
+     */
+    private handleConfigure;
+    /**
+     * Handle input stream from ResourceLoader (main thread)
+     * Strategy: Stream immediately, send codec info when ready
+     */
+    private handleReceiveStream;
+    private handleDemuxerReady;
+    /**
+     * Get demuxer statistics
+     */
+    private handleGetStats;
+    /**
+     * Dispose worker and cleanup resources
+     */
+    private handleDispose;
+}
+declare const _default: null;
+export default _default;
+//# sourceMappingURL=video-demux.worker.d.ts.map

package/dist/stages/demux/video-demux.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-demux.worker.d.ts","sourceRoot":"","sources":["../../../src/stages/demux/video-demux.worker.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,cAAc,CAA4B;IAClD,OAAO,CAAC,KAAK,CAAC,CAAiC;;IAY/C,SAAS,CAAC,aAAa,IAAI,IAAI;IAW/B;;OAEG;YACW,aAAa;IAkB3B;;;;OAIG;YACW,eAAe;IAuC7B;;;OAGG;YACW,mBAAmB;IA+DjC,OAAO,CAAC,kBAAkB;IA2B1B;;OAEG;YACW,cAAc;IAe5B;;OAEG;YACW,aAAa;CAc5B;;AASD,wBAAoB"}

package/dist/stages/demux/video-demux.worker.js

@@ -0,0 +1,173 @@
+import { WorkerChannel } from "../../worker/WorkerChannel.js";
+import { WorkerMessageType, WorkerState } from "../../worker/types.js";
+import { MP4Demuxer } from "./MP4Demuxer.js";
+class VideoDemuxWorker {
+  channel;
+  demuxer = null;
+  resourceId = null;
+  clipId;
+  downstreamPort = null;
+  range;
+  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;
+    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) {
+    console.log("[VideoDemuxWorker] handleReceiveStream", metadata?.clipId, metadata?.resourceId);
+    const currentResourceId = metadata?.resourceId || metadata?.clipId || this.resourceId || "default";
+    const clipId = metadata?.clipId;
+    if (this.resourceId && this.resourceId !== currentResourceId) {
+      throw new Error(
+        `[VideoDemuxWorker] BUG: Resource ID changed from ${this.resourceId} to ${currentResourceId}. Each VideoDemuxWorker instance should only handle one resource.`
+      );
+    }
+    if (!this.resourceId) {
+      this.resourceId = currentResourceId;
+    }
+    if (!this.demuxer) {
+      this.demuxer = new MP4Demuxer({
+        highWaterMark: 10,
+        skipAudio: true,
+        // Video only
+        onReady: () => this.handleDemuxerReady()
+      });
+    }
+    if (!this.downstreamPort) {
+      throw new Error("Decoder not connected");
+    }
+    if (clipId) {
+      this.clipId = clipId;
+    }
+    if (metadata?.range) {
+      this.range = metadata.range;
+    }
+    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,
+      ...this.range && { range: this.range }
+      // codec info will be sent separately when ready
+    });
+    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,
+      ...this.range && { range: this.range },
+      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.resourceId = null;
+    this.downstreamPort?.close();
+    this.downstreamPort = null;
+    this.channel.state = WorkerState.Disposed;
+    return { success: true };
+  }
+}
+const worker = new VideoDemuxWorker();
+self.addEventListener("beforeunload", () => {
+  worker["handleDispose"]();
+});
+const videoDemux_worker = null;
+export {
+  VideoDemuxWorker,
+  videoDemux_worker as default
+};
+//# sourceMappingURL=video-demux.worker.js.map