@napi-rs/webcodecs 1.2.0 → 1.3.0

package/index.d.ts

@@ -137,18 +137,61 @@ export interface MkvMuxerInit {
   streaming?: { bufferCapacity?: number }
 }
 
-export type TypedArray =
-  | Int8Array
-  | Uint8Array
-  | Uint8ClampedArray
-  | Int16Array
-  | Uint16Array
-  | Int32Array
-  | Uint32Array
-  | Float32Array
-  | Float64Array
-  | BigInt64Array
-  | BigUint64Array
+// ============================================================================
+// Async Iterator Types
+// ============================================================================
+
+/**
+ * Chunk yielded by demuxer async iterator.
+ *
+ * Contains either a video or audio chunk. Use the `chunkType` property
+ * to determine which type of chunk is present.
+ *
+ * @example
+ * ```typescript
+ * for await (const chunk of demuxer) {
+ *   if (chunk.chunkType === 'video') {
+ *     videoDecoder.decode(chunk.videoChunk!)
+ *   } else {
+ *     audioDecoder.decode(chunk.audioChunk!)
+ *   }
+ * }
+ * ```
+ */
+export interface DemuxerChunk {
+  /** Type of chunk: 'video' or 'audio' */
+  chunkType: 'video' | 'audio'
+  /** Video chunk (present when chunkType is 'video') */
+  videoChunk?: EncodedVideoChunk
+  /** Audio chunk (present when chunkType is 'audio') */
+  audioChunk?: EncodedAudioChunk
+}
+
+/**
+ * Adds async iterator support to Mp4Demuxer.
+ * Declaration merging allows using `for await...of` with the demuxer.
+ */
+export interface Mp4Demuxer {
+  [Symbol.asyncIterator](): AsyncGenerator<DemuxerChunk, void, void>
+}
+
+/**
+ * Adds async iterator support to WebMDemuxer.
+ * Declaration merging allows using `for await...of` with the demuxer.
+ */
+export interface WebMDemuxer {
+  [Symbol.asyncIterator](): AsyncGenerator<DemuxerChunk, void, void>
+}
+
+/**
+ * Adds async iterator support to MkvDemuxer.
+ * Declaration merging allows using `for await...of` with the demuxer.
+ */
+export interface MkvDemuxer {
+  [Symbol.asyncIterator](): AsyncGenerator<DemuxerChunk, void, void>
+}
+
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array
 /**
  * AudioData - represents uncompressed audio data
  *
@@ -242,7 +285,7 @@ export declare class AudioDecoder {
    *
    * @param init - Init dictionary containing output and error callbacks
    */
-  constructor(init: { output: (data: AudioData) => void; error: (error: Error) => void })
+  constructor(init: { output: (data: AudioData) => void, error: (error: Error) => void })
   /** Get decoder state */
   get state(): CodecState
   /** Get number of pending decode operations (per WebCodecs spec) */
@@ -282,17 +325,9 @@ export declare class AudioDecoder {
    */
   static isConfigSupported(config: AudioDecoderConfig): Promise<AudioDecoderSupport>
   /** Add an event listener for the specified event type */
-  addEventListener(
-    eventType: string,
-    callback: () => unknown,
-    options?: AudioDecoderAddEventListenerOptions | undefined | null,
-  ): void
+  addEventListener(eventType: string, callback: () => unknown, options?: AudioDecoderAddEventListenerOptions | undefined | null): void
   /** Remove an event listener for the specified event type */
-  removeEventListener(
-    eventType: string,
-    callback: () => unknown,
-    options?: AudioDecoderEventListenerOptions | undefined | null,
-  ): void
+  removeEventListener(eventType: string, callback: () => unknown, options?: AudioDecoderEventListenerOptions | undefined | null): void
   /** Dispatch an event to all registered listeners */
   dispatchEvent(eventType: string): boolean
 }
