@audio/encode 1.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dmitry Iv.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,140 @@
+# @audio/encode [![test](https://github.com/audiojs/encode/actions/workflows/test.js.yml/badge.svg)](https://github.com/audiojs/encode/actions/workflows/test.js.yml)
+
+Encode raw audio samples to any format.<br>
+JS / WASM – no ffmpeg, no native bindings, works in both node and browser.<br>
+Small API, minimal size, near-native performance, stream encoding.
+
+[![npm install @audio/encode](https://nodei.co/npm/encode-audio.png?mini=true)](https://npmjs.org/package/@audio/encode/)
+
+```js
+import encode from '@audio/encode';
+
+const buf = await encode.wav(channelData, { sampleRate: 44100 });
+```
+
+#### Supported formats:
+
+| Format | Package | Engine |
+|--------|---------|--------|
+| WAV | [@audio/encode-wav](https://npmjs.com/package/@audio/encode-wav) | JS |
+| 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
+
+Specify the format as method name. Input is _Float32Array[]_ (one per channel), a single _Float32Array_ (mono), or an [AudioBuffer](https://npmjs.com/package/audio-buffer).
+
+```js
+import encode from '@audio/encode';
+
+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:
+
+```js
+import encode from '@audio/encode';
+
+const enc = await encode.mp3({ sampleRate: 44100, bitrate: 128 });
+
+const a = await enc(chunk1);  // Uint8Array
+const b = await enc(chunk2);
+const c = await enc(null);        // end of stream — flush + free
+
+// explicit control: enc.flush(), enc.free()
+```
+
+### Streaming
+
+Pass an async iterable as data — returns an async generator:
+
+```js
+import encode from '@audio/encode'
+
+for await (let buf of encode.mp3(audioSource, { sampleRate: 44100, bitrate: 128 })) {
+  // buf is Uint8Array
+}
+```
+
+Works with any async iterable source.
+
+### Options
+
+| Option | Description | Applies to |
+|--------|-------------|------------|
+| `sampleRate` | Output sample rate (required) | all |
+| `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/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, webm |
+| `meta` | Tags (see below) | wav, mp3, flac, aiff, ogg, opus |
+
+
+### Metadata
+
+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 `@audio/encode/meta`:
+
+```js
+import { wav } from '@audio/encode/meta'
+
+let out = wav(bytes, {
+  meta: { title: 'Hare Krishna', artist: 'Prabhupada', year: '1966' },
+  markers: [{ sample: 44100, label: 'verse' }],
+  regions: [{ sample: 88200, length: 44100, label: 'chorus' }]
+})
+```
+
+Each codec sub-package also exposes its writer directly:
+
+```js
+import { writeMeta } from '@audio/encode-mp3/meta'
+let tagged = writeMeta(mp3Bytes, { meta: { title: 'foo' } })
+```
+
+
+## See also
+
+* [decode](https://github.com/audiojs/decode) – decode any audio format to raw samples.
+* [wasm-media-encoders](https://github.com/arseneyr/wasm-media-encoders) – compact WASM MP3 & Vorbis encoders.
+* [AudioEncoder](https://developer.mozilla.org/en-US/docs/Web/API/AudioEncoder) – native WebCodecs encoder API.
+
+## License
+
+[MIT](LICENSE)
+
+<a href="https://github.com/krishnized/license/">ॐ</a>

package/audio-encode.d.ts

@@ -0,0 +1,106 @@
+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: mp3, opus, webm, aac). */
+	bitrate?: number;
+	/** Quality 0-10 (VBR, format-specific: ogg, mp3). */
+	quality?: number;
+	/** 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/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;
+}
+
+export interface StreamEncoder {
+	/** Encode a chunk of audio. */
+	(channelData: AudioInput): Promise<Uint8Array>;
+	/** Flush remaining data, finalize, and free resources. */
+	(): Promise<Uint8Array>;
+	/** Flush without freeing. */
+	flush(): Promise<Uint8Array>;
+	/** Free resources without flushing. */
+	free(): void;
+}
+
+export interface FormatEncoder {
+	/** Whole-file encode. */
+	(channelData: AudioInput, opts: EncodeOptions): Promise<Uint8Array>;
+	/** Chunked encode from async iterable. */
+	(source: AsyncIterable<AudioInput>, opts: EncodeOptions): AsyncGenerator<Uint8Array>;
+	/** Create streaming encoder. */
+	(opts: EncodeOptions): Promise<StreamEncoder>;
+}
+
+declare const encode: {
+	/** Whole-file encode. */
+	(format: string, channelData: AudioInput, opts: EncodeOptions): Promise<Uint8Array>;
+	/** Chunked encode from async iterable. */
+	(format: string, source: AsyncIterable<AudioInput>, opts: EncodeOptions): AsyncGenerator<Uint8Array>;
+	/** Create streaming encoder. */
+	(format: string, opts: EncodeOptions): Promise<StreamEncoder>;
+
+	wav: FormatEncoder;
+	aiff: FormatEncoder;
+	caf: FormatEncoder;
+	mp3: FormatEncoder;
+	ogg: FormatEncoder;
+	flac: FormatEncoder;
+	opus: 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>,
+	format: string,
+	opts: EncodeOptions
+): AsyncGenerator<Uint8Array>;
+
+/** Wrap codec callbacks into a StreamEncoder with lifecycle management. */
+export function streamEncoder(
+	onEncode: (channels: Float32Array[]) => Uint8Array | Promise<Uint8Array>,
+	onFlush?: (() => Uint8Array | Promise<Uint8Array>) | null,
+	onFree?: (() => void) | null
+): StreamEncoder;

package/audio-encode.js

@@ -0,0 +1,215 @@
+/**
+ * Audio encoder: whole-file and chunked
+ * @module encode-audio
+ *
+ * let buf = await encode.wav(channelData, { sampleRate: 44100 })
+ *
+ * for await (let bytes of encode.mp3(source, { sampleRate: 44100 })) { ... }
+ *
+ * let enc = await encode.mp3({ sampleRate: 44100, bitrate: 128 })
+ * let chunk = await enc(channelData)
+ * let final = await enc() // flush + free
+ */
+
+const EMPTY = new Uint8Array(0)
+
+/**
+ * Encode audio — delegates to format-specific encoder.
+ * encode('wav', channelData, { sampleRate })      → Promise<Uint8Array>
+ * encode('wav', source(), { sampleRate })          → AsyncGenerator<Uint8Array>
+ * encode('wav', { sampleRate })                    → Promise<StreamEncoder>
+ */
+function encode(format, data, opts) {
+	if (!encode[format]) throw Error('Unknown format: ' + format)
+	return encode[format](data, opts)
+}
+export default encode
+
+function isAudioData(d) {
+	return d instanceof Float32Array || Array.isArray(d) || (d?.getChannelData && d?.numberOfChannels)
+}
+
+/**
+ * Encode a stream of PCM chunks to the given format.
+ * @param {AsyncIterable<Float32Array[]|Float32Array>} source
+ * @param {string} format
+ * @param {object} opts - encoder options (sampleRate required)
+ * @returns {AsyncGenerator<Uint8Array>}
+ */
+async function* encodeChunked(source, format, opts) {
+	let enc = await encode[format](opts)
+	try {
+		for await (let chunk of source) {
+			let buf = await enc(chunk)
+			if (buf.length) yield buf
+		}
+		let final = await enc()
+		if (final.length) yield final
+	} catch (e) { enc.free(); throw e }
+}
+export { encodeChunked }
+
+// --- format registration ---
+
+// Lazy-loaded meta writers (per-format), keyed by format name. Loaded on first
+// use when `meta`/`markers`/`regions` is passed to that format's encoder.
+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(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]()
+		let parts = []
+		return streamEncoder(
+			async ch => { let b = await codec.encode(ch); if (b?.length) parts.push(b); return EMPTY },
+			async () => {
+				let f = await codec.flush(); if (f?.length) parts.push(f)
+				let total = 0; for (let p of parts) total += p.length
+				let all = new Uint8Array(total), off = 0
+				for (let p of parts) { all.set(p, off); off += p.length }
+				return writeMeta(all, { meta: meta || {}, markers: markers || [], regions: regions || [] })
+			},
+			() => codec.free(),
+		)
+	})
+}
+
+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
+ * 1 arg (opts) → streaming encoder function
+ * 2 args (data, opts) → whole-file encode
+ */
+function fmt(name, init) {
+	let fn = (data, opts) => {
+		// 1 arg = streaming: encode.mp3({ sampleRate })
+		if (!opts) return init(data)
+		// 2 args, async iterable = chunked: encode.mp3(source(), { sampleRate })
+		if (data && (typeof data[Symbol.asyncIterator] === 'function' || typeof data[Symbol.iterator] === 'function' && !isAudioData(data)))
+			return encodeChunked(data, name, opts)
+		// 2 args = whole-file: encode.mp3(channelData, { sampleRate })
+		return wholeFile(data, opts, init)
+	}
+	return fn
+}
+
+async function wholeFile(data, opts, init) {
+	if (!opts.sampleRate) throw Error('sampleRate is required')
+	let ch = channels(data)
+	if (!ch.length || !ch[0].length) return EMPTY
+	let enc = await init({ channels: ch.length, ...opts })
+	try {
+		let result = await enc(ch)
+		let flushed = await enc()
+		return merge(result, flushed)
+	} catch (e) { enc.free(); throw e }
+}
+
+// normalize input to Float32Array[]
+function channels(data) {
+	if (!data) return []
+	if (Array.isArray(data)) {
+		if (data[0] instanceof Float32Array) return data
+		return []
+	}
+	if (data instanceof Float32Array) return [data]
+	// AudioBuffer or AudioBuffer-like ({ numberOfChannels, getChannelData })
+	if (data.getChannelData && data.numberOfChannels) {
+		let ch = []
+		for (let i = 0; i < data.numberOfChannels; i++) ch.push(data.getChannelData(i))
+		return ch
+	}
+	return []
+}
+
+/**
+ * StreamEncoder — a callable function:
+ * enc(channelData) — encode audio, returns Uint8Array
+ * enc()            — flush + finalize + free
+ * enc.flush()      — flush without freeing
+ * enc.free()       — release without flushing
+ */
+export function streamEncoder(onEncode, onFlush, onFree) {
+	let done = false
+	let fn = async (data) => {
+		if (data) {
+			if (done) throw Error('Encoder already freed')
+			let ch = channels(data)
+			try { return norm(await onEncode(ch)) }
+			catch (e) { done = true; onFree?.(); throw e }
+		}
+		// no args = end of stream
+		if (done) return EMPTY
+		done = true
+		try {
+			let result = onFlush ? norm(await onFlush()) : EMPTY
+			onFree?.()
+			return result
+		} catch (e) { onFree?.(); throw e }
+	}
+	fn.flush = async () => {
+		if (done) return EMPTY
+		return onFlush ? norm(await onFlush()) : EMPTY
+	}
+	fn.free = () => {
+		if (done) return
+		done = true
+		onFree?.()
+	}
+	return fn
+}
+
+// ensure Uint8Array
+function norm(r) {
+	if (!r?.length) return EMPTY
+	if (r instanceof Uint8Array) return r
+	if (r.buffer) return new Uint8Array(r.buffer, r.byteOffset, r.byteLength)
+	return new Uint8Array(r)
+}
+
+// concat two Uint8Arrays
+function merge(a, b) {
+	if (!b?.length) return a || EMPTY
+	if (!a?.length) return b || EMPTY
+	let out = new Uint8Array(a.length + b.length)
+	out.set(a)
+	out.set(b, a.length)
+	return out
+}

package/meta.js

@@ -0,0 +1,15 @@
+/**
+ * Meta writers — re-export from codec packages.
+ * @module 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'

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@audio/encode",
+  "version": "1.6.0",
+  "description": "Encode audio data in node or browser",
+  "type": "module",
+  "sideEffects": false,
+  "main": "audio-encode.js",
+  "types": "audio-encode.d.ts",
+  "exports": {
+    ".": {
+      "browser": "./audio-encode.js",
+      "node": "./audio-encode.js",
+      "default": "./audio-encode.js"
+    },
+    "./stream": "./stream.js",
+    "./meta": "./meta.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "audio-encode.js",
+    "audio-encode.d.ts",
+    "stream.js",
+    "stream.d.ts",
+    "meta.js",
+    "LICENSE"
+  ],
+  "workspaces": [
+    "packages/*"
+  ],
+  "scripts": {
+    "test": "node test.js",
+    "test:all": "npm test --workspaces && npm test",
+    "publish:all": "for d in packages/* .; do id=$(node -p \"require('./$d/package.json').name+'@'+require('./$d/package.json').version\"); npm view \"$id\" version >/dev/null 2>&1 && echo \"skip $id\" || (cd \"$d\" && npm publish); done",
+    "build": "npm run build --workspaces --if-present"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/encode.git"
+  },
+  "keywords": [
+    "audio",
+    "encode",
+    "encoder",
+    "codec",
+    "wav",
+    "mp3",
+    "ogg",
+    "vorbis",
+    "opus",
+    "flac",
+    "aiff",
+    "caf",
+    "webm",
+    "aac",
+    "qoa",
+    "pcm",
+    "streaming"
+  ],
+  "author": "Dmitry Iv. <dfcreative@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/audiojs/encode/issues"
+  },
+  "homepage": "https://github.com/audiojs/encode#readme",
+  "dependencies": {
+    "@audio/encode-aac": "^1.0.0",
+    "@audio/encode-aiff": "^1.1.0",
+    "@audio/encode-caf": "^1.0.0",
+    "@audio/encode-flac": "^1.1.0",
+    "@audio/encode-mp3": "^1.1.0",
+    "@audio/encode-ogg": "^1.1.0",
+    "@audio/encode-opus": "^1.1.0",
+    "@audio/encode-qoa": "^1.0.0",
+    "@audio/encode-wav": "^1.2.0",
+    "@audio/encode-webm": "^1.0.0"
+  },
+  "devDependencies": {
+    "audio-buffer": "^7.3.0",
+    "audio-decode": "^4.0.0",
+    "audio-lena": "^3.0.0",
+    "esbuild": "^0.28.0",
+    "tst": "^9.2.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/stream.d.ts

@@ -0,0 +1 @@
+export { encodeChunked as default, encodeChunked } from './audio-encode.js';

package/stream.js

@@ -0,0 +1,7 @@
+/**
+ * Chunked encoder — re-exports encodeChunked from main module.
+ * @module encode-audio/stream
+ *
+ * for await (let bytes of encode.mp3(pcmSource, { sampleRate: 44100 })) { ... }
+ */
+export { encodeChunked as default, encodeChunked } from './audio-encode.js'