Add WebM/AAC/QOA/CAF encoders, opus/aiff/ogg metadata, wav 24-bit

New format encoders:
- webm  — Opus in a Matroska/EBML container, reuses opusscript (no new WASM)
- aac   — ADTS via native WebCodecs AudioEncoder (browser-only; throws in Node)
- qoa   — Quite OK Audio (pure JS, wraps qoa-format)
- caf   — Core Audio Format LPCM (16-bit int / 32-bit float)

Metadata:
- opus — VorbisComment baked into OpusTags at encode time (stays streaming)
- aiff — ID3v2 chunk writer
- ogg  — VorbisComment rewrite, re-pages + re-CRCs, audio bit-identical
- route `meta` per-format; correct markers/regions to wav-only

Fixes:
- wav  — add 24-bit PCM; reject unsupported bitDepth (was silent corruption)
- aiff/caf — reject unsupported bitDepth (same silent-corruption class)
- remove empty packages/mp3-encode

API:
- encode.formats list + encode.mime map (named exports too)

Versions: encode-audio 1.6.0; encode-wav 1.2.0; encode-opus/aiff/ogg 1.1.0;
new encode-aac/caf/qoa/webm 1.0.0

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dy

README.md

@@ -20,8 +20,14 @@ const buf = await encode.wav(channelData, { sampleRate: 44100 });
 | MP3 | [@audio/encode-mp3](https://npmjs.com/package/@audio/encode-mp3) | WASM |
 | OGG Vorbis | [@audio/encode-ogg](https://npmjs.com/package/@audio/encode-ogg) | WASM |
 | Opus | [@audio/encode-opus](https://npmjs.com/package/@audio/encode-opus) | WASM |
+| WebM | [@audio/encode-webm](https://npmjs.com/package/@audio/encode-webm) | WASM (Opus) |
 | FLAC | [@audio/encode-flac](https://npmjs.com/package/@audio/encode-flac) | WASM |
+| AAC | [@audio/encode-aac](https://npmjs.com/package/@audio/encode-aac) | WebCodecs* |
 | AIFF | [@audio/encode-aiff](https://npmjs.com/package/@audio/encode-aiff) | JS |
+| CAF | [@audio/encode-caf](https://npmjs.com/package/@audio/encode-caf) | JS |
+| QOA | [@audio/encode-qoa](https://npmjs.com/package/@audio/encode-qoa) | JS |
+
+<sub>* AAC uses the native [WebCodecs](https://developer.mozilla.org/en-US/docs/Web/API/AudioEncoder) `AudioEncoder` — browser-only (Chromium/Safari), throws in Node.</sub>
 
 ### Whole-file encode
 
@@ -32,12 +38,18 @@ import encode from 'encode-audio';
 
 const wav  = await encode.wav(channelData, { sampleRate: 44100 });
 const aiff = await encode.aiff(channelData, { sampleRate: 44100 });
+const caf  = await encode.caf(channelData, { sampleRate: 44100 });
 const mp3  = await encode.mp3(channelData, { sampleRate: 44100, bitrate: 128 });
 const ogg  = await encode.ogg(channelData, { sampleRate: 44100, quality: 5 });
 const flac = await encode.flac(channelData, { sampleRate: 44100 });
 const opus = await encode.opus(channelData, { sampleRate: 48000, bitrate: 96 });
+const webm = await encode.webm(channelData, { sampleRate: 48000, bitrate: 96 });
+const qoa  = await encode.qoa(channelData, { sampleRate: 44100 });
+const aac  = await encode.aac(channelData, { sampleRate: 44100, bitrate: 128 }); // browser only
 ```
 
+`encode.formats` lists the supported names and `encode.mime` maps each to a MIME type — handy for format-agnostic pipelines.
+
 ### Chunked encoding
 
 Call with just options (no data) to create a streaming encoder:
@@ -73,23 +85,33 @@ Works with any async iterable source.
 | Option | Description | Applies to |
 |--------|-------------|------------|
 | `sampleRate` | Output sample rate (required) | all |
-| `bitrate` | Target bitrate in kbps | mp3, opus |
+| `bitrate` | Target bitrate in kbps | mp3, opus, webm, aac |
 | `quality` | Quality 0–10 (VBR) | ogg, mp3 |
 | `channels` | Output channel count | all |
-| `bitDepth` | Bit depth: 16 or 32 (wav), 16 or 24 (aiff, flac) | wav, aiff, flac |
+| `bitDepth` | Bit depth: 16/24/32 (wav), 16/24 (aiff, flac), 16/32 (caf) | wav, aiff, flac, caf |
 | `compression` | FLAC compression level 0–8 | flac |
-| `application` | `'audio'`, `'voip'`, or `'lowdelay'` | opus |
+| `application` | `'audio'`, `'voip'`, or `'lowdelay'` | opus, webm |
+| `meta` | Tags (see below) | wav, mp3, flac, aiff, ogg, opus |
 
 
 ### Metadata
 
-Splice tags, pictures, markers and regions into encoded bytes. Available for `wav`, `mp3`, `flac`.
+Pass `meta` (and, for `wav`, `markers`/`regions`) straight to the encoder:
+
+```js
+let bytes = await encode.flac(channelData, {
+  sampleRate: 44100,
+  meta: { title: 'Hare Krishna', artist: 'Prabhupada', year: '1966' }
+})
+```
+
+Tags work for `wav`, `mp3`, `flac`, `aiff`, `ogg` and `opus`. Cue `markers` and `regions` are `wav`-only. `opus` bakes tags into the OpusTags header at encode time (stays fully streaming); the others splice tags into the finished file — so passing `meta` to a **streaming/chunked** encode of `wav`/`mp3`/`flac`/`aiff`/`ogg` buffers the output and emits it on flush.
+
+You can also tag already-encoded bytes via `encode-audio/meta`:
 
 ```js
-import encode from 'encode-audio'
 import { wav } from 'encode-audio/meta'
 
-let bytes = await encode.wav(channelData, { sampleRate: 44100 })
 let out = wav(bytes, {
   meta: { title: 'Hare Krishna', artist: 'Prabhupada', year: '1966' },
   markers: [{ sample: 44100, label: 'verse' }],

audio-encode.d.ts

@@ -1,20 +1,38 @@
 type AudioInput = Float32Array[] | Float32Array | { numberOfChannels: number; getChannelData(i: number): Float32Array };
 
+export interface Meta {
+	title?: string; artist?: string; album?: string; albumartist?: string;
+	composer?: string; genre?: string; year?: string | number; track?: string | number;
+	disc?: string | number; bpm?: string | number; key?: string; comment?: string;
+	copyright?: string; isrc?: string; publisher?: string; software?: string; lyrics?: string;
+	pictures?: { mime?: string; description?: string; type?: number; data: Uint8Array }[];
+	[key: string]: any;
+}
+
+export interface Marker { sample: number; label?: string; }
+export interface Region { sample: number; length: number; label?: string; }
+
 export interface EncodeOptions {
 	/** Output sample rate (required). */
 	sampleRate: number;
 	/** Output channel count. */
 	channels?: number;
-	/** Target bitrate in kbps (lossy). */
+	/** Target bitrate in kbps (lossy: mp3, opus, webm, aac). */
 	bitrate?: number;
-	/** Quality 0-10 (VBR, format-specific). */
+	/** Quality 0-10 (VBR, format-specific: ogg, mp3). */
 	quality?: number;
-	/** Bit depth: 16|32 for wav, 16|24 for aiff/flac. */
+	/** Bit depth: 16|24|32 for wav, 16|24 for aiff/flac, 16|32 for caf. */
 	bitDepth?: number;
 	/** FLAC compression level 0-8. */
 	compression?: number;
-	/** Opus application: 'audio', 'voip', 'lowdelay'. */
+	/** Opus/WebM application: 'audio', 'voip', 'lowdelay'. */
 	application?: string;
+	/** Tags. Baked in for opus; for wav/mp3/flac/aiff/ogg also available via encode-audio/meta. */
+	meta?: Meta;
+	/** Cue markers (wav). */
+	markers?: Marker[];
+	/** Labeled regions (wav). */
+	regions?: Region[];
 	[key: string]: any;
 }
 
@@ -48,15 +66,31 @@ declare const encode: {
 
 	wav: FormatEncoder;
 	aiff: FormatEncoder;
+	caf: FormatEncoder;
 	mp3: FormatEncoder;
 	ogg: FormatEncoder;
 	flac: FormatEncoder;
 	opus: FormatEncoder;
-	[format: string]: FormatEncoder;
+	/** WebM (Opus). */
+	webm: FormatEncoder;
+	/** AAC (ADTS) — browser-only via WebCodecs; throws in Node. */
+	aac: FormatEncoder;
+	/** QOA (Quite OK Audio). */
+	qoa: FormatEncoder;
+	/** Supported format names. */
+	formats: string[];
+	/** Format → MIME type. */
+	mime: Record<string, string>;
+	[format: string]: any;
 };
 
 export default encode;
 
+/** Supported format names. */
+export const formats: string[];
+/** Format → MIME type map. */
+export const mime: Record<string, string>;
+
 /** Chunked encode from async iterable. */
 export function encodeChunked(
 	source: AsyncIterable<AudioInput>,

audio-encode.js

@@ -57,15 +57,22 @@ const META_WRITERS = {
 	wav: () => import('@audio/encode-wav/meta').then(m => m.writeMeta),
 	mp3: () => import('@audio/encode-mp3/meta').then(m => m.writeMeta),
 	flac: () => import('@audio/encode-flac/meta').then(m => m.writeMeta),
+	aiff: () => import('@audio/encode-aiff/meta').then(m => m.writeMeta),
+	ogg: () => import('@audio/encode-ogg/meta').then(m => m.writeMeta),
 }
 
+// Formats that bake metadata into the encoder itself (Ogg OpusTags) — streamed,
+// never buffered. The rest splice meta post-hoc via META_WRITERS on flush.
+const NATIVE_META = new Set(['opus'])
+
 function reg(name, load) {
 	encode[name] = fmt(name, async (opts) => {
 		let { meta, markers, regions, ...rest } = opts || {}
+		let hasMeta = meta || markers?.length || regions?.length
 		let init = (await load()).default
-		let codec = await init(rest)
-		// No meta requested (or unsupported by format): pass through.
-		if (!META_WRITERS[name] || !(meta || markers?.length || regions?.length))
+		let codec = await init(NATIVE_META.has(name) && hasMeta ? { ...rest, meta } : rest)
+		// Native-meta, no post-splice writer, or no meta requested: pass through.
+		if (NATIVE_META.has(name) || !META_WRITERS[name] || !hasMeta)
 			return streamEncoder(ch => codec.encode(ch), () => codec.flush(), () => codec.free())
 		// Meta requested: buffer encoder output, splice via writeMeta on flush.
 		let writeMeta = await META_WRITERS[name]()
@@ -86,10 +93,24 @@ function reg(name, load) {
 
 reg('wav', () => import('@audio/encode-wav'))
 reg('aiff', () => import('@audio/encode-aiff'))
+reg('caf', () => import('@audio/encode-caf'))
 reg('mp3', () => import('@audio/encode-mp3'))
 reg('ogg', () => import('@audio/encode-ogg'))
 reg('flac', () => import('@audio/encode-flac'))
 reg('opus', () => import('@audio/encode-opus'))
+reg('webm', () => import('@audio/encode-webm'))
+reg('aac', () => import('@audio/encode-aac'))
+reg('qoa', () => import('@audio/encode-qoa'))
+
+// Supported format names and their MIME types — for format-agnostic pipelines.
+export const formats = ['wav', 'aiff', 'caf', 'mp3', 'ogg', 'flac', 'opus', 'webm', 'aac', 'qoa']
+export const mime = {
+	wav: 'audio/wav', aiff: 'audio/aiff', caf: 'audio/x-caf',
+	mp3: 'audio/mpeg', ogg: 'audio/ogg', flac: 'audio/flac',
+	opus: 'audio/ogg', webm: 'audio/webm', aac: 'audio/aac', qoa: 'audio/qoa',
+}
+encode.formats = formats
+encode.mime = mime
 
 /**
  * Wrap a stream factory into whole-file encoder + streaming

meta.js

@@ -2,10 +2,14 @@
  * Meta writers — re-export from codec packages.
  * @module encode-audio/meta
  *
- * import { wav, mp3, flac } from 'encode-audio/meta'
+ * import { wav, mp3, flac, aiff, ogg } from 'encode-audio/meta'
  * let out = wav(bytes, { meta, markers, regions })
+ *
+ * Opus bakes tags at encode time — pass `meta` to `encode.opus(...)` directly.
  */
 
 export { writeMeta as wav } from '@audio/encode-wav/meta'
 export { writeMeta as mp3 } from '@audio/encode-mp3/meta'
 export { writeMeta as flac } from '@audio/encode-flac/meta'
+export { writeMeta as aiff } from '@audio/encode-aiff/meta'
+export { writeMeta as ogg } from '@audio/encode-ogg/meta'