@@ -327,10 +362,7 @@ export declare class AudioEncoder {
    *
    * @param init - Init dictionary containing output and error callbacks
    */
-  constructor(init: {
-    output: (chunk: EncodedAudioChunk, metadata?: EncodedAudioChunkMetadata) => void
-    error: (error: Error) => void
-  })
+  constructor(init: { output: (chunk: EncodedAudioChunk, metadata?: EncodedAudioChunkMetadata) => void, error: (error: Error) => void })
   /** Get encoder state */
   get state(): CodecState
   /** Get number of pending encode operations (per WebCodecs spec) */
@@ -373,17 +405,9 @@ export declare class AudioEncoder {
    * Add an event listener for the specified event type
    * Uses separate RwLock to avoid blocking on encode operations
    */
-  addEventListener(
-    eventType: string,
-    callback: () => unknown,
-    options?: AudioEncoderAddEventListenerOptions | undefined | null,
-  ): void
+  addEventListener(eventType: string, callback: () => unknown, options?: AudioEncoderAddEventListenerOptions | undefined | null): void
   /** Remove an event listener for the specified event type */
-  removeEventListener(
-    eventType: string,
-    callback: () => unknown,
-    options?: AudioEncoderEventListenerOptions | undefined | null,
-  ): void
+  removeEventListener(eventType: string, callback: () => unknown, options?: AudioEncoderEventListenerOptions | undefined | null): void
   /** Dispatch an event to all registered listeners */
   dispatchEvent(eventType: string): boolean
 }
@@ -394,12 +418,7 @@ export declare class AudioEncoder {
  */
 export declare class DOMRectReadOnly {
   /** Create a new DOMRectReadOnly */
-  constructor(
-    x?: number | undefined | null,
-    y?: number | undefined | null,
-    width?: number | undefined | null,
-    height?: number | undefined | null,
-  )
+  constructor(x?: number | undefined | null, y?: number | undefined | null, width?: number | undefined | null, height?: number | undefined | null)
   /** X coordinate */
   get x(): number
   /** Y coordinate */
@@ -561,6 +580,11 @@ export declare class ImageTrackList {
  * MKV Demuxer for reading encoded video and audio from Matroska container
  *
  * MKV supports almost any video and audio codec.
+ *
+ * This type implements JavaScript's async iterable protocol.
+ * It can be used with `for await...of` loops.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols
  */
 export declare class MkvDemuxer {
   constructor(init: MkvDemuxerInit)
@@ -579,6 +603,8 @@ export declare class MkvDemuxer {
   selectVideoTrack(trackIndex: number): void
   selectAudioTrack(trackIndex: number): void
   demux(count?: number | undefined | null): void
+  /** Demux packets asynchronously (awaitable version of demux) */
+  demuxAsync(count?: number | undefined | null): Promise<void>
   seek(timestampUs: number): void
   close(): void
   get state(): string
@@ -673,6 +699,11 @@ export declare class MkvMuxer {
  *
  * demuxer.close();
  * ```
+ *
+ * This type implements JavaScript's async iterable protocol.
+ * It can be used with `for await...of` loops.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols
  */
 export declare class Mp4Demuxer {
   /** Create a new MP4 demuxer */
@@ -705,6 +736,20 @@ export declare class Mp4Demuxer {
    * Otherwise, reads all packets until end of stream.
    */
   demux(count?: number | undefined | null): void
+  /**
+   * Demux packets asynchronously (awaitable version of demux)
+   *
+   * If count is specified, reads up to that many packets.
+   * Otherwise, reads all packets until end of stream.
+   * Returns a Promise that resolves when demuxing is complete.
+   *
+   * This method is useful when you want to wait for demuxing to finish
+   * before proceeding with other operations.
+   *
+   * Note: For streaming use cases, prefer the async iterator pattern:
+   * `for await (const chunk of demuxer) { ... }`
+   */
+  demuxAsync(count?: number | undefined | null): Promise<void>
   /** Seek to a timestamp in microseconds */
   seek(timestampUs: number): void
   /** Close the demuxer and release resources */
@@ -839,7 +884,7 @@ export declare class VideoDecoder {
    *
    * @param init - Init dictionary containing output and error callbacks
    */
-  constructor(init: { output: (frame: VideoFrame) => void; error: (error: Error) => void })
+  constructor(init: { output: (frame: VideoFrame) => void, error: (error: Error) => void })
   /** Get decoder state */
   get state(): CodecState
   /** Get number of pending decode operations (per WebCodecs spec) */
@@ -889,17 +934,9 @@ export declare class VideoDecoder {
    * Add an event listener for the specified event type
    * Uses separate RwLock to avoid blocking on decode operations
    */
-  addEventListener(
-    eventType: string,
-    callback: () => unknown,
-    options?: VideoDecoderAddEventListenerOptions | undefined | null,
-  ): void
+  addEventListener(eventType: string, callback: () => unknown, options?: VideoDecoderAddEventListenerOptions | undefined | null): void
   /** Remove an event listener for the specified event type */
-  removeEventListener(
-    eventType: string,
-    callback: () => unknown,
-    options?: VideoDecoderEventListenerOptions | undefined | null,
-  ): void
+  removeEventListener(eventType: string, callback: () => unknown, options?: VideoDecoderEventListenerOptions | undefined | null): void
   /** Dispatch an event to all registered listeners */
   dispatchEvent(eventType: string): boolean
 }
@@ -935,10 +972,7 @@ export declare class VideoEncoder {
    *
    * @param init - Init dictionary containing output and error callbacks
    */
-  constructor(init: {
-    output: (chunk: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata) => void
-    error: (error: Error) => void
-  })
+  constructor(init: { output: (chunk: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata) => void, error: (error: Error) => void })
   /** Get encoder state */
   get state(): CodecState
   /** Get number of pending encode operations (per WebCodecs spec) */
@@ -973,17 +1007,9 @@ export declare class VideoEncoder {
    * Add an event listener for the specified event type
    * Uses separate RwLock to avoid blocking on encode operations
    */
-  addEventListener(
-    eventType: string,
-    callback: () => unknown,
-    options?: AddEventListenerOptions | undefined | null,
-  ): void
+  addEventListener(eventType: string, callback: () => unknown, options?: AddEventListenerOptions | undefined | null): void
   /** Remove an event listener for the specified event type */
-  removeEventListener(
-    eventType: string,
-    callback: () => unknown,
-    options?: EventListenerOptions | undefined | null,
-  ): void
+  removeEventListener(eventType: string, callback: () => unknown, options?: EventListenerOptions | undefined | null): void
   /** Dispatch an event to all registered listeners */
   dispatchEvent(eventType: string): boolean
   /**
@@ -1079,7 +1105,12 @@ export declare class VideoFrame {
    * Options can specify target format and rect for cropped copy.
    */
   copyTo(destination: Uint8Array, options?: VideoFrameCopyToOptions | undefined | null): Promise<Array<PlaneLayout>>
-  /** Clone this VideoFrame */
+  /**
+   * Clone this VideoFrame
+   *
+   * This creates a new VideoFrame that shares the underlying pixel data with the original.
+   * Both frames will reference the same Arc<RwLock<Frame>>, so no pixel data is copied.
+   */
   clone(): VideoFrame
   /**
    * Close and release resources
@@ -1095,6 +1126,11 @@ export declare class VideoFrame {
  * WebM Demuxer for reading encoded video and audio from WebM container
  *
  * WebM typically contains VP8, VP9, or AV1 video with Opus or Vorbis audio.
+ *
+ * This type implements JavaScript's async iterable protocol.
+ * It can be used with `for await...of` loops.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_async_iterator_and_async_iterable_protocols
  */
 export declare class WebMDemuxer {
   constructor(init: WebMDemuxerInit)
@@ -1113,6 +1149,8 @@ export declare class WebMDemuxer {
   selectVideoTrack(trackIndex: number): void
   selectAudioTrack(trackIndex: number): void
   demux(count?: number | undefined | null): void
+  /** Demux packets asynchronously (awaitable version of demux) */
+  demuxAsync(count?: number | undefined | null): Promise<void>
   seek(timestampUs: number): void
   close(): void
   get state(): string
@@ -1180,9 +1218,9 @@ export declare class WebMMuxer {
 
 /** AAC bitstream format (W3C WebCodecs AAC Registration) */
 export type AacBitstreamFormat = /** Raw AAC frames - metadata in description */
-  | 'aac'
-  /** ADTS frames - metadata in each frame */
-  | 'adts'
+'aac'|
+/** ADTS frames - metadata in each frame */
+'adts';
 
 /** AAC encoder configuration (W3C WebCodecs AAC Registration) */
 export interface AacEncoderConfig {
@@ -1202,9 +1240,9 @@ export interface AddEventListenerOptions {
  * Default is "discard" per spec
  */
 export type AlphaOption = /** Keep alpha channel if present */
-  | 'keep'
-  /** Discard alpha channel (default per W3C spec) */
-  | 'discard'
+'keep'|
+/** Discard alpha channel (default per W3C spec) */
+'discard';
 
 /** Options for copyTo operation */
 export interface AudioDataCopyToOptions {
@@ -1270,7 +1308,9 @@ export interface AudioEncoderAddEventListenerOptions {
 }
 
 /** Encode options for audio */
-export interface AudioEncoderEncodeOptions {}
+export interface AudioEncoderEncodeOptions {
+
+}
 
 /** Options for removeEventListener (W3C DOM spec) */
 export interface AudioEncoderEventListenerOptions {
@@ -1287,27 +1327,27 @@ export interface AudioEncoderSupport {
 
 /** Audio sample format (WebCodecs spec) */
 export type AudioSampleFormat = /** Unsigned 8-bit integer samples| interleaved */
-  | 'u8'
-  /** Signed 16-bit integer samples| interleaved */
-  | 's16'
-  /** Signed 32-bit integer samples| interleaved */
-  | 's32'
-  /** 32-bit float samples| interleaved */
-  | 'f32'
-  /** Unsigned 8-bit integer samples| planar */
-  | 'u8-planar'
-  /** Signed 16-bit integer samples| planar */
-  | 's16-planar'
-  /** Signed 32-bit integer samples| planar */
-  | 's32-planar'
-  /** 32-bit float samples| planar */
-  | 'f32-planar'
+'u8'|
+/** Signed 16-bit integer samples| interleaved */
+'s16'|
+/** Signed 32-bit integer samples| interleaved */
+'s32'|
+/** 32-bit float samples| interleaved */
+'f32'|
+/** Unsigned 8-bit integer samples| planar */
+'u8-planar'|
+/** Signed 16-bit integer samples| planar */
+'s16-planar'|
+/** Signed 32-bit integer samples| planar */
+'s32-planar'|
+/** 32-bit float samples| planar */
+'f32-planar';
 
 /** AVC (H.264) bitstream format (W3C WebCodecs AVC Registration) */
 export type AvcBitstreamFormat = /** AVC format with parameter sets in description (ISO 14496-15) */
-  | 'avc'
-  /** Annex B format with parameter sets in bitstream */
-  | 'annexb'
+'avc'|
+/** Annex B format with parameter sets in bitstream */
+'annexb';
 
 /** AVC (H.264) encoder configuration (W3C WebCodecs AVC Registration) */
 export interface AvcEncoderConfig {
@@ -1317,23 +1357,23 @@ export interface AvcEncoderConfig {
 
 /** Bitrate mode for audio encoding (W3C WebCodecs spec) */
 export type BitrateMode = /** Variable bitrate (default) */
-  | 'variable'
-  /** Constant bitrate */
-  | 'constant'
+'variable'|
+/** Constant bitrate */
+'constant';
 
 /** Encoder state per WebCodecs spec */
 export type CodecState = /** Encoder not configured */
-  | 'unconfigured'
-  /** Encoder configured and ready */
-  | 'configured'
-  /** Encoder closed */
-  | 'closed'
+'unconfigured'|
+/** Encoder configured and ready */
+'configured'|
+/** Encoder closed */
+'closed';
 
 /** ColorSpaceConversion for ImageDecoder (W3C WebCodecs spec) */
 export type ColorSpaceConversion = /** Apply default color space conversion (spec default) */
-  | 'default'
-  /** No color space conversion */
-  | 'none'
+'default'|
+/** No color space conversion */
+'none';
 
 /** Audio decoder configuration exposed to JavaScript */
 export interface DemuxerAudioDecoderConfig {
@@ -1401,9 +1441,9 @@ export interface EncodedAudioChunkMetadataJs {
 
 /** Type of encoded audio chunk */
 export type EncodedAudioChunkType = /** Key chunk - can be decoded independently */
-  | 'key'
-  /** Delta chunk - depends on previous chunks */
-  | 'delta'
+'key'|
+/** Delta chunk - depends on previous chunks */
+'delta';
 
 /** Output callback metadata per WebCodecs spec */
 export interface EncodedVideoChunkMetadata {
@@ -1421,13 +1461,19 @@ export interface EncodedVideoChunkMetadataJs {
   decoderConfig?: VideoDecoderConfigJs
   /** SVC output metadata */
   svc?: SvcOutputMetadataJs
+  /**
+   * Alpha channel side data (for VP9 alpha support)
+   * This contains the encoded alpha channel data that should be written
+   * as BlockAdditions in WebM/MKV containers.
+   */
+  alphaSideData?: Uint8Array
 }
 
 /** Type of encoded video chunk */
 export type EncodedVideoChunkType = /** Keyframe - can be decoded independently */
-  | 'key'
-  /** Delta frame - depends on previous frames */
-  | 'delta'
+'key'|
+/** Delta frame - depends on previous frames */
+'delta';
 
 /** Options for removeEventListener (W3C DOM spec) */
 export interface EventListenerOptions {
@@ -1453,11 +1499,11 @@ export declare function getPreferredHardwareAccelerator(): string | null
 
 /** Hardware acceleration preference (W3C WebCodecs spec) */
 export type HardwareAcceleration = /** No preference - may use hardware or software */
-  | 'no-preference'
-  /** Prefer hardware acceleration */
-  | 'prefer-hardware'
-  /** Prefer software implementation */
-  | 'prefer-software'
+'no-preference'|
+/** Prefer hardware acceleration */
+'prefer-hardware'|
+/** Prefer software implementation */
+'prefer-software';
 
 /** Hardware accelerator information */
 export interface HardwareAccelerator {
@@ -1471,9 +1517,9 @@ export interface HardwareAccelerator {
 
 /** HEVC (H.265) bitstream format (W3C WebCodecs HEVC Registration) */
 export type HevcBitstreamFormat = /** HEVC format with parameter sets in description (ISO 14496-15) */
-  | 'hevc'
-  /** Annex B format with parameter sets in bitstream */
-  | 'annexb'
+'hevc'|
+/** Annex B format with parameter sets in bitstream */
+'annexb';
 
 /** HEVC (H.265) encoder configuration (W3C WebCodecs HEVC Registration) */
 export interface HevcEncoderConfig {
@@ -1494,9 +1540,9 @@ export declare function isHardwareAcceleratorAvailable(name: string): boolean
 
 /** Latency mode for video encoding (W3C WebCodecs spec) */
 export type LatencyMode = /** Optimize for quality (default) */
-  | 'quality'
-  /** Optimize for low latency */
-  | 'realtime'
+'quality'|
+/** Optimize for low latency */
+'realtime';
 
 /** Audio track configuration for MKV muxer */
 export interface MkvAudioTrackConfig {
@@ -1526,6 +1572,8 @@ export interface MkvVideoTrackConfig {
   width: number
   /** Video height in pixels */
   height: number
+  /** Frame rate (frames per second) */
+  framerate?: number
   /** Codec-specific description data */
   description?: Uint8Array
 }
@@ -1566,23 +1614,25 @@ export interface Mp4VideoTrackConfig {
   width: number
   /** Video height in pixels */
   height: number
+  /** Frame rate (frames per second) */
+  framerate?: 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'
-  /** Optimize for audio fidelity (default) */
-  | 'audio'
-  /** Minimize coding delay */
-  | 'lowdelay'
+'voip'|
+/** Optimize for audio fidelity (default) */
+'audio'|
+/** Minimize coding delay */
+'lowdelay';
 
 /** Opus bitstream format (W3C WebCodecs Opus Registration) */
 export type OpusBitstreamFormat = /** Opus packets (RFC 6716) - no metadata needed for decoding */
-  | 'opus'
-  /** Ogg encapsulation (RFC 7845) - metadata in description */
-  | 'ogg'
+'opus'|
+/** Ogg encapsulation (RFC 7845) - metadata in description */
+'ogg';
 
 /** Opus encoder configuration (W3C WebCodecs Opus Registration) */
 export interface OpusEncoderConfig {
@@ -1609,11 +1659,11 @@ export interface OpusEncoderConfig {
 
 /** Opus signal type hint (W3C WebCodecs Opus Registration) */
 export type OpusSignal = /** Auto-detect signal type */
-  | 'auto'
-  /** Music signal */
-  | 'music'
-  /** Voice/speech signal */
-  | 'voice'
+'auto'|
+/** Music signal */
+'music'|
+/** Voice/speech signal */
+'voice';
 
 /** Layout information for a single plane per WebCodecs spec */
 export interface PlaneLayout {
@@ -1654,15 +1704,15 @@ export interface SvcOutputMetadataJs {
 
 /** Video color primaries (W3C WebCodecs spec) */
 export type VideoColorPrimaries = /** BT.709 / sRGB primaries */
-  | 'bt709'
-  /** BT.470 BG (PAL) */
-  | 'bt470bg'
-  /** SMPTE 170M (NTSC) */
-  | 'smpte170m'
-  /** BT.2020 (UHD) */
-  | 'bt2020'
-  /** SMPTE 432 (DCI-P3) */
-  | 'smpte432'
+'bt709'|
+/** BT.470 BG (PAL) */
+'bt470bg'|
+/** SMPTE 170M (NTSC) */
+'smpte170m'|
+/** BT.2020 (UHD) */
+'bt2020'|
+/** SMPTE 432 (DCI-P3) */
+'smpte432';
 
 /** Options for addEventListener (W3C DOM spec) */
 export interface VideoDecoderAddEventListenerOptions {
@@ -1720,11 +1770,11 @@ export interface VideoDecoderSupport {
 
 /** Bitrate mode for video encoding (W3C WebCodecs spec) */
 export type VideoEncoderBitrateMode = /** Variable bitrate (default) */
-  | 'variable'
-  /** Constant bitrate */
-  | 'constant'
-  /** Use quantizer parameter from codec-specific options */
-  | 'quantizer'
+'variable'|
+/** Constant bitrate */
+'constant'|
+/** Use quantizer parameter from codec-specific options */
+'quantizer';
 
 /** Encode options per WebCodecs spec */
 export interface VideoEncoderEncodeOptions {
@@ -1742,7 +1792,7 @@ export interface VideoEncoderEncodeOptions {
 
 /** AV1 encode options (W3C WebCodecs AV1 Registration) */
 export interface VideoEncoderEncodeOptionsForAv1 {
-  /** Per-frame quantizer (0-63, lower = higher quality) */
+  /** Per-frame quantizer (0-255, lower = higher quality) */
   quantizer?: number
 }
 
@@ -1760,7 +1810,7 @@ export interface VideoEncoderEncodeOptionsForHevc {
 
 /** VP9 encode options (W3C WebCodecs VP9 Registration) */
 export interface VideoEncoderEncodeOptionsForVp9 {
-  /** Per-frame quantizer (0-63, lower = higher quality) */
+  /** Per-frame quantizer (0-255, lower = higher quality) */
   quantizer?: number
 }
 
@@ -1808,7 +1858,9 @@ export interface VideoFrameInit {
  * VideoFrameMetadata - metadata associated with a VideoFrame (W3C spec)
  * Members defined in VideoFrame Metadata Registry - currently empty per spec
  */
-export interface VideoFrameMetadata {}
+export interface VideoFrameMetadata {
+
+}
 
 /** Rectangle for specifying a region */
 export interface VideoFrameRect {
@@ -1820,75 +1872,75 @@ export interface VideoFrameRect {
 
 /** Video matrix coefficients (W3C WebCodecs spec) */
 export type VideoMatrixCoefficients = /** RGB (identity matrix) */
-  | 'rgb'
-  /** BT.709 */
-  | 'bt709'
-  /** BT.470 BG */
-  | 'bt470bg'
-  /** SMPTE 170M */
-  | 'smpte170m'
-  /** BT.2020 non-constant luminance */
-  | 'bt2020-ncl'
+'rgb'|
+/** BT.709 */
+'bt709'|
+/** BT.470 BG */
+'bt470bg'|
+/** SMPTE 170M */
+'smpte170m'|
+/** BT.2020 non-constant luminance */
+'bt2020-ncl';
 
 /** Video pixel format (WebCodecs spec) */
 export type VideoPixelFormat = /** Planar YUV 4:2:0| 12bpp| (1 Cr & Cb sample per 2x2 Y samples) */
-  | 'I420'
-  /** Planar YUV 4:2:0| 12bpp| with alpha plane */
-  | 'I420A'
-  /** Planar YUV 4:2:2| 16bpp */
-  | 'I422'
-  /** Planar YUV 4:2:2| 16bpp| with alpha plane */
-  | 'I422A'
-  /** Planar YUV 4:4:4| 24bpp */
-  | 'I444'
-  /** Planar YUV 4:4:4| 24bpp| with alpha plane */
-  | 'I444A'
-  /** Planar YUV 4:2:0| 10-bit */
-  | 'I420P10'
-  /** Planar YUV 4:2:0| 10-bit| with alpha plane */
-  | 'I420AP10'
-  /** Planar YUV 4:2:2| 10-bit */
-  | 'I422P10'
-  /** Planar YUV 4:2:2| 10-bit| with alpha plane */
-  | 'I422AP10'
-  /** Planar YUV 4:4:4| 10-bit */
-  | 'I444P10'
-  /** Planar YUV 4:4:4| 10-bit| with alpha plane */
-  | 'I444AP10'
-  /** Planar YUV 4:2:0| 12-bit */
-  | 'I420P12'
-  /** Planar YUV 4:2:2| 12-bit */
-  | 'I422P12'
-  /** Planar YUV 4:4:4| 12-bit */
-  | 'I444P12'
-  /** Semi-planar YUV 4:2:0| 12bpp (Y plane + interleaved UV) */
-  | 'NV12'
-  /** Semi-planar YUV 4:2:0| 12bpp (Y plane + interleaved VU) - per W3C WebCodecs spec */
-  | 'NV21'
-  /** RGBA 32bpp */
-  | 'RGBA'
-  /** RGBX 32bpp (alpha ignored) */
-  | 'RGBX'
-  /** BGRA 32bpp */
-  | 'BGRA'
-  /** BGRX 32bpp (alpha ignored) */
-  | 'BGRX'
+'I420'|
+/** Planar YUV 4:2:0| 12bpp| with alpha plane */
+'I420A'|
+/** Planar YUV 4:2:2| 16bpp */
+'I422'|
+/** Planar YUV 4:2:2| 16bpp| with alpha plane */
+'I422A'|
+/** Planar YUV 4:4:4| 24bpp */
+'I444'|
+/** Planar YUV 4:4:4| 24bpp| with alpha plane */
+'I444A'|
+/** Planar YUV 4:2:0| 10-bit */
+'I420P10'|
+/** Planar YUV 4:2:0| 10-bit| with alpha plane */
+'I420AP10'|
+/** Planar YUV 4:2:2| 10-bit */
+'I422P10'|
+/** Planar YUV 4:2:2| 10-bit| with alpha plane */
+'I422AP10'|
+/** Planar YUV 4:4:4| 10-bit */
+'I444P10'|
+/** Planar YUV 4:4:4| 10-bit| with alpha plane */
+'I444AP10'|
+/** Planar YUV 4:2:0| 12-bit */
+'I420P12'|
+/** Planar YUV 4:2:2| 12-bit */
+'I422P12'|
+/** Planar YUV 4:4:4| 12-bit */
+'I444P12'|
+/** Semi-planar YUV 4:2:0| 12bpp (Y plane + interleaved UV) */
+'NV12'|
+/** Semi-planar YUV 4:2:0| 12bpp (Y plane + interleaved VU) - per W3C WebCodecs spec */
+'NV21'|
+/** RGBA 32bpp */
+'RGBA'|
+/** RGBX 32bpp (alpha ignored) */
+'RGBX'|
+/** BGRA 32bpp */
+'BGRA'|
+/** BGRX 32bpp (alpha ignored) */
+'BGRX';
 
 /** Video transfer characteristics (W3C WebCodecs spec) */
 export type VideoTransferCharacteristics = /** BT.709 transfer */
-  | 'bt709'
-  /** SMPTE 170M transfer */
-  | 'smpte170m'
-  /** IEC 61966-2-1 (sRGB) - technical name */
-  | 'iec61966-2-1'
-  /** sRGB transfer (alias for iec61966-2-1) */
-  | 'srgb'
-  /** Linear transfer */
-  | 'linear'
-  /** Perceptual Quantizer (HDR) */
-  | 'pq'
-  /** Hybrid Log-Gamma (HDR) */
-  | 'hlg'
+'bt709'|
+/** SMPTE 170M transfer */
+'smpte170m'|
+/** IEC 61966-2-1 (sRGB) - technical name */
+'iec61966-2-1'|
+/** sRGB transfer (alias for iec61966-2-1) */
+'srgb'|
+/** Linear transfer */
+'linear'|
+/** Perceptual Quantizer (HDR) */
+'pq'|
+/** Hybrid Log-Gamma (HDR) */
+'hlg';
 
 /** Audio track configuration for WebM muxer */
 export interface WebMAudioTrackConfig {
@@ -1918,6 +1970,10 @@ export interface WebMVideoTrackConfig {
   width: number
   /** Video height in pixels */
   height: number
+  /** Frame rate (frames per second) */
+  framerate?: number
   /** Codec-specific description data */
   description?: Uint8Array
+  /** Whether the video has alpha channel (VP9 alpha support) */
+  alpha?: boolean
 }