@openclaw/whatsapp 2026.9.5 → 2026.9.7

package/node_modules/audio-decode/node_modules/@audio/decode-vorbis/meta.js

@@ -0,0 +1,102 @@
+/**
+ * Ogg Vorbis metadata — Vorbis comment tags + cover art.
+ * @module @audio/decode-vorbis/meta
+ *
+ * import { parseMeta } from '@audio/decode-vorbis/meta'
+ * let { meta, sampleRate } = parseMeta(oggBytes)
+ * // meta: { title, artist, album, year, genre, ..., pictures, raw }
+ */
+
+const TD = new TextDecoder('utf-8'), TD_L1 = new TextDecoder('iso-8859-1')
+
+const VORBIS_MAP = {
+  TITLE: 'title', ARTIST: 'artist', ALBUM: 'album', ALBUMARTIST: 'albumartist',
+  COMPOSER: 'composer', GENRE: 'genre', DATE: 'year', TRACKNUMBER: 'track',
+  DISCNUMBER: 'disc', BPM: 'bpm', KEY: 'key', COMMENT: 'comment', DESCRIPTION: 'comment',
+  COPYRIGHT: 'copyright', ISRC: 'isrc', PUBLISHER: 'publisher', ENCODER: 'software',
+  LYRICS: 'lyrics'
+}
+
+function u32le(b, o) { return (b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] * 0x1000000)) >>> 0 }
+function u32be(b, o) { return (b[o] * 0x1000000) + (b[o + 1] << 16) + (b[o + 2] << 8) + b[o + 3] }
+
+function concat(arr) {
+  if (arr.length === 1) return arr[0]
+  let n = 0; for (let a of arr) n += a.length
+  let out = new Uint8Array(n), o = 0
+  for (let a of arr) { out.set(a, o); o += a.length }
+  return out
+}
+
+// Reassemble logical packets from the leading Ogg pages (enough for the header packets).
+function oggPackets(b, max) {
+  let packets = [], seg = [], off = 0
+  while (off + 27 <= b.length && packets.length < max) {
+    if (b[off] !== 0x4f || b[off + 1] !== 0x67 || b[off + 2] !== 0x67 || b[off + 3] !== 0x53) break // 'OggS'
+    let nseg = b[off + 26], tbl = off + 27, body = tbl + nseg
+    if (body > b.length) break
+    let size = 0
+    for (let i = 0; i < nseg; i++) size += b[tbl + i]
+    let p = body
+    for (let i = 0; i < nseg; i++) {
+      let lace = b[tbl + i]
+      seg.push(b.subarray(p, p + lace)); p += lace
+      if (lace < 255) { packets.push(concat(seg)); seg = []; if (packets.length >= max) break }
+    }
+    off = body + size
+  }
+  return packets
+}
+
+function decodeB64(s) {
+  if (typeof atob === 'function') { let bin = atob(s), u = new Uint8Array(bin.length); for (let i = 0; i < bin.length; i++) u[i] = bin.charCodeAt(i); return u }
+  return Uint8Array.from(Buffer.from(s, 'base64'))
+}
+
+// FLAC PICTURE block layout (also used by METADATA_BLOCK_PICTURE)
+function parsePicture(b) {
+  let type = u32be(b, 0), o = 4
+  let ml = u32be(b, o); o += 4
+  let mime = TD_L1.decode(b.subarray(o, o + ml)); o += ml
+  let dl = u32be(b, o); o += 4
+  let desc = TD.decode(b.subarray(o, o + dl)); o += dl
+  o += 16 // width, height, depth, colors
+  let len = u32be(b, o); o += 4
+  return { mime, type, description: desc, data: b.slice(o, o + len) }
+}
+
+// Vorbis comment block: vendor string + key=value list. Returns { tags, pictures, vendor }.
+export function parseComment(b) {
+  let off = 0, tags = {}, pictures = []
+  let vlen = u32le(b, off); off += 4
+  let vendor = TD.decode(b.subarray(off, off + vlen)); off += vlen
+  let n = u32le(b, off); off += 4
+  for (let i = 0; i < n && off + 4 <= b.length; i++) {
+    let len = u32le(b, off); off += 4
+    let s = TD.decode(b.subarray(off, off + len)); off += len
+    let eq = s.indexOf('='); if (eq < 0) continue
+    let key = s.slice(0, eq).toUpperCase(), val = s.slice(eq + 1)
+    if (key === 'METADATA_BLOCK_PICTURE') { try { pictures.push(parsePicture(decodeB64(val))) } catch {} continue }
+    let norm = VORBIS_MAP[key]
+    if (norm && tags[norm] == null) tags[norm] = val
+  }
+  return { tags, pictures, vendor }
+}
+
+/** Parse Ogg Vorbis metadata. Returns { meta, sampleRate, markers, regions } or null. */
+export function parseMeta(bytes) {
+  let b = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)
+  if (b.length < 4 || b[0] !== 0x4f || b[1] !== 0x67 || b[2] !== 0x67 || b[3] !== 0x53) return null
+  let [id, comment] = oggPackets(b, 2)
+  // identification header: 0x01 'vorbis' + version(4) + channels(1) + sampleRate(4 LE)
+  if (!id || id.length < 16 || id[0] !== 1 || String.fromCharCode(id[1], id[2], id[3], id[4], id[5], id[6]) !== 'vorbis') return null
+  let sampleRate = u32le(id, 12)
+  let meta = {}, pictures = []
+  // comment header: 0x03 'vorbis' then the comment block
+  if (comment && comment.length > 7 && comment[0] === 3) {
+    let { tags, pictures: pics, vendor } = parseComment(comment.subarray(7))
+    Object.assign(meta, tags); pictures = pics; meta.raw = { vendor }
+  }
+  meta.pictures = pictures
+  return { meta, sampleRate, markers: [], regions: [] }
+}

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

