@openclaw/whatsapp 2026.9.6 → 2026.9.7

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

@@ -0,0 +1,21 @@
+export interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+interface AVIDecoder {
+  /**
+   * Decode an AVI chunk. Synchronous once the stream headers have been seen; the call that
+   * completes them returns a Promise while the codec module loads.
+   */
+  decode(data: Uint8Array | ArrayBuffer): AudioData | Promise<AudioData>;
+  /** Finish the stream. Throws if no audio stream was found. */
+  flush(): AudioData | Promise<AudioData>;
+  free(): void;
+}
+
+/** Decode the audio stream of a complete AVI file. */
+export default function decode(src: ArrayBuffer | Uint8Array): Promise<AudioData>;
+
+/** Create a streaming decoder. */
+export function decoder(): Promise<AVIDecoder>;

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

@@ -0,0 +1,241 @@
+/**
+ * AVI audio decoder — RIFF/AVI demuxer (incl. OpenDML AVIX) that routes the audio stream to a codec:
+ * PCM / µ-law / A-law inline · MP3 → @audio/decode-mp3 · AAC → @audio/decode-aac · AC-3 → @audio/decode-ac3 · DTS → @audio/decode-dts.
+ *
+ * let { channelData, sampleRate } = await decode(avibuf)
+ * let dec = await decoder(); let result = await dec.decode(chunk)
+ */
+
+const EMPTY = Object.freeze({ channelData: [], sampleRate: 0 })
+
+/**
+ * Whole-file decode
+ * @param {Uint8Array|ArrayBuffer} src
+ * @returns {Promise<{channelData: Float32Array[], sampleRate: number}>}
+ */
+export default async function decode(src) {
+	if (!src || typeof src === 'string' || !(src.buffer || src.byteLength != null || src.length))
+		throw TypeError('Expected ArrayBuffer or Uint8Array')
+	let buf = src instanceof Uint8Array ? src : new Uint8Array(src.buffer || src)
+	let dec = new AVIDecoder()
+	try {
+		let result = await dec.decode(buf)
+		return merge(result, await dec.flush())
+	} finally { dec.free() }
+}
+
+/**
+ * Create streaming decoder instance. decode() is synchronous once the stream headers (hdrl) have
+ * been seen; the call that completes them returns a Promise while the codec module loads.
+ */
+export async function decoder() {
+	return new AVIDecoder()
+}
+
+class AVIDecoder {
+	constructor() {
+		this.left = null
+		this.pending = null
+		this.codec = null
+		this.stream = null     // { index, id: 'NNwb', fmt }
+		this.streams = 0       // strl lists seen
+		this.header = false    // hdrl complete
+		this.frames = []       // audio chunks queued while the codec loads
+		this.freed = false
+		this.started = 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)
+		if (this.pending) return this.pending.then(() => this.decode(buf))
+		buf = append(this.left, buf); this.left = null
+		if (!this.started) {
+			if (buf.length < 12) { this.left = buf; return EMPTY }
+			if (str4(buf, 0) !== 'RIFF' || str4(buf, 8) !== 'AVI ') throw Error('Not an AVI file')
+			this.started = true
+		}
+		let frames = this.scan(buf)
+		if (this.codec) return frames.length ? this.codec.feed(frames) : EMPTY
+		this.frames.push(...frames)
+		if (!this.header) return EMPTY
+		if (!this.stream) throw Error('No audio stream found in AVI')
+		return this.pending = createCodec(this.stream.fmt).then(codec => {
+			this.pending = null
+			if (this.freed) { codec.free(); return EMPTY }
+			this.codec = codec
+			let queued = this.frames; this.frames = []
+			return queued.length ? codec.feed(queued) : EMPTY
+		})
+	}
+
+	// Chunk scanner: descends into RIFF/LIST containers, harvests the audio stream's chunks, keeps the tail.
+	scan(buf) {
+		let frames = [], pos = 0
+		while (pos + 8 <= buf.length) {
+			let id = str4(buf, pos), size = r32(buf, pos + 4)
+			if (id === 'RIFF' || id === 'LIST') {
+				if (pos + 12 > buf.length) break
+				let type = str4(buf, pos + 8)
+				if (type === 'strl') this.streams++
+				if (type === 'hdrl' || type === 'strl' || type === 'movi' || type === 'rec ' || id === 'RIFF') { pos += 12; continue } // descend
+				pos += 8 + size + (size & 1)
+				continue
+			}
+			let end = pos + 8 + size + (size & 1)
+			if (end > buf.length) {
+				if (this.stream && id === this.stream.id) break            // partial audio chunk — wait
+				if (!this.header && (id === 'strh' || id === 'strf')) break // partial header
+				if (size > 0x10000000) throw Error('Corrupt AVI chunk')
+				break
+			}
+			let body = buf.subarray(pos + 8, pos + 8 + size)
+			if (!this.header) {
+				if (id === 'strh' && !this.stream && str4(body, 0) === 'auds') this.stream = { index: this.streams - 1, id: null, fmt: null }
+				else if (id === 'strf' && this.stream && this.stream.index === this.streams - 1 && !this.stream.fmt) {
+					this.stream.fmt = parseWaveFormat(body)
+					this.stream.id = String(this.stream.index).padStart(2, '0') + 'wb'
+				}
+				else if (id === 'avih') {}
+				else if (id !== 'strn' && id !== 'strd' && id !== 'indx' && id !== 'vprp' && id !== 'JUNK' && id !== 'odml' && id !== 'dmlh' && id !== 'ISFT' && this.streams && (id.endsWith('wb') || id.endsWith('dc') || id.endsWith('db') || id === 'idx1')) this.header = true
+			}
+			if (this.stream?.id && id === this.stream.id && size) { frames.push(body.slice()); this.header = true }
+			pos = end
+		}
+		if (pos < buf.length) this.left = buf.subarray(pos).slice()
+		return frames
+	}
+
+	flush() {
+		if (this.freed) return EMPTY
+		if (this.pending) return this.pending.then(() => this.flush())
+		this.freed = true
+		if (!this.codec) throw Error(this.started ? 'No audio stream found in AVI' : 'Not an AVI file')
+		try { return this.codec.flush() } finally { this.codec.free(); this.codec = null; this.left = null }
+	}
+
+	free() {
+		if (this.freed) return
+		this.freed = true
+		this.codec?.free(); this.codec = null
+		this.left = null; this.frames = []
+	}
+}
+
+/** WAVEFORMATEX(TENSIBLE) → { tag, channels, sampleRate, bits, extra } */
+function parseWaveFormat(b) {
+	let dv = new DataView(b.buffer, b.byteOffset, b.byteLength)
+	let f = { tag: dv.getUint16(0, true), channels: dv.getUint16(2, true), sampleRate: dv.getUint32(4, true), bits: dv.getUint16(14, true), extra: null }
+	let cb = b.length >= 18 ? dv.getUint16(16, true) : 0
+	if (f.tag === 0xFFFE && b.length >= 40) { f.tag = dv.getUint16(24, true); f.bits = dv.getUint16(18, true) || f.bits; f.extra = b.subarray(40, 18 + cb) }
+	else if (cb) f.extra = b.subarray(18, 18 + cb)
+	return f
+}
+
+const NAMES = { 0x160: 'WMA v1', 0x161: 'WMA v2', 0x162: 'WMA Pro', 0x163: 'WMA Lossless', 0x50: 'MPEG-1 Layer II', 0x2: 'MS ADPCM', 0x11: 'IMA ADPCM', 0x22: 'TrueSpeech', 0x31: 'GSM 6.10', 0x8000: 'AAC' }
+
+async function createCodec(fmt) {
+	switch (fmt.tag) {
+		case 1: return pcm({ ...fmt, float: false, signed: fmt.bits > 8 })
+		case 3: return pcm({ ...fmt, float: true, signed: true })
+		case 6: return pcm({ ...fmt, bits: 8, law: 'a' })
+		case 7: return pcm({ ...fmt, bits: 8, law: 'u' })
+		case 0x55: return frames(import('@audio/decode-mp3'))
+		case 0x2000: return frames(import('@audio/decode-ac3'))
+		case 0x2001: return frames(import('@audio/decode-dts'))
+		case 0xFF: {
+			if (!fmt.extra?.length) throw Error('AVI AAC stream has no AudioSpecificConfig')
+			let dec = await (await import('@audio/decode-aac')).decoder({ asc: fmt.extra })
+			return { feed: frames => dec.decode(frames), flush: () => dec.flush(), free: () => dec.free() }
+		}
+	}
+	throw Error('Unsupported AVI audio codec: ' + (NAMES[fmt.tag] || 'wFormatTag 0x' + fmt.tag.toString(16)))
+}
+
+// self-synchronizing frame streams (MP3, AC-3, DTS): the codec resyncs on concatenated chunks
+async function frames(load) {
+	let dec = await (await load).decoder()
+	return { feed: frames => dec.decode(concat(frames)), flush: () => dec.flush?.() ?? EMPTY, free: () => dec.free() }
+}
+
+// interleaved little-endian PCM → planar float. Keeps a partial frame between calls.
+function pcm({ channels, sampleRate, bits, float, signed, law }) {
+	if (!channels || !sampleRate || !bits) throw Error('Invalid AVI PCM format')
+	let bps = bits >> 3, frame = bps * channels, left = null
+	let read = law === 'u' ? ulaw : law === 'a' ? alaw : reader(bits, float, signed)
+	return {
+		feed(frames) {
+			let buf = concat(left ? [left, ...frames] : frames)
+			let n = Math.floor(buf.length / frame)
+			left = n * frame < buf.length ? buf.slice(n * frame) : null
+			if (!n) return EMPTY
+			let dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+			let channelData = Array.from({ length: channels }, () => new Float32Array(n))
+			for (let i = 0, off = 0; i < n; i++)
+				for (let c = 0; c < channels; c++, off += bps) channelData[c][i] = read(dv, off)
+			return { channelData, sampleRate }
+		},
+		flush: () => EMPTY,
+		free() { left = null }
+	}
+}
+
+function reader(bits, float, signed) {
+	if (float) return bits === 64 ? (dv, o) => dv.getFloat64(o, true) : (dv, o) => dv.getFloat32(o, true)
+	switch (bits) {
+		case 8: return signed ? (dv, o) => dv.getInt8(o) / 128 : (dv, o) => (dv.getUint8(o) - 128) / 128
+		case 16: return (dv, o) => dv.getInt16(o, true) / 32768
+		case 24: return (dv, o) => ((dv.getUint8(o + 2) << 24 | dv.getUint8(o + 1) << 16 | dv.getUint8(o) << 8) >> 8) / 8388608
+		case 32: return (dv, o) => dv.getInt32(o, true) / 2147483648
+	}
+	throw Error('Unsupported PCM bit depth: ' + bits)
+}
+
+// ITU-T G.711
+function ulaw(dv, o) {
+	let u = ~dv.getUint8(o) & 0xFF
+	let t = (((u & 0x0F) << 3) + 0x84) << ((u & 0x70) >> 4)
+	return ((u & 0x80) ? 0x84 - t : t - 0x84) / 32768
+}
+function alaw(dv, o) {
+	let a = dv.getUint8(o) ^ 0x55
+	let t = (a & 0x0F) << 4, seg = (a & 0x70) >> 4
+	t = seg === 0 ? t + 8 : seg === 1 ? t + 0x108 : (t + 0x108) << (seg - 1)
+	return ((a & 0x80) ? t : -t) / 32768
+}
+
+
+// ===== helpers =====
+
+function r32(b, o) { return (b[o] | b[o + 1] << 8 | b[o + 2] << 16 | b[o + 3] << 24) >>> 0 } // RIFF is little-endian
+function str4(b, o) { return String.fromCharCode(b[o], b[o + 1], b[o + 2], b[o + 3]) }
+
+function append(left, buf) {
+	if (!left?.length) return buf
+	let out = new Uint8Array(left.length + buf.length)
+	out.set(left); out.set(buf, left.length)
+	return out
+}
+
+function concat(parts) {
+	if (parts.length === 1) return parts[0]
+	let total = 0
+	for (let p of parts) total += p.length
+	let out = new Uint8Array(total), off = 0
+	for (let p of parts) { out.set(p, off); off += p.length }
+	return out
+}
+
+function merge(a, b) {
+	if (!b?.channelData?.length) return a
+	if (!a?.channelData?.length) return b
+	return {
+		channelData: a.channelData.map((ch, i) => {
+			let m = new Float32Array(ch.length + b.channelData[i].length)
+			m.set(ch); m.set(b.channelData[i], ch.length)
+			return m
+		}),
+		sampleRate: a.sampleRate
+	}
+}

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

