@napi-rs/webcodecs 1.0.0 → 1.1.0

package/README.md

@@ -18,7 +18,7 @@ WebCodecs API implementation for Node.js using FFmpeg, built with [NAPI-RS](http
 ## Installation
 
 ```bash
-npm install @napi-rs/webcodecs
+bun add @napi-rs/webcodecs
 # or
 pnpm add @napi-rs/webcodecs
 # or

package/index.d.ts

@@ -60,6 +60,317 @@ export interface CanvasLike {
   data(): Uint8Array
 }
 
+// ============================================================================
+// Muxer/Demuxer Types
+// ============================================================================
+
+/** Demuxer state */
+export type DemuxerState = 'unloaded' | 'ready' | 'demuxing' | 'ended' | 'closed'
+
+/** Muxer state */
+export type MuxerState = 'configuring' | 'muxing' | 'finalized' | 'closed'
+
+/** Track type for demuxer */
+export type DemuxerTrackType = 'video' | 'audio' | 'subtitle' | 'data'
+
+/** Track info from demuxer */
+export interface DemuxerTrackInfo {
+  /** Track index */
+  index: number
+  /** Track type */
+  trackType: DemuxerTrackType
+  /** Codec string */
+  codec?: string
+  /** Coded width (video only) */
+  codedWidth?: number
+  /** Coded height (video only) */
+  codedHeight?: number
+  /** Sample rate (audio only) */
+  sampleRate?: number
+  /** Number of channels (audio only) */
+  numberOfChannels?: number
+  /** Duration in microseconds */
+  duration?: number
+}
+
+/** Video decoder config from demuxer */
+export interface DemuxerVideoDecoderConfig {
+  /** Codec string */
+  codec: string
+  /** Coded width */
+  codedWidth: number
+  /** Coded height */
+  codedHeight: number
+  /** Codec description (e.g., avcC for H.264) */
+  description?: Uint8Array
+}
+
+/** Audio decoder config from demuxer */
+export interface DemuxerAudioDecoderConfig {
+  /** Codec string */
+  codec: string
+  /** Sample rate */
+  sampleRate: number
+  /** Number of channels */
+  numberOfChannels: number
+  /** Codec description */
+  description?: Uint8Array
+}
+
+/** Init options for Mp4Demuxer */
+export interface Mp4DemuxerInit {
+  /** Callback for video chunks */
+  videoOutput?: (chunk: EncodedVideoChunk) => void
+  /** Callback for audio chunks */
+  audioOutput?: (chunk: EncodedAudioChunk) => void
+  /** Error callback (required) */
+  error: (error: Error) => void
+}
+
+/** Init options for WebMDemuxer */
+export interface WebMDemuxerInit {
+  /** Callback for video chunks */
+  videoOutput?: (chunk: EncodedVideoChunk) => void
+  /** Callback for audio chunks */
+  audioOutput?: (chunk: EncodedAudioChunk) => void
+  /** Error callback (required) */
+  error: (error: Error) => void
+}
+
+/** Init options for MkvDemuxer */
+export interface MkvDemuxerInit {
+  /** Callback for video chunks */
+  videoOutput?: (chunk: EncodedVideoChunk) => void
+  /** Callback for audio chunks */
+  audioOutput?: (chunk: EncodedAudioChunk) => void
+  /** Error callback (required) */
+  error: (error: Error) => void
+}
+
+/** Video track config for muxer */
+export interface MuxerVideoTrackConfig {
+  /** Codec string */
+  codec: string
+  /** Video width */
+  width: number
+  /** Video height */
+  height: number
+  /** Codec description (e.g., avcC for H.264) */
+  description?: Uint8Array
+}
+
+/** Audio track config for muxer */
+export interface MuxerAudioTrackConfig {
+  /** Codec string */
+  codec: string
+  /** Sample rate */
+  sampleRate: number
+  /** Number of channels */
+  numberOfChannels: number
+  /** Codec description */
+  description?: Uint8Array
+}
+
+/** Init options for Mp4Muxer */
+export interface Mp4MuxerInit {
+  /** Move moov atom to beginning (not compatible with streaming) */
+  fastStart?: boolean
+  /** Use fragmented MP4 for streaming */
+  fragmented?: boolean
+  /** Enable streaming output mode */
+  streaming?: { bufferCapacity?: number }
+}
+
+/** Init options for WebMMuxer */
+export interface WebMMuxerInit {
+  /** Enable live streaming mode */
+  live?: boolean
+  /** Enable streaming output mode */
+  streaming?: { bufferCapacity?: number }
+}
+
+/** Init options for MkvMuxer */
+export interface MkvMuxerInit {
+  /** Enable live streaming mode */
+  live?: boolean
+  /** Enable streaming output mode */
+  streaming?: { bufferCapacity?: number }
+}
+
+/**
+ * MP4 Demuxer - reads encoded video/audio from MP4 containers
+ */
+export declare class Mp4Demuxer {
+  constructor(init: Mp4DemuxerInit)
+  /** Load from file path */
+  load(path: string): Promise<void>
+  /** Load from buffer */
+  loadBuffer(data: Uint8Array): Promise<void>
+  /** Get all tracks */
+  get tracks(): DemuxerTrackInfo[]
+  /** Get container duration in microseconds */
+  get duration(): number | null
+  /** Get video decoder configuration */
+  get videoDecoderConfig(): DemuxerVideoDecoderConfig | null
+  /** Get audio decoder configuration */
+  get audioDecoderConfig(): DemuxerAudioDecoderConfig | null
+  /** Select video track by index */
+  selectVideoTrack(trackIndex: number): void
+  /** Select audio track by index */
+  selectAudioTrack(trackIndex: number): void
+  /** Start demuxing (optional packet count limit) */
+  demux(count?: number): void
+  /** Seek to timestamp in microseconds */
+  seek(timestampUs: number): void
+  /** Close and release resources */
+  close(): void
+  /** Get current state */
+  get state(): DemuxerState
+}
+
+/**
+ * WebM Demuxer - reads encoded video/audio from WebM containers
+ */
+export declare class WebMDemuxer {
+  constructor(init: WebMDemuxerInit)
+  /** Load from file path */
+  load(path: string): Promise<void>
+  /** Load from buffer */
+  loadBuffer(data: Uint8Array): Promise<void>
+  /** Get all tracks */
+  get tracks(): DemuxerTrackInfo[]
+  /** Get container duration in microseconds */
+  get duration(): number | null
+  /** Get video decoder configuration */
+  get videoDecoderConfig(): DemuxerVideoDecoderConfig | null
+  /** Get audio decoder configuration */
+  get audioDecoderConfig(): DemuxerAudioDecoderConfig | null
+  /** Select video track by index */
+  selectVideoTrack(trackIndex: number): void
+  /** Select audio track by index */
+  selectAudioTrack(trackIndex: number): void
+  /** Start demuxing (optional packet count limit) */
+  demux(count?: number): void
+  /** Seek to timestamp in microseconds */
+  seek(timestampUs: number): void
+  /** Close and release resources */
+  close(): void
+  /** Get current state */
+  get state(): DemuxerState
+}
+
+/**
+ * MKV Demuxer - reads encoded video/audio from MKV containers
+ */
+export declare class MkvDemuxer {
+  constructor(init: MkvDemuxerInit)
+  /** Load from file path */
+  load(path: string): Promise<void>
+  /** Load from buffer */
+  loadBuffer(data: Uint8Array): Promise<void>
+  /** Get all tracks */
+  get tracks(): DemuxerTrackInfo[]
+  /** Get container duration in microseconds */
+  get duration(): number | null
+  /** Get video decoder configuration */
+  get videoDecoderConfig(): DemuxerVideoDecoderConfig | null
+  /** Get audio decoder configuration */
+  get audioDecoderConfig(): DemuxerAudioDecoderConfig | null
+  /** Select video track by index */
+  selectVideoTrack(trackIndex: number): void
+  /** Select audio track by index */
+  selectAudioTrack(trackIndex: number): void
+  /** Start demuxing (optional packet count limit) */
+  demux(count?: number): void
+  /** Seek to timestamp in microseconds */
+  seek(timestampUs: number): void
+  /** Close and release resources */
+  close(): void
+  /** Get current state */
+  get state(): DemuxerState
+}
+
+/**
+ * MP4 Muxer - writes encoded video/audio to MP4 containers
+ */
+export declare class Mp4Muxer {
+  constructor(init?: Mp4MuxerInit)
+  /** Add video track */
+  addVideoTrack(config: MuxerVideoTrackConfig): void
+  /** Add audio track */
+  addAudioTrack(config: MuxerAudioTrackConfig): void
+  /** Add encoded video chunk */
+  addVideoChunk(chunk: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata): void
+  /** Add encoded audio chunk */
+  addAudioChunk(chunk: EncodedAudioChunk, metadata?: EncodedAudioChunkMetadata): void
+  /** Flush pending data */
+  flush(): Promise<void>
+  /** Finalize and get output data */
+  finalize(): Uint8Array
+  /** Read available data (streaming mode) */
+  read(): Uint8Array | null
+  /** Check if finished (streaming mode) */
+  get isFinished(): boolean
+  /** Close and release resources */
+  close(): void
+  /** Get current state */
+  get state(): MuxerState
+}
+
+/**
+ * WebM Muxer - writes encoded video/audio to WebM containers
+ */
+export declare class WebMMuxer {
+  constructor(init?: WebMMuxerInit)
+  /** Add video track */
+  addVideoTrack(config: MuxerVideoTrackConfig): void
+  /** Add audio track */
+  addAudioTrack(config: MuxerAudioTrackConfig): void
+  /** Add encoded video chunk */
+  addVideoChunk(chunk: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata): void
+  /** Add encoded audio chunk */
+  addAudioChunk(chunk: EncodedAudioChunk, metadata?: EncodedAudioChunkMetadata): void
+  /** Flush pending data */
+  flush(): Promise<void>
+  /** Finalize and get output data */
+  finalize(): Uint8Array
+  /** Read available data (streaming mode) */
+  read(): Uint8Array | null
+  /** Check if finished (streaming mode) */
+  get isFinished(): boolean
+  /** Close and release resources */
+  close(): void
+  /** Get current state */
+  get state(): MuxerState
+}
+
+/**
+ * MKV Muxer - writes encoded video/audio to MKV containers
+ */
+export declare class MkvMuxer {
+  constructor(init?: MkvMuxerInit)
+  /** Add video track */
+  addVideoTrack(config: MuxerVideoTrackConfig): void
+  /** Add audio track */
+  addAudioTrack(config: MuxerAudioTrackConfig): void
+  /** Add encoded video chunk */
+  addVideoChunk(chunk: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata): void
+  /** Add encoded audio chunk */
+  addAudioChunk(chunk: EncodedAudioChunk, metadata?: EncodedAudioChunkMetadata): void
+  /** Flush pending data */
+  flush(): Promise<void>
+  /** Finalize and get output data */
+  finalize(): Uint8Array
+  /** Read available data (streaming mode) */
+  read(): Uint8Array | null
+  /** Check if finished (streaming mode) */
+  get isFinished(): boolean
+  /** Close and release resources */
+  close(): void
+  /** Get current state */
+  get state(): MuxerState
+}
+
 export type TypedArray =
   | Int8Array
   | Uint8Array
@@ -480,6 +791,252 @@ export declare class ImageTrackList {
   item(index: number): ImageTrack | null
 }
 
+/**
+ * MKV Demuxer for reading encoded video and audio from Matroska container
+ *
+ * MKV supports almost any video and audio codec.
+ */
+export declare class MkvDemuxer {
+  constructor(init: MkvDemuxerInit)
+  load(path: string): Promise<void>
+  /**
+   * Load an MKV from a buffer
+   *
+   * This method uses zero-copy buffer loading - the Uint8Array data is passed
+   * directly to the demuxer without an intermediate copy.
+   */
+  loadBuffer(data: Uint8Array): Promise<void>
+  get tracks(): Array<DemuxerTrackInfo>
+  get duration(): number | null
+  get videoDecoderConfig(): DemuxerVideoDecoderConfig | null
+  get audioDecoderConfig(): DemuxerAudioDecoderConfig | null
+  selectVideoTrack(trackIndex: number): void
+  selectAudioTrack(trackIndex: number): void
+  demux(count?: number | undefined | null): void
+  seek(timestampUs: number): void
+  close(): void
+  get state(): string
+}
+
+/**
+ * MKV Muxer for combining encoded video and audio into Matroska container
+ *
+ * MKV (Matroska) supports virtually all video and audio codecs.
+ *
+ * Usage:
+ * ```javascript
+ * const muxer = new MkvMuxer();
+ * muxer.addVideoTrack({ codec: 'avc1.42001E', width: 1920, height: 1080 });
+ * muxer.addAudioTrack({ codec: 'opus', sampleRate: 48000, numberOfChannels: 2 });
+ *
+ * // Add encoded chunks from VideoEncoder/AudioEncoder
+ * encoder.configure({
+ *   output: (chunk, metadata) => muxer.addVideoChunk(chunk, metadata)
+ * });
+ *
+ * // Finalize and get MKV data
+ * const mkvData = muxer.finalize();
+ * ```
+ */
+export declare class MkvMuxer {
+  /** Create a new MKV muxer */
+  constructor(options?: MkvMuxerOptions | undefined | null)
+  /**
+   * Add a video track to the muxer
+   *
+   * MKV supports H.264, H.265, VP8, VP9, AV1, and many other video codecs.
+   */
+  addVideoTrack(config: MkvVideoTrackConfig): void
+  /**
+   * Add an audio track to the muxer
+   *
+   * MKV supports AAC, Opus, Vorbis, FLAC, MP3, AC3, and many other audio codecs.
+   */
+  addAudioTrack(config: MkvAudioTrackConfig): void
+  /** Add an encoded video chunk to the muxer */
+  addVideoChunk(
+    chunk: import('./standard').EncodedVideoChunk,
+    metadata?: import('./standard').EncodedVideoChunkMetadata,
+  ): void
+  /** Add an encoded audio chunk to the muxer */
+  addAudioChunk(
+    chunk: import('./standard').EncodedAudioChunk,
+    metadata?: import('./standard').EncodedAudioChunkMetadata,
+  ): void
+  /** Flush any buffered data */
+  flush(): void
+  /** Finalize the muxer and return the MKV data */
+  finalize(): Uint8Array
+  /**
+   * Read available data from streaming buffer (streaming mode only)
+   *
+   * Returns available data, or null if no data is ready yet.
+   * Returns empty Uint8Array when streaming is finished.
+   */
+  read(): Uint8Array | null
+  /** Check if muxer is in streaming mode */
+  get isStreaming(): boolean
+  /** Check if streaming is finished (streaming mode only) */
+  get isFinished(): boolean
+  /** Close the muxer and release resources */
+  close(): void
+  /** Get the current state of the muxer */
+  get state(): string
+}
+
+/**
+ * MP4 Demuxer for reading encoded video and audio from MP4 container
+ *
+ * Usage:
+ * ```javascript
+ * const demuxer = new Mp4Demuxer({
+ *   videoOutput: (chunk) => videoDecoder.decode(chunk),
+ *   audioOutput: (chunk) => audioDecoder.decode(chunk),
+ *   error: (err) => console.error(err)
+ * });
+ *
+ * await demuxer.load('./video.mp4');
+ *
+ * // Get decoder configs
+ * const videoConfig = demuxer.videoDecoderConfig;
+ * const audioConfig = demuxer.audioDecoderConfig;
+ *
+ * // Configure decoders
+ * videoDecoder.configure(videoConfig);
+ * audioDecoder.configure(audioConfig);
+ *
+ * // Start demuxing
+ * demuxer.demux();
+ *
+ * // Seek to 5 seconds
+ * demuxer.seek(5_000_000);
+ *
+ * demuxer.close();
+ * ```
+ */
+export declare class Mp4Demuxer {
+  /** Create a new MP4 demuxer */
+  constructor(init: Mp4DemuxerInit)
+  /** Load an MP4 file from a path */
+  load(path: string): Promise<void>
+  /**
+   * Load an MP4 from a buffer
+   *
+   * This method uses zero-copy buffer loading - the Uint8Array data is passed
+   * directly to the demuxer without an intermediate copy.
+   */
+  loadBuffer(data: Uint8Array): Promise<void>
+  /** Get all tracks */
+  get tracks(): Array<DemuxerTrackInfo>
+  /** Get container duration in microseconds */
+  get duration(): number | null
+  /** Get video decoder configuration for the selected video track */
+  get videoDecoderConfig(): DemuxerVideoDecoderConfig | null
+  /** Get audio decoder configuration for the selected audio track */
+  get audioDecoderConfig(): DemuxerAudioDecoderConfig | null
+  /** Select a video track by index */
+  selectVideoTrack(trackIndex: number): void
+  /** Select an audio track by index */
+  selectAudioTrack(trackIndex: number): void
+  /**
+   * Start demuxing packets
+   *
+   * If count is specified, reads up to that many packets.
+   * Otherwise, reads all packets until end of stream.
+   */
+  demux(count?: number | undefined | null): void
+  /** Seek to a timestamp in microseconds */
+  seek(timestampUs: number): void
+  /** Close the demuxer and release resources */
+  close(): void
+  /** Get the current state of the demuxer */
+  get state(): string
+}
+
+/**
+ * MP4 Muxer for combining encoded video and audio into MP4 container
+ *
+ * Usage:
+ * ```javascript
+ * const muxer = new Mp4Muxer({ fastStart: true });
+ * muxer.addVideoTrack({ codec: 'avc1.42001E', width: 1920, height: 1080 });
+ * muxer.addAudioTrack({ codec: 'mp4a.40.2', sampleRate: 48000, numberOfChannels: 2 });
+ *
+ * // Add encoded chunks from VideoEncoder/AudioEncoder
+ * encoder.configure({
+ *   output: (chunk, metadata) => muxer.addVideoChunk(chunk, metadata)
+ * });
+ *
+ * // Finalize and get MP4 data
+ * const mp4Data = muxer.finalize();
+ * ```
+ */
+export declare class Mp4Muxer {
+  /** Create a new MP4 muxer */
+  constructor(options?: Mp4MuxerOptions | undefined | null)
+  /**
+   * Add a video track to the muxer
+   *
+   * Must be called before adding any chunks.
+   */
+  addVideoTrack(config: Mp4VideoTrackConfig): void
+  /**
+   * Add an audio track to the muxer
+   *
+   * Must be called before adding any chunks.
+   */
+  addAudioTrack(config: Mp4AudioTrackConfig): void
+  /**
+   * Add an encoded video chunk to the muxer
+   *
+   * The chunk should come from a VideoEncoder's output callback.
+   * If metadata contains decoderConfig.description, it will be used to update
+   * the codec extradata (useful for extracting avcC/hvcC from the encoder).
+   */
+  addVideoChunk(
+    chunk: import('./standard').EncodedVideoChunk,
+    metadata?: import('./standard').EncodedVideoChunkMetadata,
+  ): void
+  /**
+   * Add an encoded audio chunk to the muxer
+   *
+   * The chunk should come from an AudioEncoder's output callback.
+   */
+  addAudioChunk(
+    chunk: import('./standard').EncodedAudioChunk,
+    metadata?: import('./standard').EncodedAudioChunkMetadata,
+  ): void
+  /** Flush any buffered data */
+  flush(): void
+  /**
+   * Finalize the muxer and return the MP4 data
+   *
+   * After calling this, no more chunks can be added.
+   * Returns the complete MP4 file as a Uint8Array.
+   */
+  finalize(): Uint8Array
+  /**
+   * Read available data from streaming buffer (streaming mode only)
+   *
+   * Returns available data, or null if no data is ready yet.
+   * Returns empty Uint8Array when streaming is finished.
+   */
+  read(): Uint8Array | null
+  /** Check if muxer is in streaming mode */
+  get isStreaming(): boolean
+  /** Check if streaming is finished (streaming mode only) */
+  get isFinished(): boolean
+  /**
+   * Close the muxer and release resources
+   *
+   * This is called automatically when the muxer is garbage collected,
+   * but can be called explicitly to release resources early.
+   */
+  close(): void
+  /** Get the current state of the muxer */
+  get state(): string
+}
+
 /** Video color space parameters (WebCodecs spec) - as a class per spec */
 export declare class VideoColorSpace {
   /** Create a new VideoColorSpace */
@@ -780,6 +1337,99 @@ export declare class VideoFrame {
   close(): void
 }
 
+/**
+ * WebM Demuxer for reading encoded video and audio from WebM container
+ *
+ * WebM typically contains VP8, VP9, or AV1 video with Opus or Vorbis audio.
+ */
+export declare class WebMDemuxer {
+  constructor(init: WebMDemuxerInit)
+  load(path: string): Promise<void>
+  /**
+   * Load a WebM from a buffer
+   *
+   * This method uses zero-copy buffer loading - the Uint8Array data is passed
+   * directly to the demuxer without an intermediate copy.
+   */
+  loadBuffer(data: Uint8Array): Promise<void>
+  get tracks(): Array<DemuxerTrackInfo>
+  get duration(): number | null
+  get videoDecoderConfig(): DemuxerVideoDecoderConfig | null
+  get audioDecoderConfig(): DemuxerAudioDecoderConfig | null
+  selectVideoTrack(trackIndex: number): void
+  selectAudioTrack(trackIndex: number): void
+  demux(count?: number | undefined | null): void
+  seek(timestampUs: number): void
+  close(): void
+  get state(): string
+}
+
+/**
+ * WebM Muxer for combining encoded video and audio into WebM container
+ *
+ * WebM supports VP8, VP9, AV1 video codecs and Opus, Vorbis audio codecs.
+ *
+ * Usage:
+ * ```javascript
+ * const muxer = new WebMMuxer();
+ * muxer.addVideoTrack({ codec: 'vp09.00.10.08', width: 1920, height: 1080 });
+ * muxer.addAudioTrack({ codec: 'opus', sampleRate: 48000, numberOfChannels: 2 });
+ *
+ * // Add encoded chunks from VideoEncoder/AudioEncoder
+ * encoder.configure({
+ *   output: (chunk, metadata) => muxer.addVideoChunk(chunk, metadata)
+ * });
+ *
+ * // Finalize and get WebM data
+ * const webmData = muxer.finalize();
+ * ```
+ */
+export declare class WebMMuxer {
+  /** Create a new WebM muxer */
+  constructor(options?: WebMMuxerOptions | undefined | null)
+  /**
+   * Add a video track to the muxer
+   *
+   * WebM supports VP8, VP9, and AV1 video codecs.
+   */
+  addVideoTrack(config: WebMVideoTrackConfig): void
+  /**
+   * Add an audio track to the muxer
+   *
+   * WebM supports Opus and Vorbis audio codecs.
+   */
+  addAudioTrack(config: WebMAudioTrackConfig): void
+  /** Add an encoded video chunk to the muxer */
+  addVideoChunk(
+    chunk: import('./standard').EncodedVideoChunk,
+    metadata?: import('./standard').EncodedVideoChunkMetadata,
+  ): void
+  /** Add an encoded audio chunk to the muxer */
+  addAudioChunk(
+    chunk: import('./standard').EncodedAudioChunk,
+    metadata?: import('./standard').EncodedAudioChunkMetadata,
+  ): void
+  /** Flush any buffered data */
+  flush(): void
+  /** Finalize the muxer and return the WebM data */
+  finalize(): Uint8Array
+  /**
+   * Read available data from streaming buffer (streaming mode only)
+   *
+   * Returns available data, or null if no data is ready yet.
+   * Returns empty Uint8Array when streaming is finished.
+   */
+  read(): Uint8Array | null
+  /** Check if muxer is in streaming mode */
+  get isStreaming(): boolean
+  /** Check if streaming is finished (streaming mode only) */
+  get isFinished(): boolean
+  /** Close the muxer and release resources */
+  close(): void
+  /** Get the current state of the muxer */
+  get state(): string
+}
+
 /** AAC bitstream format (W3C WebCodecs AAC Registration) */
 export type AacBitstreamFormat = /** Raw AAC frames - metadata in description */
   | 'aac'
@@ -827,6 +1477,18 @@ export interface AudioDecoderAddEventListenerOptions {
   passive?: boolean
 }
 
+/** JavaScript-facing audio decoder config type */
+export interface AudioDecoderConfigJs {
+  /** Codec string */
+  codec?: string
+  /** Sample rate */
+  sampleRate?: number
+  /** Number of channels */
+  numberOfChannels?: number
+  /** Codec-specific description */
+  description?: Uint8Array
+}
+
 /** Decoder configuration output (for passing to decoder) */
 export interface AudioDecoderConfigOutput {
   /** Codec string */
@@ -925,6 +1587,50 @@ export type ColorSpaceConversion = /** Apply default color space conversion (spe
   /** No color space conversion */
   | 'none'
 
+/** Audio decoder configuration exposed to JavaScript */
+export interface DemuxerAudioDecoderConfig {
+  /** Codec string */
+  codec: string
+  /** Sample rate */
+  sampleRate: number
+  /** Number of channels */
+  numberOfChannels: number
+  /** Codec-specific description data */
+  description?: Uint8Array
+}
+
+/** Track information exposed to JavaScript */
+export interface DemuxerTrackInfo {
+  /** Track index */
+  index: number
+  /** Track type ("video" or "audio") */
+  trackType: string
+  /** Codec string (WebCodecs format) */
+  codec: string
+  /** Duration in microseconds */
+  duration?: number
+  /** Coded width (video only) */
+  codedWidth?: number
+  /** Coded height (video only) */
+  codedHeight?: number
+  /** Sample rate (audio only) */
+  sampleRate?: number
+  /** Number of channels (audio only) */
+  numberOfChannels?: number
+}
+
+/** Video decoder configuration exposed to JavaScript */
+export interface DemuxerVideoDecoderConfig {
+  /** Codec string */
+  codec: string
+  /** Coded width */
+  codedWidth: number
+  /** Coded height */
+  codedHeight: number
+  /** Codec-specific description data (avcC/hvcC) */
+  description?: Uint8Array
+}
+
 /** DOMRectInit for specifying regions */
 export interface DOMRectInit {
   x?: number
@@ -939,6 +1645,12 @@ export interface EncodedAudioChunkMetadata {
   decoderConfig?: AudioDecoderConfigOutput
 }
 
+/** JavaScript-facing metadata type for audio chunks */
+export interface EncodedAudioChunkMetadataJs {
+  /** Decoder configuration from encoder */
+  decoderConfig?: AudioDecoderConfigJS
+}
+
 /** Type of encoded audio chunk */
 export type EncodedAudioChunkType = /** Key chunk - can be decoded independently */
   | 'key'
@@ -955,6 +1667,14 @@ export interface EncodedVideoChunkMetadata {
   alphaSideData?: Uint8Array
 }
 
+/** JavaScript-facing metadata type for video chunks */
+export interface EncodedVideoChunkMetadataJs {
+  /** Decoder configuration from encoder */
+  decoderConfig?: VideoDecoderConfigJS
+  /** SVC output metadata */
+  svc?: SvcOutputMetadataJS
+}
+
 /** Type of encoded video chunk */
 export type EncodedVideoChunkType = /** Keyframe - can be decoded independently */
   | 'key'
@@ -1030,6 +1750,78 @@ export type LatencyMode = /** Optimize for quality (default) */
   /** Optimize for low latency */
   | 'realtime'
 
+/** Audio track configuration for MKV muxer */
+export interface MkvAudioTrackConfig {
+  /** Codec string (e.g., "mp4a.40.2", "opus", "flac", "vorbis", "ac3") */
+  codec: string
+  /** Sample rate in Hz */
+  sampleRate: number
+  /** Number of audio channels */
+  numberOfChannels: number
+  /** Codec-specific description data */
+  description?: Uint8Array
+}
+
+/** MKV muxer options */
+export interface MkvMuxerOptions {
+  /** Enable live streaming mode */
+  live?: boolean
+  /** Enable streaming output mode */
+  streaming?: StreamingMuxerOptions
+}
+
+/** Video track configuration for MKV muxer */
+export interface MkvVideoTrackConfig {
+  /** Codec string (e.g., "avc1.42001E", "hev1.1.6.L93.B0", "vp09.00.10.08", "av01.0.04M.08") */
+  codec: string
+  /** Video width in pixels */
+  width: number
+  /** Video height in pixels */
+  height: number
+  /** Codec-specific description data */
+  description?: Uint8Array
+}
+
+/** Audio track configuration for MP4 muxer */
+export interface Mp4AudioTrackConfig {
+  /** Codec string (e.g., "mp4a.40.2" for AAC-LC, "opus") */
+  codec: string
+  /** Sample rate in Hz */
+  sampleRate: number
+  /** Number of audio channels */
+  numberOfChannels: number
+  /** Codec-specific description data (esds for AAC, etc.) */
+  description?: Uint8Array
+}
+
+/** MP4 muxer options */
+export interface Mp4MuxerOptions {
+  /**
+   * Move moov atom to beginning for better streaming (default: false)
+   * Note: Not compatible with streaming output mode
+   */
+  fastStart?: boolean
+  /**
+   * Use fragmented MP4 for streaming output
+   * When true, uses frag_keyframe+empty_moov+default_base_moof
+   */
+  fragmented?: boolean
+  /** Enable streaming output mode */
+  streaming?: StreamingMuxerOptions
+}
+
+/** Video track configuration for MP4 muxer */
+export interface Mp4VideoTrackConfig {
+  /** Codec string (e.g., "avc1.42001E", "hev1.1.6.L93.B0", "av01.0.04M.08") */
+  codec: string
+  /** Video width in pixels */
+  width: number
+  /** Video height in pixels */
+  height: number
+  /** Codec-specific description data (avcC/hvcC/av1C from encoder metadata) */
+  description?: Uint8Array
+}
+
 /** Opus application mode (W3C WebCodecs Opus Registration) */
 export type OpusApplication = /** Optimize for VoIP (speech intelligibility) */
   | 'voip'
@@ -1094,12 +1886,24 @@ export interface PlaneLayout {
  */
 export declare function resetHardwareFallbackState(): void
 
+/** Streaming mode options for muxers */
+export interface StreamingMuxerOptions {
+  /** Buffer capacity for streaming output (default: 256KB) */
+  bufferCapacity?: number
+}
+
 /** SVC (Scalable Video Coding) output metadata (W3C WebCodecs spec) */
 export interface SvcOutputMetadata {
   /** Temporal layer ID for this frame */
   temporalLayerId?: number
 }
 
+/** JavaScript-facing SVC metadata */
+export interface SvcOutputMetadataJs {
+  /** Temporal layer ID */
+  temporalLayerId?: number
+}
+
 /** Video color primaries (W3C WebCodecs spec) */
 export type VideoColorPrimaries = /** BT.709 / sRGB primaries */
   | 'bt709'
@@ -1119,6 +1923,18 @@ export interface VideoDecoderAddEventListenerOptions {
   passive?: boolean
 }
 
+/** JavaScript-facing decoder config type */
+export interface VideoDecoderConfigJs {
+  /** Codec string */
+  codec?: string
+  /** Codec-specific description */
+  description?: Uint8Array
+  /** Coded width */
+  codedWidth?: number
+  /** Coded height */
+  codedHeight?: number
+}
+
 /** Decoder configuration output (for passing to decoder) */
 export interface VideoDecoderConfigOutput {
   /** Codec string */
@@ -1325,3 +2141,35 @@ export type VideoTransferCharacteristics = /** BT.709 transfer */
   | 'pq'
   /** Hybrid Log-Gamma (HDR) */
   | 'hlg'
+
+/** Audio track configuration for WebM muxer */
+export interface WebMAudioTrackConfig {
+  /** Codec string (e.g., "opus", "vorbis") */
+  codec: string
+  /** Sample rate in Hz */
+  sampleRate: number
+  /** Number of audio channels */
+  numberOfChannels: number
+  /** Codec-specific description data */
+  description?: Uint8Array
+}
+
+/** WebM muxer options */
+export interface WebMMuxerOptions {
+  /** Enable live streaming mode (cluster-at-a-time output) */
+  live?: boolean
+  /** Enable streaming output mode */
+  streaming?: StreamingMuxerOptions
+}
+
+/** Video track configuration for WebM muxer */
+export interface WebMVideoTrackConfig {
+  /** Codec string (e.g., "vp8", "vp09.00.10.08", "av01.0.04M.08") */
+  codec: string
+  /** Video width in pixels */
+  width: number
+  /** Video height in pixels */
+  height: number
+  /** Codec-specific description data */
+  description?: Uint8Array
+}

package/index.js

@@ -78,12 +78,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-android-arm64')
         const bindingPackageVersion = require('@napi-rs/webcodecs-android-arm64/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -100,12 +100,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-android-arm-eabi')
         const bindingPackageVersion = require('@napi-rs/webcodecs-android-arm-eabi/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -130,12 +130,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-win32-x64-gnu')
           const bindingPackageVersion = require('@napi-rs/webcodecs-win32-x64-gnu/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -152,12 +152,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-win32-x64-msvc')
           const bindingPackageVersion = require('@napi-rs/webcodecs-win32-x64-msvc/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -175,12 +175,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-win32-ia32-msvc')
         const bindingPackageVersion = require('@napi-rs/webcodecs-win32-ia32-msvc/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -197,12 +197,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-win32-arm64-msvc')
         const bindingPackageVersion = require('@napi-rs/webcodecs-win32-arm64-msvc/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -222,12 +222,12 @@ function requireNative() {
       const binding = require('@napi-rs/webcodecs-darwin-universal')
       const bindingPackageVersion = require('@napi-rs/webcodecs-darwin-universal/package.json').version
       if (
-        bindingPackageVersion !== '0.0.0' &&
+        bindingPackageVersion !== '1.1.0' &&
         process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
         process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
       ) {
         throw new Error(
-          `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+          `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
         )
       }
       return binding
@@ -244,12 +244,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-darwin-x64')
         const bindingPackageVersion = require('@napi-rs/webcodecs-darwin-x64/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -266,12 +266,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-darwin-arm64')
         const bindingPackageVersion = require('@napi-rs/webcodecs-darwin-arm64/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -292,12 +292,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-freebsd-x64')
         const bindingPackageVersion = require('@napi-rs/webcodecs-freebsd-x64/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -314,12 +314,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-freebsd-arm64')
         const bindingPackageVersion = require('@napi-rs/webcodecs-freebsd-arm64/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -341,12 +341,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-linux-x64-musl')
           const bindingPackageVersion = require('@napi-rs/webcodecs-linux-x64-musl/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -363,12 +363,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-linux-x64-gnu')
           const bindingPackageVersion = require('@napi-rs/webcodecs-linux-x64-gnu/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -387,12 +387,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-linux-arm64-musl')
           const bindingPackageVersion = require('@napi-rs/webcodecs-linux-arm64-musl/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -409,12 +409,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-linux-arm64-gnu')
           const bindingPackageVersion = require('@napi-rs/webcodecs-linux-arm64-gnu/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -433,12 +433,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-linux-arm-musleabihf')
           const bindingPackageVersion = require('@napi-rs/webcodecs-linux-arm-musleabihf/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -455,12 +455,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-linux-arm-gnueabihf')
           const bindingPackageVersion = require('@napi-rs/webcodecs-linux-arm-gnueabihf/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -479,12 +479,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-linux-loong64-musl')
           const bindingPackageVersion = require('@napi-rs/webcodecs-linux-loong64-musl/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -501,12 +501,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-linux-loong64-gnu')
           const bindingPackageVersion = require('@napi-rs/webcodecs-linux-loong64-gnu/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -525,12 +525,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-linux-riscv64-musl')
           const bindingPackageVersion = require('@napi-rs/webcodecs-linux-riscv64-musl/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -547,12 +547,12 @@ function requireNative() {
           const binding = require('@napi-rs/webcodecs-linux-riscv64-gnu')
           const bindingPackageVersion = require('@napi-rs/webcodecs-linux-riscv64-gnu/package.json').version
           if (
-            bindingPackageVersion !== '0.0.0' &&
+            bindingPackageVersion !== '1.1.0' &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
             process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
           ) {
             throw new Error(
-              `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+              `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
             )
           }
           return binding
@@ -570,12 +570,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-linux-ppc64-gnu')
         const bindingPackageVersion = require('@napi-rs/webcodecs-linux-ppc64-gnu/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -592,12 +592,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-linux-s390x-gnu')
         const bindingPackageVersion = require('@napi-rs/webcodecs-linux-s390x-gnu/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -618,12 +618,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-openharmony-arm64')
         const bindingPackageVersion = require('@napi-rs/webcodecs-openharmony-arm64/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -640,12 +640,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-openharmony-x64')
         const bindingPackageVersion = require('@napi-rs/webcodecs-openharmony-x64/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -662,12 +662,12 @@ function requireNative() {
         const binding = require('@napi-rs/webcodecs-openharmony-arm')
         const bindingPackageVersion = require('@napi-rs/webcodecs-openharmony-arm/package.json').version
         if (
-          bindingPackageVersion !== '0.0.0' &&
+          bindingPackageVersion !== '1.1.0' &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
           process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0'
         ) {
           throw new Error(
-            `Native binding package version mismatch, expected 0.0.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+            `Native binding package version mismatch, expected 1.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
           )
         }
         return binding
@@ -741,10 +741,16 @@ module.exports.ImageDecoder = nativeBinding.ImageDecoder
 module.exports.ImageDecodeResult = nativeBinding.ImageDecodeResult
 module.exports.ImageTrack = nativeBinding.ImageTrack
 module.exports.ImageTrackList = nativeBinding.ImageTrackList
+module.exports.MkvDemuxer = nativeBinding.MkvDemuxer
+module.exports.MkvMuxer = nativeBinding.MkvMuxer
+module.exports.Mp4Demuxer = nativeBinding.Mp4Demuxer
+module.exports.Mp4Muxer = nativeBinding.Mp4Muxer
 module.exports.VideoColorSpace = nativeBinding.VideoColorSpace
 module.exports.VideoDecoder = nativeBinding.VideoDecoder
 module.exports.VideoEncoder = nativeBinding.VideoEncoder
 module.exports.VideoFrame = nativeBinding.VideoFrame
+module.exports.WebMDemuxer = nativeBinding.WebMDemuxer
+module.exports.WebMMuxer = nativeBinding.WebMMuxer
 module.exports.AacBitstreamFormat = nativeBinding.AacBitstreamFormat
 module.exports.AlphaOption = nativeBinding.AlphaOption
 module.exports.AudioSampleFormat = nativeBinding.AudioSampleFormat

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@napi-rs/webcodecs",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "WebCodecs API implementation for Node.js using FFmpeg",
   "keywords": [
     "N-API",
@@ -55,6 +55,7 @@
     "prepublishOnly": "napi prepublish -t npm",
     "test": "ava",
     "typecheck": "tsc -b tsconfig.json",
+    "preversion": "napi build --platform && git add .",
     "version": "napi version"
   },
   "lint-staged": {
@@ -150,14 +151,14 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "@napi-rs/webcodecs-darwin-x64": "1.0.0",
-    "@napi-rs/webcodecs-darwin-arm64": "1.0.0",
-    "@napi-rs/webcodecs-linux-x64-gnu": "1.0.0",
-    "@napi-rs/webcodecs-linux-x64-musl": "1.0.0",
-    "@napi-rs/webcodecs-win32-x64-msvc": "1.0.0",
-    "@napi-rs/webcodecs-linux-arm64-gnu": "1.0.0",
-    "@napi-rs/webcodecs-linux-arm64-musl": "1.0.0",
-    "@napi-rs/webcodecs-win32-arm64-msvc": "1.0.0",
-    "@napi-rs/webcodecs-linux-arm-gnueabihf": "1.0.0"
+    "@napi-rs/webcodecs-darwin-x64": "1.1.0",
+    "@napi-rs/webcodecs-darwin-arm64": "1.1.0",
+    "@napi-rs/webcodecs-linux-x64-gnu": "1.1.0",
+    "@napi-rs/webcodecs-linux-x64-musl": "1.1.0",
+    "@napi-rs/webcodecs-win32-x64-msvc": "1.1.0",
+    "@napi-rs/webcodecs-linux-arm64-gnu": "1.1.0",
+    "@napi-rs/webcodecs-linux-arm64-musl": "1.1.0",
+    "@napi-rs/webcodecs-win32-arm64-msvc": "1.1.0",
+    "@napi-rs/webcodecs-linux-arm-gnueabihf": "1.1.0"
   }
 }