@@ -0,0 +1,60 @@
+{
+  "name": "@audio/decode-vorbis",
+  "version": "1.3.2",
+  "description": "Decode Ogg Vorbis audio with libvorbis WASM",
+  "type": "module",
+  "main": "decode-vorbis.js",
+  "types": "decode-vorbis.d.ts",
+  "exports": {
+    ".": "./decode-vorbis.js",
+    "./meta": "./meta.js",
+    "./audio": {
+      "types": "./audio.d.ts",
+      "default": "./audio.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "decode-vorbis.js",
+    "meta.js",
+    "decode-vorbis.d.ts",
+    "LICENSE",
+    "audio.js",
+    "audio.d.ts"
+  ],
+  "scripts": {
+    "build": "bash build.sh",
+    "prepack": "npm run build",
+    "test": "node test.js"
+  },
+  "keywords": [
+    "vorbis",
+    "ogg",
+    "audio",
+    "decode",
+    "decoder",
+    "wasm"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "audiojs",
+  "homepage": "https://github.com/audiojs/decode/tree/master/packages/decode-vorbis#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode.git",
+    "directory": "packages/decode-vorbis"
+  },
+  "bugs": "https://github.com/audiojs/decode/issues",
+  "dependencies": {
+    "@wasm-audio-decoders/ogg-vorbis": "~0.1.20",
+    "codec-parser": "~2.5.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "audio": "./audio.js",
+  "sideEffects": false,
+  "funding": "https://github.com/sponsors/audiojs"
+}

package/node_modules/audio-decode/node_modules/@audio/decode-wav/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-wav/README.md

@@ -0,0 +1,23 @@
+# @audio/decode-wav
+
+Decode WAV/RIFF audio in pure JavaScript. Supports PCM, float, A-law, µ-law, IMA ADPCM, and MS ADPCM.
+
+```
+npm install @audio/decode-wav
+```
+
+```js
+import decode, { decoder } from '@audio/decode-wav'
+
+let { channelData, sampleRate } = decode(bytes)
+
+let dec = decoder()
+let result = dec.decode(chunk)
+dec.free()
+```
+
+`decode()` and `decoder()` are synchronous. The `./meta` subpath reads embedded metadata. The `./audio` subpath registers the codec with [`audio`](https://github.com/audiojs/audio).
+
+## License
+
+[ॐ](https://github.com/krishnized/license/) · [MIT](./LICENSE)

package/node_modules/audio-decode/node_modules/@audio/decode-wav/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 'wav' — extends audio()'s openable formats / save() targets */
+export declare const wav: {
+  codec: 'wav'
+  decode(bytes: Uint8Array): { channelData: Float32Array[], sampleRate: number } | Promise<{ channelData: Float32Array[], sampleRate: number }>
+}

package/node_modules/audio-decode/node_modules/@audio/decode-wav/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-wav) by format
+// name. Format detection is magic-byte (audio-type) — no test() needed here.
+
+import decodeFn from './decode-wav.js'
+
+export const wav = {
+	codec: 'wav',
+	decode: (bytes) => decodeFn(bytes),
+}

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

@@ -0,0 +1,8 @@
+/** Decoded PCM: planar channel data + rate. */
+export interface AudioData { channelData: Float32Array[], sampleRate: number }
+/** @deprecated Renamed to AudioData. */
+export type Decoded = AudioData
+/** Decode a complete WAV file synchronously. */
+export default function decode(src: Uint8Array | ArrayBuffer): AudioData
+/** Create a synchronous streaming decoder. */
+export function decoder(): { decode(chunk: Uint8Array | ArrayBuffer): AudioData, flush(): AudioData, free(): void }

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

@@ -0,0 +1,256 @@
+/**
+ * WAV decoder — pure JS / ESM
+ * Decodes WAV audio to Float32Array samples:
+ *   PCM 8/16/24/32-bit int, 32/64-bit float, G.711 A-law / µ-law,
+ *   plus WAVE_FORMAT_EXTENSIBLE wrapping any of the above.
+ *
+ * let { channelData, sampleRate } = decode(wavbuf)
+ */
+
+const EMPTY = Object.freeze({ channelData: [], sampleRate: 0 })
+
+// WAVE format tag → codec. EXTENSIBLE (0xFFFE) is resolved to its SubFormat tag.
+const WAV_CODECS = { 1: 'pcm', 3: 'float', 6: 'alaw', 7: 'ulaw', 2: 'ms', 0x11: 'ima' }
+
+// IMA/DVI ADPCM tables (ITU-T / Intel)
+const IMA_STEP = new Int16Array([7,8,9,10,11,12,13,14,16,17,19,21,23,25,28,31,34,37,41,45,50,55,60,66,73,80,88,97,107,118,130,143,157,173,190,209,230,253,279,307,337,371,408,449,494,544,598,658,724,796,876,963,1060,1166,1282,1411,1552,1707,1878,2066,2272,2499,2749,3024,3327,3660,4026,4428,4871,5358,5894,6484,7132,7845,8630,9493,10442,11487,12635,13899,15289,16818,18500,20350,22385,24623,27086,29794,32767])
+const IMA_IDX = new Int8Array([-1,-1,-1,-1,2,4,6,8,-1,-1,-1,-1,2,4,6,8])
+
+// MS ADPCM adaptation table + default predictor coefficients
+const MS_ADAPT = new Int16Array([230,230,230,230,307,409,512,614,768,614,512,409,307,230,230,230])
+const MS_DEFAULT_COEFS = [[256,0],[512,-256],[0,0],[192,64],[240,0],[460,-208],[392,-232]]
+
+// G.711 expansion tables (ITU-T) — int16 PCM per encoded byte
+const ALAW_TBL = new Int16Array(256)
+const ULAW_TBL = new Int16Array(256)
+for (let i = 0; i < 256; i++) {
+	let ax = i ^ 0x55, seg = (ax >> 4) & 7, val = ((ax & 0x0F) << 4) + 8
+	if (seg) val = (val + 256) << (seg - 1)
+	ALAW_TBL[i] = (ax & 0x80) ? val : -val
+
+	let ux = ~i & 0xFF
+	seg = (ux >> 4) & 7
+	val = ((ux & 0x0F) << 3) + 132
+	val <<= seg
+	ULAW_TBL[i] = (ux & 0x80) ? (132 - val) : (val - 132)
+}
+
+/** Decode a complete WAV file synchronously. */
+export default function decode(src) {
+	let dec = decoder()
+	try { return dec.decode(src instanceof Uint8Array ? src : new Uint8Array(src)) }
+	finally { dec.free() }
+}
+
+/** Create a synchronous streaming decoder. */
+export function decoder() {
+	let hdr = null, left = null, freed = false, dataLeft = Infinity
+	return {
+		decode(data) {
+			if (freed) throw Error('Decoder already freed')
+			if (!data || !data.byteLength) return EMPTY
+			let chunk = data instanceof Uint8Array ? data : new Uint8Array(data)
+			if (left) { chunk = cat(left, chunk); left = null }
+			if (!hdr) {
+				hdr = scanWavHdr(chunk)
+				if (!hdr) { left = chunk.slice(); return EMPTY }
+				// 0 / 0xFFFFFFFF are streaming placeholders; read to the end
+				dataLeft = hdr.dataSize > 0 && hdr.dataSize < 0xFFFFFFFF ? hdr.dataSize : Infinity
+				chunk = chunk.subarray(hdr.dataStart)
+			}
+			if (dataLeft <= 0) return EMPTY // Ignore chunks after the declared audio data.
+			let fb = hdr.blockSize
+			let avail = Math.min(chunk.length, dataLeft) // Do not read past the declared data size.
+			let complete = Math.floor(avail / fb) * fb
+			if (!complete) { if (chunk.length && dataLeft > chunk.length) left = chunk.slice(); return EMPTY }
+			dataLeft -= complete
+			let rest = chunk.subarray(complete)
+			if (rest.length && dataLeft > 0) left = rest.subarray(0, Math.min(rest.length, dataLeft)).slice()
+			return decodeRaw(chunk.subarray(0, complete), hdr)
+		},
+		flush() { left = null; return EMPTY },
+		free() { freed = true; left = null; hdr = null },
+	}
+}
+
+function cat(a, b) {
+	let r = new Uint8Array(a.length + b.length)
+	r.set(a); r.set(b, a.length)
+	return r
+}
+
+function s4(b, o) { return String.fromCharCode(b[o], b[o + 1], b[o + 2], b[o + 3]) }
+
+function scanWavHdr(b) {
+	// reject non-WAV as soon as the magic is readable; only buffer when a valid header is still arriving
+	if (b.length >= 4 && s4(b, 0) !== 'RIFF') throw TypeError('Not a WAV file')
+	if (b.length < 12) return null
+	let dv = new DataView(b.buffer, b.byteOffset, b.byteLength)
+	if (s4(b, 8) !== 'WAVE') throw TypeError('Not a WAV file')
+	let pos = 12, fmt = null
+	while (pos + 8 <= b.length) {
+		let type = s4(b, pos), size = dv.getUint32(pos + 4, true)
+		if (type === 'fmt ') {
+			if (pos + 24 > b.length) return null
+			let fid = dv.getUint16(pos + 8, true)
+			// WAVE_FORMAT_EXTENSIBLE: real codec is the first 2 bytes of the SubFormat GUID
+			if (fid === 0xFFFE) {
+				if (pos + 48 > b.length) return null
+				fid = dv.getUint16(pos + 32, true)
+			}
+			let codec = WAV_CODECS[fid]
+			if (!codec) throw TypeError('Unsupported WAV format: 0x' + fid.toString(16))
+			fmt = {
+				codec, channels: dv.getUint16(pos + 10, true),
+				sampleRate: dv.getUint32(pos + 12, true),
+				blockSize: dv.getUint16(pos + 20, true), bitDepth: dv.getUint16(pos + 22, true),
+			}
+			// ADPCM: block-based — read samples-per-block (+ predictor coefs for MS) from the fmt extension
+			if (codec === 'ima' || codec === 'ms') {
+				if (pos + 8 + size > b.length) return null // wait for the full fmt chunk
+				let nCh = fmt.channels, ba = fmt.blockSize
+				let cbSize = dv.getUint16(pos + 24, true)
+				fmt.samplesPerBlock = cbSize >= 2 ? dv.getUint16(pos + 26, true) : 0
+				if (codec === 'ima') {
+					if (!fmt.samplesPerBlock) fmt.samplesPerBlock = 1 + (ba / nCh - 4) * 2
+				} else {
+					if (!fmt.samplesPerBlock) fmt.samplesPerBlock = 2 + (ba - 7 * nCh) * 2 / nCh
+					let nCoef = cbSize >= 4 ? dv.getUint16(pos + 28, true) : 0
+					let coefs = []
+					for (let i = 0; i < nCoef; i++)
+						coefs.push([dv.getInt16(pos + 30 + i * 4, true), dv.getInt16(pos + 32 + i * 4, true)])
+					fmt.coefs = coefs.length ? coefs : MS_DEFAULT_COEFS
+				}
+			}
+		} else if (type === 'data') {
+			if (!fmt) return null
+			return { ...fmt, dataStart: pos + 8, dataSize: size }
+		}
+		pos += 8 + size
+	}
+	return null
+}
+
+function decodeRaw(raw, hdr) {
+	let { channels: nCh, bitDepth, codec, sampleRate, blockSize } = hdr
+	if (codec === 'ima') return decodeImaWav(raw, hdr)
+	if (codec === 'ms') return decodeMsWav(raw, hdr)
+	let frames = Math.floor(raw.length / blockSize)
+	if (!frames) return EMPTY
+	let ch = Array.from({ length: nCh }, () => new Float32Array(frames))
+	let dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength)
+	let p = 0
+	let isFloat = codec === 'float'
+	if (codec === 'alaw' || codec === 'ulaw') {
+		let tbl = codec === 'alaw' ? ALAW_TBL : ULAW_TBL
+		for (let i = 0; i < frames; i++) for (let c = 0; c < nCh; c++) ch[c][i] = tbl[raw[p++]] / 32768
+	} else if (isFloat && bitDepth === 64) {
+		for (let i = 0; i < frames; i++) for (let c = 0; c < nCh; c++) { ch[c][i] = dv.getFloat64(p, true); p += 8 }
+	} else if (isFloat && bitDepth === 32) {
+		for (let i = 0; i < frames; i++) for (let c = 0; c < nCh; c++) { ch[c][i] = dv.getFloat32(p, true); p += 4 }
+	} else if (bitDepth === 8) {
+		for (let i = 0; i < frames; i++) for (let c = 0; c < nCh; c++) {
+			let v = raw[p++] - 128; ch[c][i] = v < 0 ? v / 128 : v / 127
+		}
+	} else if (bitDepth === 16) {
+		for (let i = 0; i < frames; i++) for (let c = 0; c < nCh; c++) {
+			let v = dv.getInt16(p, true); p += 2; ch[c][i] = v < 0 ? v / 32768 : v / 32767
+		}
+	} else if (bitDepth === 24) {
+		for (let i = 0; i < frames; i++) for (let c = 0; c < nCh; c++) {
+			let v = raw[p] | (raw[p + 1] << 8) | (raw[p + 2] << 16); p += 3
+			if (v >= 0x800000) v -= 0x1000000
+			ch[c][i] = v < 0 ? v / 8388608 : v / 8388607
+		}
+	} else if (bitDepth === 32) {
+		for (let i = 0; i < frames; i++) for (let c = 0; c < nCh; c++) {
+			let v = dv.getInt32(p, true); p += 4; ch[c][i] = v < 0 ? v / 2147483648 : v / 2147483647
+		}
+	} else { throw TypeError('Unsupported WAV bit depth: ' + bitDepth) }
+	return { channelData: ch, sampleRate }
+}
+
+// IMA/DVI ADPCM — per channel: 4-byte header (predictor int16 + step index), then
+// 4-byte words round-robin across channels, low nibble first, 8 samples per word.
+function decodeImaWav(raw, hdr) {
+	let { channels: nCh, blockSize: ba, samplesPerBlock: spb, sampleRate } = hdr
+	let nBlocks = Math.floor(raw.length / ba)
+	let ch = Array.from({ length: nCh }, () => new Float32Array(nBlocks * spb))
+	let dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength)
+	for (let blk = 0; blk < nBlocks; blk++) {
+		let base = blk * ba, outBase = blk * spb
+		let pred = new Int32Array(nCh), idx = new Int32Array(nCh), cnt = new Int32Array(nCh)
+		for (let c = 0; c < nCh; c++) {
+			pred[c] = dv.getInt16(base + c * 4, true)
+			idx[c] = Math.min(raw[base + c * 4 + 2], 88)
+			ch[c][outBase] = pred[c] / 32768
+			cnt[c] = 1
+		}
+		let p = base + nCh * 4, nWords = Math.ceil((spb - 1) / 8)
+		for (let w = 0; w < nWords; w++) {
+			for (let c = 0; c < nCh; c++, p += 4) {
+				let out = ch[c], pr = pred[c], ix = idx[c]
+				for (let n = 0; n < 4; n++) {
+					let byte = raw[p + n]
+					for (let half = 0; half < 2; half++) {
+						let nib = half === 0 ? (byte & 0x0F) : (byte >> 4)
+						let step = IMA_STEP[ix]
+						let diff = ((2 * (nib & 7) + 1) * step) >> 3
+						pr += (nib & 8) ? -diff : diff
+						if (pr > 32767) pr = 32767; else if (pr < -32768) pr = -32768
+						ix += IMA_IDX[nib]
+						if (ix < 0) ix = 0; else if (ix > 88) ix = 88
+						if (cnt[c] < spb) out[outBase + cnt[c]++] = pr / 32768
+					}
+				}
+				pred[c] = pr; idx[c] = ix
+			}
+		}
+	}
+	return { channelData: ch, sampleRate }
+}
+
+// MS ADPCM — per channel: predictor index byte, then int16 delta, sample1, sample2.
+// Stereo interleaves one nibble per channel per byte (high=L, low=R); mono packs two.
+function decodeMsWav(raw, hdr) {
+	let { channels: nCh, blockSize: ba, samplesPerBlock: spb, sampleRate, coefs } = hdr
+	let nBlocks = Math.floor(raw.length / ba)
+	let ch = Array.from({ length: nCh }, () => new Float32Array(nBlocks * spb))
+	let dv = new DataView(raw.buffer, raw.byteOffset, raw.byteLength)
+	let predIdx = new Int32Array(nCh), delta = new Int32Array(nCh), s1 = new Int32Array(nCh), s2 = new Int32Array(nCh)
+	let expand = (nib, c) => {
+		let signed = nib >= 8 ? nib - 16 : nib
+		let co = coefs[predIdx[c]]
+		let pr = (s1[c] * co[0] + s2[c] * co[1]) >> 8
+		pr += signed * delta[c]
+		if (pr > 32767) pr = 32767; else if (pr < -32768) pr = -32768
+		s2[c] = s1[c]; s1[c] = pr
+		delta[c] = (MS_ADAPT[nib] * delta[c]) >> 8
+		if (delta[c] < 16) delta[c] = 16
+		return pr / 32768
+	}
+	for (let blk = 0; blk < nBlocks; blk++) {
+		let base = blk * ba, outBase = blk * spb, p = base
+		for (let c = 0; c < nCh; c++) predIdx[c] = Math.min(raw[p++], coefs.length - 1)
+		for (let c = 0; c < nCh; c++) { delta[c] = dv.getInt16(p, true); p += 2 }
+		for (let c = 0; c < nCh; c++) { s1[c] = dv.getInt16(p, true); p += 2 }
+		for (let c = 0; c < nCh; c++) { s2[c] = dv.getInt16(p, true); p += 2 }
+		for (let c = 0; c < nCh; c++) { ch[c][outBase] = s2[c] / 32768; ch[c][outBase + 1] = s1[c] / 32768 }
+		let cnt = 2
+		if (nCh === 1) {
+			while (cnt < spb) {
+				let byte = raw[p++]
+				ch[0][outBase + cnt++] = expand(byte >> 4, 0)
+				if (cnt < spb) ch[0][outBase + cnt++] = expand(byte & 0x0F, 0)
+			}
+		} else {
+			while (cnt < spb) {
+				let byte = raw[p++]
+				ch[0][outBase + cnt] = expand(byte >> 4, 0)
+				ch[1][outBase + cnt] = expand(byte & 0x0F, 1)
+				cnt++
+			}
+		}
+	}
+	return { channelData: ch, sampleRate }
+}

package/node_modules/audio-decode/node_modules/@audio/decode-wav/meta.js

@@ -0,0 +1,114 @@
+/**
+ * WAV RIFF metadata parser — INFO, bext, iXML, cue/adtl chunks.
+ * @module @audio/decode-wav/meta
+ */
+
+const TD_U8 = new TextDecoder('utf-8'), TD_L1 = new TextDecoder('iso-8859-1')
+
+function str(bytes, enc = 'utf-8') {
+  let end = bytes.length
+  while (end > 0 && bytes[end - 1] === 0) end--
+  return (enc === 'iso-8859-1' ? TD_L1 : TD_U8).decode(bytes.subarray(0, end))
+}
+
+// ── Constants ───────────────────────────────────────────────────────────
+
+export const INFO_MAP = {
+  INAM: 'title', IART: 'artist', IPRD: 'album', IGNR: 'genre',
+  ICRD: 'year', ITRK: 'track', ICMT: 'comment', ICOP: 'copyright',
+  IENG: 'engineer', ISFT: 'software', ISRC: 'isrc', ISBJ: 'subject',
+  IKEY: 'keywords', IARL: 'location'
+}
+
+// ── Binary helpers ──────────────────────────────────────────────────────
+
+function u32le(b, o) { return b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] * 0x1000000) }
+function u16le(b, o) { return b[o] | (b[o + 1] << 8) }
+function fourcc(b, o) { return String.fromCharCode(b[o], b[o + 1], b[o + 2], b[o + 3]) }
+
+// ── Chunk parsers ───────────────────────────────────────────────────────
+
+function parseBext(b) {
+  if (b.length < 348) return null
+  return {
+    description: str(b.subarray(0, 256)),
+    originator: str(b.subarray(256, 288)),
+    originatorReference: str(b.subarray(288, 320)),
+    originationDate: str(b.subarray(320, 330)),
+    originationTime: str(b.subarray(330, 338)),
+    timeReferenceLow: u32le(b, 338),
+    timeReferenceHigh: u32le(b, 342),
+    version: u16le(b, 346)
+  }
+}
+
+function parseInfo(b) {
+  let out = {}, off = 0
+  while (off + 8 <= b.length) {
+    let id = fourcc(b, off), size = u32le(b, off + 4)
+    let v = str(b.subarray(off + 8, off + 8 + size))
+    let key = INFO_MAP[id]
+    if (key) out[key] = v
+    off += 8 + size + (size & 1)
+  }
+  return out
+}
+
+function parseCue(b, cues) {
+  let n = u32le(b, 0)
+  for (let i = 0; i < n; i++) {
+    let o = 4 + i * 24
+    if (o + 24 > b.length) break
+    let id = u32le(b, o), pos = u32le(b, o + 20)
+    cues.set(id, pos)
+  }
+}
+
+function parseAdtl(b, labels, notes, ltxts) {
+  let off = 0
+  while (off + 8 <= b.length) {
+    let id = fourcc(b, off), size = u32le(b, off + 4)
+    let body = b.subarray(off + 8, off + 8 + size)
+    if (id === 'labl' && body.length >= 4) labels.set(u32le(body, 0), str(body.subarray(4)))
+    else if (id === 'note' && body.length >= 4) notes.set(u32le(body, 0), str(body.subarray(4)))
+    else if (id === 'ltxt' && body.length >= 20) ltxts.set(u32le(body, 0), { duration: u32le(body, 4), label: str(body.subarray(20)) })
+    off += 8 + size + (size & 1)
+  }
+}
+
+/** Parse WAV RIFF metadata. Returns {meta, sampleRate, markers, regions} or null. */
+export function parseMeta(bytes) {
+  if (!bytes?.length || bytes.length < 12 || fourcc(bytes, 0) !== 'RIFF' || fourcc(bytes, 8) !== 'WAVE') return null
+  let meta = {}, raw = {}, pictures = [], markers = [], regions = []
+  let cues = new Map(), labels = new Map(), notes = new Map(), ltxts = new Map()
+  let sampleRate = 0
+
+  let off = 12
+  while (off + 8 <= bytes.length) {
+    let id = fourcc(bytes, off), size = u32le(bytes, off + 4)
+    let body = bytes.subarray(off + 8, off + 8 + size)
+    if (id === 'fmt ' && body.length >= 16) sampleRate = u32le(body, 4)
+    else if (id === 'bext') raw.bext = parseBext(body)
+    else if (id === 'iXML') raw.iXML = str(body, 'utf-8')
+    else if (id === 'LIST' && body.length >= 4 && fourcc(body, 0) === 'INFO') Object.assign(meta, parseInfo(body.subarray(4)))
+    // NOTE: embedded ID3 in WAV (id === 'ID3 ') not parsed here — use @audio/decode-mp3/meta for that
+    else if (id === 'cue ') parseCue(body, cues)
+    else if (id === 'LIST' && body.length >= 4 && fourcc(body, 0) === 'adtl') parseAdtl(body.subarray(4), labels, notes, ltxts)
+    off += 8 + size + (size & 1)
+  }
+
+  for (let [id, pos] of cues) {
+    let label = labels.get(id) || notes.get(id) || ''
+    let lt = ltxts.get(id)
+    if (lt && lt.duration > 0) regions.push({ sample: pos, length: lt.duration, label: lt.label || label })
+    else markers.push({ sample: pos, label })
+  }
+  markers.sort((a, b) => a.sample - b.sample)
+  regions.sort((a, b) => a.sample - b.sample)
+
+  if (raw.bext?.description && !meta.comment) meta.comment = raw.bext.description
+
+  meta.raw = raw
+  meta.pictures = pictures
+  return { meta, sampleRate, markers, regions }
+}

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

@@ -0,0 +1,52 @@
+{
+  "name": "@audio/decode-wav",
+  "version": "1.5.0",
+  "description": "Decode WAV audio to PCM samples",
+  "type": "module",
+  "main": "decode-wav.js",
+  "files": [
+    "decode-wav.js",
+    "meta.js",
+    "audio.js",
+    "audio.d.ts",
+    "decode-wav.d.ts"
+  ],
+  "exports": {
+    ".": "./decode-wav.js",
+    "./meta": "./meta.js",
+    "./audio": {
+      "types": "./audio.d.ts",
+      "default": "./audio.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "wav",
+    "audio",
+    "decode",
+    "decoder",
+    "pcm"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "audiojs",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "audio": "./audio.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode.git",
+    "directory": "packages/decode-wav"
+  },
+  "homepage": "https://github.com/audiojs/decode/tree/master/packages/decode-wav#readme",
+  "bugs": "https://github.com/audiojs/decode/issues",
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "funding": "https://github.com/sponsors/audiojs",
+  "types": "decode-wav.d.ts"
+}