@@ -0,0 +1,66 @@
+{
+  "name": "@audio/decode-avi",
+  "version": "1.1.0",
+  "description": "Decode the audio stream of AVI files (PCM, MP3, AAC, \u00b5-law, A-law) to PCM samples",
+  "type": "module",
+  "main": "decode-avi.js",
+  "types": "decode-avi.d.ts",
+  "exports": {
+    ".": "./decode-avi.js",
+    "./audio": {
+      "types": "./audio.d.ts",
+      "default": "./audio.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node test.js"
+  },
+  "files": [
+    "decode-avi.js",
+    "decode-avi.d.ts",
+    "audio.js",
+    "audio.d.ts",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@audio/decode-aac": "^1.5.0",
+    "@audio/decode-ac3": "^1.0.0",
+    "@audio/decode-dts": "^1.0.0",
+    "@audio/decode-mp3": "^1.3.0"
+  },
+  "devDependencies": {
+    "tst": "^9.2.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "avi",
+    "riff",
+    "opendml",
+    "demux",
+    "video",
+    "audio",
+    "decode",
+    "decoder",
+    "pcm",
+    "mp3",
+    "aac"
+  ],
+  "license": "MIT",
+  "author": "audiojs",
+  "homepage": "https://github.com/audiojs/decode/tree/main/packages/decode-avi",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode.git",
+    "directory": "packages/decode-avi"
+  },
+  "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-caf/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-caf/README.md

@@ -0,0 +1,48 @@
+# @audio/decode-caf
+
+Decode Core Audio Format audio to PCM float samples.
+
+## Install
+
+```
+npm i @audio/decode-caf
+```
+
+## Usage
+
+```js
+import decode, { decoder } from '@audio/decode-caf'
+
+let { channelData, sampleRate } = decode(cafBytes)
+
+let dec = decoder()
+let result = dec.decode(chunk)
+dec.free()
+```
+
+`decode()` and `decoder()` are synchronous.
+
+## API
+
+### `decode(src): AudioData`
+
+Decode a complete `Uint8Array` or `ArrayBuffer`.
+
+### `decoder(): CAFDecoder`
+
+Create a decoder instance.
+
+- `dec.decode(data)`: decode a chunk.
+- `dec.flush()`: discard buffered partial data and return an empty result.
+- `dec.free()`: release resources.
+
+## Formats
+
+- `lpcm`: 8, 16, 24, and 32-bit signed integer; 32 and 64-bit float; little-endian or big-endian.
+- `alaw`: G.711 A-law.
+- `ulaw`: G.711 µ-law.
+- `ima4`: IMA/QuickTime ADPCM.
+
+## License
+
+[ॐ](https://github.com/krishnized/license/) · [MIT](./LICENSE)

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

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

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

@@ -0,0 +1,16 @@
+export interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+interface CAFDecoder {
+  decode(data: Uint8Array | ArrayBuffer): AudioData;
+  flush(): AudioData;
+  free(): void;
+}
+
+/** Decode a complete CAF file synchronously. */
+export default function decode(src: ArrayBuffer | Uint8Array): AudioData;
+
+/** Create a synchronous decoder. */
+export function decoder(): CAFDecoder;

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

@@ -0,0 +1,238 @@
+/**
+ * CAF (Core Audio Format) decoder
+ * Decodes CAF containers with lpcm, alaw, ulaw audio to Float32 PCM
+ *
+ * let { channelData, sampleRate } = decode(cafbuf)
+ */
+
+const EMPTY = Object.freeze({ channelData: [], sampleRate: 0 })
+
+// IMA/QuickTime ADPCM tables
+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])
+
+/** Decode a complete CAF file synchronously. */
+export default function decode(src) {
+	let dec = decoder()
+	try { return dec.decode(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 = catB(left, chunk); left = null }
+			if (!hdr) {
+				hdr = scanCafHdr(chunk)
+				if (!hdr) { left = chunk.slice(); return EMPTY }
+				dataLeft = hdr.dataSize
+				chunk = chunk.subarray(hdr.dataStart)
+			}
+			if (dataLeft <= 0) return EMPTY // Ignore chunks after the declared audio data.
+			let fb = hdr.frameBytes
+			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 decodeCafRaw(chunk.subarray(0, complete), hdr)
+		},
+		flush() { left = null; return EMPTY },
+		free() { freed = true; left = null; hdr = null },
+	}
+}
+
+function catB(a, b) {
+	let r = new Uint8Array(a.length + b.length)
+	r.set(a); r.set(b, a.length)
+	return r
+}
+
+function scanCafHdr(buf) {
+	if (buf.length < 8) return null
+	if (buf[0] !== 0x63 || buf[1] !== 0x61 || buf[2] !== 0x66 || buf[3] !== 0x66) throw Error('Not a CAF file')
+	let dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+	if (dv.getUint16(4, false) !== 1) throw Error('Unsupported CAF version')
+	let off = 8, desc = null
+	while (off + 12 <= buf.length) {
+		let type = String.fromCharCode(buf[off], buf[off + 1], buf[off + 2], buf[off + 3])
+		let sizeHi = dv.getUint32(off + 4, false), sizeLo = dv.getUint32(off + 8, false)
+		let size = sizeHi * 0x100000000 + sizeLo
+		off += 12
+		if (type === 'desc') {
+			if (off + 32 > buf.length) return null
+			desc = {
+				sampleRate: dv.getFloat64(off, false),
+				formatID: String.fromCharCode(buf[off + 8], buf[off + 9], buf[off + 10], buf[off + 11]),
+				formatFlags: dv.getUint32(off + 12, false),
+				bytesPerPacket: dv.getUint32(off + 16, false),
+				framesPerPacket: dv.getUint32(off + 20, false),
+				channelsPerFrame: dv.getUint32(off + 24, false),
+				bitsPerChannel: dv.getUint32(off + 28, false),
+			}
+		} else if (type === 'data') {
+			if (!desc) return null
+			let dataStart = off + 4 // skip editCount
+			if (dataStart > buf.length) return null
+			// -1 (0xFFFF…) size means "until EOF" — read to end; else payload minus 4-byte editCount
+			let dataSize = (sizeHi === 0xFFFFFFFF && sizeLo === 0xFFFFFFFF) ? Infinity : Math.max(0, size - 4)
+			let { formatID, formatFlags, channelsPerFrame: ch, bitsPerChannel: bits } = desc
+			let bytesPerSample = bits >> 3
+			let frameBytes
+			if (formatID === 'alaw' || formatID === 'ulaw') frameBytes = ch
+			else if (formatID === 'ima4') frameBytes = desc.bytesPerPacket || 34 * ch // packet = 34 bytes/channel
+			else frameBytes = ch * bytesPerSample
+			if (!frameBytes) return null
+			return { ...desc, dataStart, frameBytes, dataSize }
+		}
+		if (size < 0) break
+		if (sizeHi === 0xFFFFFFFF && sizeLo === 0xFFFFFFFF) break
+		off += size
+	}
+	return null
+}
+
+function decodeCafRaw(raw, hdr) {
+	let { sampleRate, formatID, formatFlags, channelsPerFrame: ch, bitsPerChannel: bits, frameBytes } = hdr
+	let frames = Math.floor(raw.length / frameBytes)
+	if (!frames) return EMPTY
+	let samples
+	if (formatID === 'lpcm') samples = decodeLPCM(raw, formatFlags, bits, ch)
+	else if (formatID === 'alaw') samples = decodeAlaw(raw, ch)
+	else if (formatID === 'ulaw') samples = decodeUlaw(raw, ch)
+	else if (formatID === 'ima4') samples = decodeIma4(raw, hdr)
+	else throw Error('CAF: unsupported format ' + formatID)
+	return { channelData: samples, sampleRate }
+}
+
+// QuickTime IMA4 ADPCM — 34-byte packets per channel → 64 frames each.
+// The predictor runs continuously across the whole stream; each packet's 2-byte
+// preamble only snapshots the high 9 bits, so resetting per packet would lose up
+// to 127 LSB. State (predictor + step index) is carried on hdr across chunks.
+function decodeIma4(raw, hdr) {
+	let nCh = hdr.channelsPerFrame, fpp = hdr.framesPerPacket || 64
+	let pktBytes = 34 * nCh, nPk = Math.floor(raw.length / pktBytes)
+	if (!nPk) return []
+	let st = (hdr.ima ||= { pred: new Int32Array(nCh), step: new Int32Array(nCh), started: false })
+	let init = !st.started
+	let ch = Array.from({ length: nCh }, () => new Float32Array(nPk * fpp))
+	for (let pk = 0; pk < nPk; pk++) {
+		for (let c = 0; c < nCh; c++) {
+			let bp = pk * pktBytes + c * 34
+			if (init && pk === 0) {
+				let pre = (raw[bp] << 8) | raw[bp + 1]
+				let p = pre & 0xFF80; if (p > 32767) p -= 65536
+				st.pred[c] = p
+				st.step[c] = Math.min(pre & 0x7F, 88)
+			}
+			let pred = st.pred[c], ix = st.step[c], out = ch[c], base = pk * fpp
+			for (let i = 0; i < 32; i++) {
+				let byte = raw[bp + 2 + i]
+				for (let h = 0; h < 2; h++) {
+					let nib = h === 0 ? byte & 0x0F : (byte >> 4) & 0x0F
+					let step = IMA_STEP[ix], diff = step >> 3
+					if (nib & 1) diff += step >> 2
+					if (nib & 2) diff += step >> 1
+					if (nib & 4) diff += step
+					pred += (nib & 8) ? -diff : diff
+					if (pred > 32767) pred = 32767; else if (pred < -32768) pred = -32768
+					ix += IMA_IDX[nib]; if (ix < 0) ix = 0; else if (ix > 88) ix = 88
+					out[base + i * 2 + h] = pred / 32768
+				}
+			}
+			st.pred[c] = pred; st.step[c] = ix
+		}
+	}
+	st.started = true
+	return ch
+}
+
+function decodeLPCM(data, flags, bits, ch) {
+	let isFloat = flags & 1, isLE = flags & 2
+	let bytesPerSample = bits >> 3
+	let totalSamples = (data.length / bytesPerSample) | 0
+	let framesCount = (totalSamples / ch) | 0
+	if (!framesCount) return []
+
+	let dv = new DataView(data.buffer, data.byteOffset, data.byteLength)
+	let channelData = Array.from({ length: ch }, () => new Float32Array(framesCount))
+
+	if (isFloat && bits === 32) {
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off += 4)
+				channelData[c][i] = dv.getFloat32(off, !!isLE)
+	} else if (isFloat && bits === 64) {
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off += 8)
+				channelData[c][i] = dv.getFloat64(off, !!isLE)
+	} else if (bits === 32) {
+		let norm = 1 / 2147483648
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off += 4)
+				channelData[c][i] = dv.getInt32(off, !!isLE) * norm
+	} else if (bits === 24) {
+		let norm = 1 / 8388608
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off += 3) {
+				let s
+				if (!isLE) s = (data[off] << 16) | (data[off + 1] << 8) | data[off + 2]
+				else s = data[off] | (data[off + 1] << 8) | (data[off + 2] << 16)
+				if (s & 0x800000) s |= ~0xFFFFFF
+				channelData[c][i] = s * norm
+			}
+	} else if (bits === 16) {
+		let norm = 1 / 32768
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off += 2)
+				channelData[c][i] = dv.getInt16(off, !!isLE) * norm
+	} else if (bits === 8) {
+		let norm = 1 / 128
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off++)
+				channelData[c][i] = dv.getInt8(off) * norm
+	} else {
+		throw Error('CAF: unsupported LPCM bit depth ' + bits)
+	}
+
+	return channelData
+}
+
+function alawDecode(val) {
+	val ^= 0x55
+	let sign = val & 0x80, seg = (val >> 4) & 7, quant = val & 0x0F
+	let sample = seg ? ((quant << 1) | 0x21) << (seg - 1) : (quant << 1) | 1
+	return (sign ? -sample : sample) / 32768
+}
+
+function ulawDecode(val) {
+	val = ~val & 0xFF
+	let sign = val & 0x80, exp = (val >> 4) & 7, mant = val & 0x0F
+	let sample = ((mant << 1) | 0x21) << exp
+	return (sign ? -(sample - 33) : (sample - 33)) / 32768
+}
+
+function decodeAlaw(data, ch) {
+	let framesCount = (data.length / ch) | 0
+	if (!framesCount) return []
+	let channelData = Array.from({ length: ch }, () => new Float32Array(framesCount))
+	for (let i = 0, off = 0; i < framesCount; i++)
+		for (let c = 0; c < ch; c++, off++)
+			channelData[c][i] = alawDecode(data[off])
+	return channelData
+}
+
+function decodeUlaw(data, ch) {
+	let framesCount = (data.length / ch) | 0
+	if (!framesCount) return []
+	let channelData = Array.from({ length: ch }, () => new Float32Array(framesCount))
+	for (let i = 0, off = 0; i < framesCount; i++)
+		for (let c = 0; c < ch; c++, off++)
+			channelData[c][i] = ulawDecode(data[off])
+	return channelData
+}