@openclaw/whatsapp 2026.9.5 → 2026.9.7

package/node_modules/audio-decode/node_modules/@audio/decode-wavpack/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, audiojs
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

package/node_modules/audio-decode/node_modules/@audio/decode-wavpack/LICENSE.wavpack

@@ -0,0 +1,25 @@
+                  Copyright (c) 1998 - 2025 David Bryant
+                          All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the copyright holder nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/node_modules/audio-decode/node_modules/@audio/decode-wavpack/README.md

@@ -0,0 +1,41 @@
+# @audio/decode-wavpack [![npm](https://img.shields.io/npm/v/@audio/decode-wavpack)](https://www.npmjs.com/package/@audio/decode-wavpack) [![BSD-3-Clause](https://img.shields.io/badge/BSD--3--Clause-%E0%A5%90-white)](https://github.com/krishnized/license)
+
+Decode WavPack (.wv) to PCM float samples
+
+```
+npm install @audio/decode-wavpack
+```
+
+```js
+import decode, { decoder } from '@audio/decode-wavpack'
+```
+
+[libwavpack](https://github.com/dbry/WavPack) (the reference WavPack 5 implementation, David Bryant) compiled to a single-file WASM ES module — no side files, loads from any CDN, Node, workers and AudioWorklets. Handles everything the format defines: lossless and hybrid/lossy, 8/16/24/32-bit integer and 32-bit float, mono through multichannel, and DSD-as-PCM (`OPEN_DSD_AS_PCM`, decimated to 24-bit PCM by the library). Streaming decode drives libwavpack's own block reader through a memory-backed `WavpackStreamReader64`, so multichannel block groups and adaptive decorrelation state are handled exactly as the reference library handles them — this package only tracks byte-level block boundaries.
+
+```js
+let { channelData, sampleRate } = await decode(wvBytes)
+
+let dec = await decoder()
+let head = dec.decode(chunk1)   // synchronous; partial blocks carry over
+let tail = dec.flush()          // drops an incomplete trailing block, if any
+dec.free()
+```
+
+| Export | | |
+|---|---|---|
+| `decode(src)` | `Promise<AudioData>` | Whole-stream decode |
+| `decoder()` | `Promise<{decode, flush, free}>` | Streaming decoder; `decode(chunk)` is synchronous |
+
+`AudioData` is `{ channelData: Float32Array[], sampleRate: number }`, samples in `[-1, 1]`. Integer PCM is scaled by `2^(bits-1)` (asymmetric, matching WAV convention: max positive sample maps to `<1`, max negative to exactly `-1`); float PCM is a direct bit reinterpretation (WavPack stores float samples pre-normalized when opened with `OPEN_NORMALIZE`, which this package always sets). Channels come out in the order libwavpack reports them, which for standard Microsoft-ordered sources (anything ffmpeg or the WavPack CLI produces) is WAV order: FL, FR, FC, LFE, BL, BR, ...
+
+`decode()` drains every sample libwavpack can produce from the blocks fed so far, every call — there's no encoder lookahead or block-spanning delay to hold back, so `flush()` only ever discards an incomplete trailing block (a stream cut off mid-block) and returns nothing new.
+
+Hybrid/lossy WavPack (`-b<n>`) decodes at whatever quality it was encoded at; the `.wvc` correction file (lossless-hybrid two-file mode) is not read — only the standalone `.wv` bitstream. A garbage or non-WavPack input throws instead of returning empty/wrong data.
+
+**Use when:** you need a from-scratch, spec-accurate WavPack decoder in the browser or Node — audio tools reading `.wv` files, WavPack-in-container demuxers, or any pipeline that already speaks `@audio`'s `{channelData, sampleRate}` shape.
+
+---
+
+Part of [@audio/decode](https://github.com/audiojs/decode) — the decode family umbrella.
+
+[ॐ](https://github.com/krishnized/license/) · [BSD-3-Clause](./LICENSE), inherited from the bundled [libwavpack](./LICENSE.wavpack).

package/node_modules/audio-decode/node_modules/@audio/decode-wavpack/audio.d.ts

@@ -0,0 +1,15 @@
+// Generated from the audio.js manifest (params metadata is the source of truth).
+// Regenerate: node tools/dts.js in @audio/compile. Do not edit by hand.
+
+/** Automatable number — scalar, `t => value` fn, or breakpoint curve {t, v} */
+type Auto = number | ((t: number) => number) | { t: number[], v: number[] }
+/** Per-block param values as delivered by hosts (numbers arrive as 1-length Float32Array) */
+type Live = Record<string, Float32Array | string | boolean>
+type Ctx = { sampleRate: number, maxBlockSize: number, maxChannels: number, currentTime: number, duration?: number, events?: readonly any[], emit?: (name: string, ...args: any[]) => void, [k: string]: unknown }
+type Process = (inputs: Float32Array[][], outputs: Float32Array[][], params: Live) => void
+
+/** Codec plugin 'wv' — extends audio()'s openable formats / save() targets */
+export declare const wv: {
+  codec: 'wv'
+  decode(bytes: Uint8Array): { channelData: Float32Array[], sampleRate: number } | Promise<{ channelData: Float32Array[], sampleRate: number }>
+}

package/node_modules/audio-decode/node_modules/@audio/decode-wavpack/audio.js

@@ -0,0 +1,9 @@
+// audio.js manifest — codec atom, decode half: whole-buffer bytes → { channelData,
+// sampleRate }. Format detection is magic-byte (audio-type, 'wvpk' at offset 0) — no test() needed here.
+
+import decodeFn from './decode-wavpack.js'
+
+export const wv = {
+	codec: 'wv',
+	decode: (bytes) => decodeFn(bytes),
+}

package/node_modules/audio-decode/node_modules/@audio/decode-wavpack/decode-wavpack.d.ts

@@ -0,0 +1,18 @@
+export interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+interface WavpackDecoder {
+  /** Decode a chunk of a WavPack (.wv) stream synchronously. Partial blocks carry over to the next call. */
+  decode(data: Uint8Array | ArrayBuffer): AudioData;
+  /** Drop any incomplete trailing block. decode() already returns every decodable sample, so this yields nothing new. */
+  flush(): AudioData;
+  free(): void;
+}
+
+/** Decode a complete WavPack stream. Channels come out in WAV order (as libwavpack reports them). */
+export default function decode(src: ArrayBuffer | Uint8Array): Promise<AudioData>;
+
+/** Initialize WASM and create a decoder with synchronous methods. */
+export function decoder(): Promise<WavpackDecoder>;

package/node_modules/audio-decode/node_modules/@audio/decode-wavpack/decode-wavpack.js

@@ -0,0 +1,140 @@
+/**
+ * WavPack decoder — libwavpack compiled to WASM (single-file ES module, host-neutral).
+ * Streaming: the memory-backed WavpackStreamReader64 in the C glue lets libwavpack's own block
+ * reader drive decoding, so multichannel block groups, hybrid/lossy streams and DSD-as-PCM all
+ * decode exactly as the reference library would. JS only tracks byte-level block boundaries
+ * (the 32-byte block header's ckSize field) so it never hands the reader a partial block.
+ *
+ * let { channelData, sampleRate } = await decode(wvBuf)
+ * let dec = await decoder(); let result = dec.decode(chunk)
+ */
+import createWavpack from './src/wavpack.wasm.js'
+
+const EMPTY = Object.freeze({ channelData: [], sampleRate: 0 })
+const EMPTY_BYTES = new Uint8Array(0)
+const HEADER = 8            // bytes needed to read ckSize and know the full block size
+const MAX_BLOCK = 16 << 20  // sanity cap: no real WavPack block approaches 16 MiB
+
+let modP
+function getMod() {
+	if (modP) return modP
+	let p = createWavpack()
+	modP = p
+	return p.catch(e => { modP = null; throw e })
+}
+
+/**
+ * Whole-file decode
+ * @param {Uint8Array|ArrayBuffer} src
+ * @returns {Promise<{channelData: Float32Array[], sampleRate: number}>}
+ */
+export default async function decode(src) {
+	let buf = src instanceof Uint8Array ? src : new Uint8Array(src)
+	let dec = await decoder()
+	try { return dec.decode(buf) }
+	finally { dec.free() }
+}
+
+/** Create streaming decoder instance — decode() and flush() are synchronous. */
+export async function decoder() {
+	return new WavpackDecoder(await getMod())
+}
+
+class WavpackDecoder {
+	constructor(m) {
+		this.m = m
+		this.h = m._wv_create()
+		if (!this.h) throw Error('WavPack decoder allocation failed')
+		this.left = EMPTY_BYTES
+		this.sawBlock = false // true once at least one real block has been parsed (ever)
+		this.freed = false
+	}
+
+	decode(data) {
+		if (this.freed) throw Error('Decoder already freed')
+		if (!data || !data.byteLength) return EMPTY
+		let buf = data instanceof Uint8Array ? data : new Uint8Array(data)
+		let joined = this.left.length ? concat(this.left, buf) : buf
+
+		// Audio blocks are always contiguous from the start of the stream; anything after them
+		// (APEv2 tags, padding) does not start with 'wvpk' and is inert trailer, not corruption —
+		// only a magic/size mismatch before any real block has been seen is a hard error.
+		let pos = 0, seen = this.sawBlock
+		while (pos + HEADER <= joined.length) {
+			let isWvpk = joined[pos] === 0x77 && joined[pos + 1] === 0x76 && joined[pos + 2] === 0x70 && joined[pos + 3] === 0x6B
+			if (!isWvpk) {
+				if (!seen) throw Error('WavPack: not a WavPack stream (missing "wvpk" sync)')
+				break
+			}
+			let ckSize = (joined[pos + 4] | joined[pos + 5] << 8 | joined[pos + 6] << 16 | joined[pos + 7] << 24) >>> 0
+			let blockLen = ckSize + 8
+			if (blockLen < 32 || blockLen > MAX_BLOCK) {
+				if (!seen) throw Error('WavPack: implausible block size (corrupt stream?)')
+				break
+			}
+			if (pos + blockLen > joined.length) break // incomplete block — wait for more
+			pos += blockLen
+			seen = true
+		}
+		this.sawBlock = seen
+		this.left = pos < joined.length ? joined.subarray(pos).slice() : EMPTY_BYTES
+		if (!pos) return EMPTY
+
+		let m = this.m
+		let dst = m._wv_reserve(this.h, pos)
+		if (!dst) throw Error('WavPack: out of WASM memory')
+		m.HEAPU8.set(joined.subarray(0, pos), dst)
+		let n = m._wv_feed(this.h, pos)
+		if (n < 0) throw Error(readError(m, this.h))
+		if (!n) return EMPTY
+
+		let channels = m._wv_channels(this.h)
+		let sampleRate = m._wv_rate(this.h)
+		let bits = m._wv_bits(this.h)
+		let isFloat = m._wv_is_float(this.h)
+		let outPtr = m._wv_output(this.h)
+		let channelData = Array.from({ length: channels }, () => new Float32Array(n))
+
+		if (isFloat) {
+			let f32 = new Float32Array(m.HEAPU8.buffer, outPtr, n * channels)
+			for (let i = 0, k = 0; i < n; i++) for (let c = 0; c < channels; c++) channelData[c][i] = f32[k++]
+		} else {
+			let div = 2 ** (bits - 1), max = div - 1
+			let base = outPtr >> 2, k = base
+			let i32 = m.HEAP32
+			for (let i = 0; i < n; i++) for (let c = 0; c < channels; c++) {
+				let v = i32[k++]
+				channelData[c][i] = v < 0 ? v / div : v / max
+			}
+		}
+		return { channelData, sampleRate }
+	}
+
+	/** No trailing latency: decode() already drains every sample libwavpack can produce from the
+	    blocks fed so far. Drops an incomplete trailing block, if any. */
+	flush() {
+		this.left = EMPTY_BYTES
+		return EMPTY
+	}
+
+	free() {
+		if (this.freed) return
+		this.freed = true
+		this.m._wv_destroy(this.h)
+		this.h = 0
+		this.left = EMPTY_BYTES
+	}
+}
+
+function concat(a, b) {
+	let out = new Uint8Array(a.length + b.length)
+	out.set(a); out.set(b, a.length)
+	return out
+}
+
+function readError(m, h) {
+	let ptr = m._wv_error(h)
+	let bytes = m.HEAPU8.subarray(ptr, ptr + 128)
+	let nul = bytes.indexOf(0)
+	return new TextDecoder().decode(bytes.subarray(0, nul < 0 ? 128 : nul))
+}

package/node_modules/audio-decode/node_modules/@audio/decode-wavpack/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@audio/decode-wavpack",
+  "version": "1.0.0",
+  "description": "Decode WavPack (.wv) audio with libwavpack WASM",
+  "type": "module",
+  "main": "decode-wavpack.js",
+  "types": "decode-wavpack.d.ts",
+  "exports": {
+    ".": "./decode-wavpack.js",
+    "./audio": {
+      "types": "./audio.d.ts",
+      "default": "./audio.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bash build.sh",
+    "prepack": "npm run build",
+    "test": "node test.js"
+  },
+  "files": [
+    "decode-wavpack.js",
+    "decode-wavpack.d.ts",
+    "src/wavpack.wasm.js",
+    "audio.js",
+    "audio.d.ts",
+    "LICENSE",
+    "LICENSE.wavpack"
+  ],
+  "devDependencies": {
+    "tst": "^9.4.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "wavpack",
+    "wv",
+    "hybrid",
+    "lossless",
+    "audio",
+    "decode",
+    "decoder",
+    "wasm",
+    "libwavpack"
+  ],
+  "license": "BSD-3-Clause",
+  "author": "audiojs",
+  "homepage": "https://github.com/audiojs/decode/tree/main/packages/decode-wavpack",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode.git",
+    "directory": "packages/decode-wavpack"
+  },
+  "bugs": "https://github.com/audiojs/decode/issues",
+  "audio": "./audio.js",
+  "sideEffects": false,
+  "funding": "https://github.com/sponsors/audiojs"
+}

package/node_modules/audio-decode/node_modules/@audio/decode-webm/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 audiojs
+
+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/node_modules/audio-decode/node_modules/@audio/decode-webm/LICENSE.libopus

@@ -0,0 +1,44 @@
+Copyright 2001-2023 Xiph.Org, Skype Limited, Octasic,
+                    Jean-Marc Valin, Timothy B. Terriberry,
+                    CSIRO, Gregory Maxwell, Mark Borgerding,
+                    Erik de Castro Lopo, Mozilla, Amazon
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of Internet Society, IETF or IETF Trust, nor the
+names of specific contributors, may be used to endorse or promote
+products derived from this software without specific prior written
+permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Opus is subject to the royalty-free patent licenses which are
+specified at:
+
+Xiph.Org Foundation:
+https://datatracker.ietf.org/ipr/1524/
+
+Microsoft Corporation:
+https://datatracker.ietf.org/ipr/1914/
+
+Broadcom Corporation:
+https://datatracker.ietf.org/ipr/1526/

package/node_modules/audio-decode/node_modules/@audio/decode-webm/README.md

@@ -0,0 +1,59 @@
+# @audio/decode-webm
+
+Decode WebM and Matroska (MKV) audio to PCM float samples — the audio track of video files included (Opus, Vorbis, AAC, ALAC, MP3, FLAC, AC-3, DTS, PCM).
+
+## Install
+
+```
+npm i @audio/decode-webm
+```
+
+## Usage
+
+```js
+import decode, { decoder } from '@audio/decode-webm'
+
+let { channelData, sampleRate } = await decode(webmBytes)
+
+let dec = await decoder() // initialize Opus and Vorbis WASM
+let result = dec.decode(chunk)
+let tail = dec.flush()
+dec.free()
+```
+
+Video tracks are skipped; the first audio track is decoded. Laced blocks (Xiph, EBML, fixed) are split into frames.
+
+## API
+
+### `decode(src): Promise<AudioData>`
+
+Decode a complete `Uint8Array` or `ArrayBuffer`.
+
+### `decoder(): Promise<WebmDecoder>`
+
+Initialize the codec runtimes and return a streaming decoder. For the WebM codecs (Opus, Vorbis) `decode()` and `flush()` are synchronous. For Matroska-only codecs the call that completes the track header returns a Promise while the codec package loads; later calls are synchronous. `flush()` ends the stream.
+
+The factory prepares the Opus and Vorbis runtimes, then releases what the track does not need once the header is read.
+
+## Codecs
+
+| CodecID | Decoded by |
+|---|---|
+| `A_OPUS` | bundled libopus WASM core from [@audio/decode-opus](../decode-opus) |
+| `A_VORBIS` | bundled [@audio/decode-vorbis](../decode-vorbis) |
+| `A_AAC` (all profiles) | [@audio/decode-aac](../decode-aac), loaded on demand |
+| `A_ALAC` | [@audio/decode-aac](../decode-aac), loaded on demand |
+| `A_MPEG/L3` | [@audio/decode-mp3](../decode-mp3), loaded on demand |
+| `A_FLAC` | [@audio/decode-flac](../decode-flac), loaded on demand |
+| `A_PCM/INT/LIT`, `A_PCM/INT/BIG`, `A_PCM/FLOAT/IEEE` | built in |
+| `A_AC3` | [@audio/decode-ac3](../decode-ac3), loaded on demand |
+| `A_DTS` (core of DTS-HD too) | [@audio/decode-dts](../decode-dts), loaded on demand |
+| `A_EAC3` | [@audio/decode-eac3](../decode-eac3), loaded on demand |
+
+TrueHD, MPEG Layer I/II, WavPack, TTA and `A_MS/ACM` tracks throw an error naming the codec. `DiscardPadding` on Opus blocks is honoured, so files from @audio/encode-webm decode sample-exact.
+
+On-demand codec packages are imported dynamically, which is unavailable inside an AudioWorklet — Opus and Vorbis work there, the others need the main thread or a Worker.
+
+## License
+
+[ॐ](https://github.com/krishnized/license/) · [MIT](./LICENSE). Bundled [libopus](https://opus-codec.org/) is [BSD 3-Clause](./LICENSE.libopus).

package/node_modules/audio-decode/node_modules/@audio/decode-webm/audio.d.ts

@@ -0,0 +1,15 @@
+// Generated from the audio.js manifest (params metadata is the source of truth).
+// Regenerate: node tools/dts.js in @audio/compile. Do not edit by hand.
+
+/** Automatable number — scalar, `t => value` fn, or breakpoint curve {t, v} */
+type Auto = number | ((t: number) => number) | { t: number[], v: number[] }
+/** Per-block param values as delivered by hosts (numbers arrive as 1-length Float32Array) */
+type Live = Record<string, Float32Array | string | boolean>
+type Ctx = { sampleRate: number, maxBlockSize: number, maxChannels: number, currentTime: number, duration?: number, events?: readonly any[], emit?: (name: string, ...args: any[]) => void, [k: string]: unknown }
+type Process = (inputs: Float32Array[][], outputs: Float32Array[][], params: Live) => void
+
+/** Codec plugin 'webm' — extends audio()'s openable formats / save() targets */
+export declare const webm: {
+  codec: 'webm'
+  decode(bytes: Uint8Array): { channelData: Float32Array[], sampleRate: number } | Promise<{ channelData: Float32Array[], sampleRate: number }>
+}

package/node_modules/audio-decode/node_modules/@audio/decode-webm/audio.js

@@ -0,0 +1,10 @@
+// audio.js manifest — codec atom, decode half: whole-buffer bytes → { channelData,
+// sampleRate }. Hosts merge with the encode half (@audio/encode-webm) by format
+// name. Format detection is magic-byte (audio-type) — no test() needed here.
+
+import decodeFn from './decode-webm.js'
+
+export const webm = {
+	codec: 'webm',
+	decode: (bytes) => decodeFn(bytes),
+}

package/node_modules/audio-decode/node_modules/@audio/decode-webm/decode-webm.d.ts

@@ -0,0 +1,18 @@
+export interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+interface WebmDecoder {
+  /** Decode a WebM chunk synchronously. */
+  decode(data: Uint8Array | ArrayBuffer): AudioData;
+  /** Finish the stream synchronously. */
+  flush(): AudioData;
+  free(): void;
+}
+
+/** Decode a complete WebM audio file. */
+export default function decode(src: ArrayBuffer | Uint8Array): Promise<AudioData>;
+
+/** Initialize WASM and return a decoder with synchronous methods. */
+export function decoder(): Promise<WebmDecoder>;