@openclaw/whatsapp 2026.9.5 → 2026.9.7

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

@@ -0,0 +1,115 @@
+/**
+ * FLAC metadata parser — Vorbis comments, pictures, cue sheets.
+ * @module @audio/decode-flac/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 ───────────────────────────────────────────────────────────
+
+const STREAMINFO = 0, PADDING = 1, VORBIS_COMMENT = 4, CUESHEET = 5, PICTURE = 6
+
+export 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'
+}
+
+// ── Binary helpers ──────────────────────────────────────────────────────
+
+function u32be(b, o) { return (b[o] * 0x1000000) + (b[o + 1] << 16) + (b[o + 2] << 8) + b[o + 3] }
+function u32le(b, o) { return b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] * 0x1000000) }
+function u24be(b, o) { return (b[o] << 16) | (b[o + 1] << 8) | b[o + 2] }
+function fourcc(b, o) { return String.fromCharCode(b[o], b[o + 1], b[o + 2], b[o + 3]) }
+
+// ── Block parsers ───────────────────────────────────────────────────────
+
+function parseVorbisComment(b) {
+  let off = 0
+  let vendorLen = u32le(b, off); off += 4
+  off += vendorLen
+  let n = u32le(b, off); off += 4
+  let out = {}
+  for (let i = 0; i < n; i++) {
+    let len = u32le(b, off); off += 4
+    let s = str(b.subarray(off, off + len), 'utf-8')
+    off += len
+    let eq = s.indexOf('=')
+    if (eq < 0) continue
+    let key = s.slice(0, eq).toUpperCase(), val = s.slice(eq + 1)
+    let norm = VORBIS_MAP[key]
+    if (norm) out[norm] = val
+  }
+  return out
+}
+
+function parseFlacPicture(b) {
+  let off = 0
+  let type = u32be(b, off); off += 4
+  let mimeLen = u32be(b, off); off += 4
+  let mime = str(b.subarray(off, off + mimeLen), 'iso-8859-1'); off += mimeLen
+  let descLen = u32be(b, off); off += 4
+  let desc = str(b.subarray(off, off + descLen), 'utf-8'); off += descLen
+  off += 16  // width, height, depth, colors
+  let dataLen = u32be(b, off); off += 4
+  let data = b.slice(off, off + dataLen)
+  return { mime, type, description: desc, data }
+}
+
+function parseCueSheet(b) {
+  let markers = [], regions = []
+  let off = 395  // media catalog (128) + leadin (8) + flags (1) + reserved (258)
+  if (b.length < off + 1) return { markers, regions }
+  let numTracks = b[off]; off += 1
+  for (let t = 0; t < numTracks; t++) {
+    if (off + 36 > b.length) break
+    let trackOffLow = u32be(b, off + 4), trackOffHigh = u32be(b, off)
+    let trackOffset = trackOffHigh * 0x100000000 + trackOffLow
+    let trackNum = b[off + 8]
+    let nIdx = b[off + 35]
+    off += 36
+    if (nIdx > 0 && trackNum < 170) markers.push({ sample: trackOffset, label: `Track ${trackNum}` })
+    off += nIdx * 12
+  }
+  return { markers, regions }
+}
+
+/** Parse FLAC metadata blocks. Returns {meta, sampleRate, markers, regions} or null. */
+export function parseMeta(bytes) {
+  if (!bytes?.length || bytes.length < 4 || fourcc(bytes, 0) !== 'fLaC') return null
+  let meta = {}, raw = { blocks: [] }, pictures = []
+  let sampleRate = 0, markers = [], regions = []
+  let off = 4
+  while (off + 4 <= bytes.length) {
+    let hdr = bytes[off]
+    let last = !!(hdr & 0x80), type = hdr & 0x7f
+    let size = u24be(bytes, off + 1)
+    let body = bytes.subarray(off + 4, off + 4 + size)
+    if (type !== STREAMINFO && type !== PADDING) raw.blocks.push({ type, body })
+    if (type === STREAMINFO && body.length >= 18) {
+      sampleRate = (body[10] << 12) | (body[11] << 4) | (body[12] >> 4)
+    } else if (type === VORBIS_COMMENT) {
+      Object.assign(meta, parseVorbisComment(body))
+    } else if (type === PICTURE) {
+      let p = parseFlacPicture(body)
+      if (p) pictures.push(p)
+    } else if (type === CUESHEET) {
+      let c = parseCueSheet(body)
+      markers.push(...c.markers); regions.push(...c.regions)
+    }
+    off += 4 + size
+    if (last) break
+  }
+
+  meta.raw = raw
+  meta.pictures = pictures
+  return { meta, sampleRate, markers, regions }
+}

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

@@ -0,0 +1,60 @@
+{
+  "name": "@audio/decode-flac",
+  "version": "1.3.3",
+  "description": "Decode FLAC audio with libFLAC WASM",
+  "type": "module",
+  "main": "decode-flac.js",
+  "types": "decode-flac.d.ts",
+  "exports": {
+    ".": "./decode-flac.js",
+    "./meta": "./meta.js",
+    "./audio": {
+      "types": "./audio.d.ts",
+      "default": "./audio.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "decode-flac.js",
+    "decode-flac.d.ts",
+    "meta.js",
+    "LICENSE",
+    "audio.js",
+    "audio.d.ts"
+  ],
+  "scripts": {
+    "build": "bash build.sh",
+    "prepack": "npm run build",
+    "test": "node test.js"
+  },
+  "keywords": [
+    "flac",
+    "audio",
+    "decode",
+    "decoder",
+    "wasm",
+    "lossless"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "audiojs",
+  "homepage": "https://github.com/audiojs/decode/tree/master/packages/decode-flac#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode.git",
+    "directory": "packages/decode-flac"
+  },
+  "bugs": "https://github.com/audiojs/decode/issues",
+  "dependencies": {
+    "@wasm-audio-decoders/flac": "~0.2.10",
+    "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-mod/LICENSE

@@ -0,0 +1,23 @@
+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:
+    * 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 audiojs 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-mod/LICENSE.libopenmpt

@@ -0,0 +1,25 @@
+Copyright (c) 2004-2026, OpenMPT Project Developers and Contributors
+Copyright (c) 1997-2003, Olivier Lapicque
+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 OpenMPT project 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-mod/README.md

@@ -0,0 +1,86 @@
+# @audio/decode-mod
+
+Decode tracker modules — MOD, XM, S3M, IT, MPTM, and everything else [libopenmpt](https://lib.openmpt.org/libopenmpt/) reads — to PCM float samples.<br>
+[libopenmpt](https://github.com/OpenMPT/openmpt) compiled to a single-file WASM ES module — no side files, loads from any CDN, Node, workers and AudioWorklets.
+
+[![npm install @audio/decode-mod](https://nodei.co/npm/@audio/decode-mod.png?mini=true)](https://npmjs.org/package/@audio/decode-mod/)
+
+```js
+import decode, { decoder, info } from '@audio/decode-mod'
+
+let { channelData, sampleRate } = await decode(modBytes)
+
+let meta = await info(modBytes)
+// { title, artist, type, typeLong, tracker, message, duration, channels, patterns, orders, instruments, samples }
+```
+
+A tracker module is a small program (samples + patterns + a playback sequence), not raw
+audio — libopenmpt is the mixer that renders it. Render params follow libopenmpt's public
+C API (`libopenmpt/libopenmpt.h`): `openmpt_module_create_from_memory2`,
+`openmpt_module_read_float_{mono,stereo,quad}`, `openmpt_module_set_render_param`. A
+module is a whole file, not a stream — there's no meaningful partial parse of a truncated
+MOD/XM/S3M/IT, so `decode()` always needs the complete file. `repeat_count` is fixed at 0
+(play once); `duration` is a render-length cap for songs that loop or whose estimated
+length is impractically long.
+
+```js
+let { channelData } = await decode(bytes, {
+  sampleRate: 44100,
+  channels: 1,           // mono / stereo / quad (L,R,RL,RR)
+  duration: 30,           // seconds — cap for endless/looping songs
+  interpolation: 2,       // 0 internal default, 1 hold, 2 linear, 4 cubic, 8 windowed sinc
+  stereoSeparation: 150,  // percent, [0,200]
+  gain: -6,                // dB
+})
+```
+
+| Param | Default | |
+|---|---|---|
+| `sampleRate` | `48000` | Output sample rate, Hz |
+| `channels` | `2` | `1` mono, `2` stereo, `4` quad (L,R,RL,RR) |
+| `duration` | libopenmpt's estimate, capped at 600s | Seconds to render; hard cap for endless/looping songs |
+| `interpolation` | `8` | `OPENMPT_MODULE_RENDER_INTERPOLATIONFILTER_LENGTH` — 0 internal default, 1 zero-order hold, 2 linear, 4 cubic, 8 windowed sinc (8 taps) |
+| `stereoSeparation` | `100` | Percent, `[0,200]` |
+| `gain` | — | Master gain, dB |
+
+## API
+
+### `decode(src: Uint8Array | ArrayBuffer, opts?): Promise<AudioData>`
+
+Render a complete module.
+
+### `info(src: Uint8Array | ArrayBuffer): Promise<ModuleInfo>`
+
+Read title/artist/format/duration/channel-and-pattern counts without rendering audio.
+
+### `decoder(opts?): Promise<ModDecoder>`
+
+`{ decode(chunk), flush(), free() }`. `decode(chunk)` expects (and renders) a complete
+file in one call — a module can't be parsed from a partial buffer. `flush()` returns
+empty (nothing carries over); `free()` is a no-op (no WASM state outlives a single
+`decode()` call). Matches [@audio/decode-qoa](../decode-qoa)'s whole-file shape.
+
+### `AudioData`
+
+```ts
+{ channelData: Float32Array[], sampleRate: number }
+```
+
+## Notes
+
+- MO3 (a separately-compressed OpenMPT container) is not supported: it needs either an
+  external `unmo3` or the bundled minimp3/stb_vorbis/miniz fallback decoders, none of
+  which ship here (see `build.sh`) to keep the WASM small.
+- No volume-ramping/click suppression beyond libopenmpt's own mixer — that's libopenmpt's
+  job, not this package's.
+- Format reference: [ProTracker MOD](https://www.aes.id.au/modformat.html), [FastTracker II XM](https://github.com/milkytracker/MilkyTracker/blob/master/resources/reference/xm-form.txt), [Scream Tracker 3 S3M](https://www.romhacking.net/documents/[177]S3M%20Format.txt), [Impulse Tracker IT](https://github.com/schismtracker/schismtracker/wiki/ITTECH.TXT); libopenmpt's own [C API docs](https://lib.openmpt.org/doc/).
+
+**Use when:** playing back tracker-format chiptunes/game music in the browser, or converting a `.mod`/`.xm`/`.s3m`/`.it` library to PCM/WAV in bulk.
+
+---
+
+Part of [@audio/decode](https://github.com/audiojs/decode) — the decode family umbrella.
+
+## License
+
+[ॐ](https://github.com/krishnized/license/) · [BSD-3-Clause](./LICENSE), same as the bundled [libopenmpt](./LICENSE.libopenmpt).

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

@@ -0,0 +1,20 @@
+// 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
+
+type AudioData = { channelData: Float32Array[], sampleRate: number }
+
+/** Codec plugin 'mod' — extends audio()'s openable formats / save() targets */
+export declare const mod: { codec: 'mod', decode(bytes: Uint8Array): AudioData | Promise<AudioData> }
+/** Codec plugin 'xm' — extends audio()'s openable formats / save() targets */
+export declare const xm: { codec: 'xm', decode(bytes: Uint8Array): AudioData | Promise<AudioData> }
+/** Codec plugin 's3m' — extends audio()'s openable formats / save() targets */
+export declare const s3m: { codec: 's3m', decode(bytes: Uint8Array): AudioData | Promise<AudioData> }
+/** Codec plugin 'it' — extends audio()'s openable formats / save() targets */
+export declare const it: { codec: 'it', decode(bytes: Uint8Array): AudioData | Promise<AudioData> }

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

@@ -0,0 +1,12 @@
+// audio.js manifest — codec atoms, decode half: whole-buffer bytes → { channelData,
+// sampleRate }. One libopenmpt decoder serves four format names (MPTM shares the IT
+// loader). Format detection is magic-byte (audio-type) — no test() needed here.
+
+import decodeFn from './decode-mod.js'
+
+const decode = (bytes) => decodeFn(bytes)
+
+export const mod = { codec: 'mod', decode }
+export const xm = { codec: 'xm', decode }
+export const s3m = { codec: 's3m', decode }
+export const it = { codec: 'it', decode }

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

@@ -0,0 +1,58 @@
+export interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+export interface DecodeOpts {
+  /** @default 48000 */
+  sampleRate?: number;
+  /** mono / stereo / quad (L,R,RL,RR). @default 2 */
+  channels?: 1 | 2 | 4;
+  /** Seconds to render. @default libopenmpt's own duration estimate, capped at 600s */
+  duration?: number;
+  /** OPENMPT_MODULE_RENDER_INTERPOLATIONFILTER_LENGTH: 0 internal default, 1 zero-order hold, 2 linear, 4 cubic, 8 windowed sinc (8 taps). @default 8 */
+  interpolation?: 0 | 1 | 2 | 4 | 8;
+  /** Percent, [0,200]. @default 100 */
+  stereoSeparation?: number;
+  /** Master gain in dB. */
+  gain?: number;
+}
+
+export interface ModuleInfo {
+  title: string;
+  artist: string;
+  /** Format extension, e.g. "it" */
+  type: string;
+  /** Format name, e.g. "Impulse Tracker" */
+  typeLong: string;
+  /** Tracker the file was (most likely) saved with */
+  tracker: string;
+  /** Song message, or instrument/sample name listing when the format has no message */
+  message: string;
+  /** libopenmpt's duration estimate in seconds (openmpt_module_get_duration_seconds) */
+  duration: number;
+  /** Pattern channel count — independent of the rendered output channel count */
+  channels: number;
+  patterns: number;
+  orders: number;
+  instruments: number;
+  samples: number;
+}
+
+interface ModDecoder {
+  /** Renders a complete module file. Partial buffers are not supported — a module isn't a stream. */
+  decode(data: Uint8Array | ArrayBuffer): Promise<AudioData>;
+  /** No-op: decode() already returns the full render. */
+  flush(): AudioData;
+  /** No-op: no WASM state outlives a single decode() call. */
+  free(): void;
+}
+
+/** Decode a complete tracker module (MOD, XM, S3M, IT, MPTM, …) to PCM. */
+export default function decode(src: ArrayBuffer | Uint8Array, opts?: DecodeOpts): Promise<AudioData>;
+
+/** Read module metadata (title, duration, channel/pattern/order counts…) without rendering audio. */
+export function info(src: ArrayBuffer | Uint8Array): Promise<ModuleInfo>;
+
+/** Initialize WASM and create a whole-file decoder. */
+export function decoder(opts?: DecodeOpts): Promise<ModDecoder>;

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

@@ -0,0 +1,148 @@
+/**
+ * Tracker module renderer — libopenmpt (MOD, XM, S3M, IT, MPTM, and everything else
+ * libopenmpt reads: 669, AMF, AMS, C67, DBM, DIGI, DMF, DSM, DTM, FAR, FMT, FTM, GDM,
+ * ICE, IMF, ITP, J2B, MDL, MED, MO3*, MT2, MTM, MUS, OKT, PLM, PSM, PT36, PTM, PUMA,
+ * RTM, SFX, STM, STP, SYMMOD, ULT, UMX, WOW — see openmpt_get_supported_extensions())
+ * compiled to a single-file WASM ES module. A module is a whole file, not a stream:
+ * there is no meaningful partial parse of a truncated MOD/XM/S3M/IT, so decode() always
+ * needs the complete file — see decoder() below.
+ *
+ * *MO3 needs either an external unmo3 or the bundled minimp3/stb_vorbis/miniz fallback
+ * decoders; none of those ship here (see build.sh), so MO3 files fail to load cleanly.
+ *
+ * let { channelData, sampleRate } = await decode(modBytes)
+ * let meta = await info(modBytes)   // title, duration, channel/pattern/order counts…
+ */
+import createMod from './src/mod.wasm.js'
+
+const EMPTY = Object.freeze({ channelData: [], sampleRate: 0 })
+const BLOCK = 4096          // frames rendered per libopenmpt call
+const MAX_DURATION_S = 600  // default cap for endless/looping songs when opts.duration is omitted
+
+// OPENMPT_MODULE_RENDER_* — libopenmpt/libopenmpt.h
+const RENDER_MASTERGAIN_MILLIBEL = 1
+const RENDER_STEREOSEPARATION_PERCENT = 2
+const RENDER_INTERPOLATIONFILTER_LENGTH = 3
+
+let modP
+function getMod() {
+	if (modP) return modP
+	let p = createMod()
+	modP = p
+	return p.catch(e => { modP = null; throw e })
+}
+
+function toBytes(src) { return src instanceof Uint8Array ? src : new Uint8Array(src) }
+
+/** Load a module, throw libopenmpt's own error text on failure. Caller must destroy(). */
+function open(m, bytes) {
+	let ptr = m._malloc(bytes.length)
+	m.HEAPU8.set(bytes, ptr)
+	let mod = m._audio_mod_create(ptr, bytes.length)
+	m._free(ptr)
+	if (!mod) throw Error('MOD: ' + m.UTF8ToString(m._audio_mod_last_error()))
+	return mod
+}
+
+function metaStr(m, mod, key) {
+	let len = m.lengthBytesUTF8(key) + 1, kp = m._malloc(len)
+	m.stringToUTF8(key, kp, len)
+	let rp = m._audio_mod_get_metadata(mod, kp)
+	m._free(kp)
+	let s = m.UTF8ToString(rp)
+	m._audio_mod_free_string(rp)
+	return s
+}
+
+/**
+ * Render a complete module to PCM.
+ * @param {Uint8Array|ArrayBuffer} src
+ * @param {object} [opts]
+ * @param {number} [opts.sampleRate=48000]
+ * @param {1|2|4} [opts.channels=2] mono / stereo / quad (L,R,RL,RR)
+ * @param {number} [opts.duration] seconds to render; default is libopenmpt's own duration
+ *   estimate (openmpt_module_get_duration_seconds), capped at 600 s for endless/looping songs
+ * @param {0|1|2|4|8} [opts.interpolation=8] OPENMPT_MODULE_RENDER_INTERPOLATIONFILTER_LENGTH —
+ *   0 internal default, 1 zero-order hold, 2 linear, 4 cubic, 8 windowed sinc (8 taps)
+ * @param {number} [opts.stereoSeparation=100] percent, [0,200]
+ * @param {number} [opts.gain] dB, applied as master gain
+ * @returns {Promise<{channelData: Float32Array[], sampleRate: number}>}
+ */
+export default async function decode(src, opts) {
+	let m = await getMod()
+	return render(m, toBytes(src), opts)
+}
+
+function render(m, bytes, opts = {}) {
+	let { sampleRate = 48000, channels = 2, duration, interpolation = 8, stereoSeparation = 100, gain } = opts
+	if (channels !== 1 && channels !== 2 && channels !== 4) throw Error('MOD: channels must be 1, 2 or 4')
+	let mod = open(m, bytes)
+	try {
+		m._audio_mod_set_repeat_count(mod, 0)
+		m._audio_mod_set_render_param(mod, RENDER_INTERPOLATIONFILTER_LENGTH, interpolation)
+		m._audio_mod_set_render_param(mod, RENDER_STEREOSEPARATION_PERCENT, stereoSeparation)
+		if (gain != null) m._audio_mod_set_render_param(mod, RENDER_MASTERGAIN_MILLIBEL, Math.round(gain * 100))
+
+		let capS = duration != null ? duration : Math.min(m._audio_mod_get_duration_seconds(mod), MAX_DURATION_S)
+		let maxFrames = Math.ceil(capS * sampleRate)
+		let bufs = Array.from({ length: channels }, () => m._malloc(BLOCK * 4))
+		try {
+			let parts = [], frames = 0
+			while (frames < maxFrames) {
+				let want = Math.min(BLOCK, maxFrames - frames)
+				let n = channels === 1 ? m._audio_mod_read_mono(mod, sampleRate, want, bufs[0])
+					: channels === 2 ? m._audio_mod_read_stereo(mod, sampleRate, want, bufs[0], bufs[1])
+					: m._audio_mod_read_quad(mod, sampleRate, want, bufs[0], bufs[1], bufs[2], bufs[3])
+				if (!n) break // song end (repeat count exhausted)
+				parts.push(bufs.map(p => m.HEAPF32.slice(p >> 2, (p >> 2) + n)))
+				frames += n
+			}
+			if (!frames) return EMPTY
+			let channelData = Array.from({ length: channels }, (_, c) => {
+				let o = new Float32Array(frames), off = 0
+				for (let p of parts) { o.set(p[c], off); off += p[c].length }
+				return o
+			})
+			return { channelData, sampleRate }
+		} finally { for (let p of bufs) m._free(p) }
+	} finally { m._audio_mod_destroy(mod) }
+}
+
+/**
+ * Read module metadata without rendering audio.
+ * @param {Uint8Array|ArrayBuffer} src
+ */
+export async function info(src) {
+	let m = await getMod()
+	let mod = open(m, toBytes(src))
+	try {
+		return {
+			title: metaStr(m, mod, 'title'),
+			artist: metaStr(m, mod, 'artist'),
+			type: metaStr(m, mod, 'type'),
+			typeLong: metaStr(m, mod, 'type_long'),
+			tracker: metaStr(m, mod, 'tracker'),
+			message: metaStr(m, mod, 'message'),
+			duration: m._audio_mod_get_duration_seconds(mod),
+			channels: m._audio_mod_get_num_channels(mod),
+			patterns: m._audio_mod_get_num_patterns(mod),
+			orders: m._audio_mod_get_num_orders(mod),
+			instruments: m._audio_mod_get_num_instruments(mod),
+			samples: m._audio_mod_get_num_samples(mod),
+		}
+	} finally { m._audio_mod_destroy(mod) }
+}
+
+/**
+ * Whole-file decoder. A module can't be parsed from a partial buffer, so decode(chunk)
+ * expects (and returns) the complete rendered file in one call; flush() has nothing left
+ * to do. free() is a no-op — no WASM state outlives a single decode() call.
+ */
+export async function decoder(opts) {
+	let m = await getMod()
+	return {
+		decode: (chunk) => chunk && chunk.byteLength ? render(m, toBytes(chunk), opts) : EMPTY,
+		flush: () => EMPTY,
+		free: () => {},
+	}
+}

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

@@ -0,0 +1,68 @@
+{
+  "name": "@audio/decode-mod",
+  "version": "1.0.0",
+  "description": "Decode tracker modules — MOD, XM, S3M, IT, MPTM and more — with libopenmpt WASM",
+  "type": "module",
+  "main": "decode-mod.js",
+  "types": "decode-mod.d.ts",
+  "exports": {
+    ".": "./decode-mod.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-mod.js",
+    "decode-mod.d.ts",
+    "src/mod.wasm.js",
+    "audio.js",
+    "audio.d.ts",
+    "LICENSE",
+    "LICENSE.libopenmpt"
+  ],
+  "devDependencies": {
+    "tst": "^9.4.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mod",
+    "xm",
+    "s3m",
+    "it",
+    "mptm",
+    "tracker",
+    "protracker",
+    "fasttracker",
+    "impulse-tracker",
+    "chiptune",
+    "audio",
+    "decode",
+    "decoder",
+    "wasm",
+    "libopenmpt"
+  ],
+  "license": "BSD-3-Clause",
+  "author": "audiojs",
+  "homepage": "https://github.com/audiojs/decode/tree/main/packages/decode-mod",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode.git",
+    "directory": "packages/decode-mod"
+  },
+  "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-mp3/LICENSE

@@ -0,0 +1,25 @@
+This work is offered to Krishna (https://github.com/krishnized/license).
+
+---
+
+The MIT License (MIT)
+
+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-mp3/README.md

@@ -0,0 +1,20 @@
+# @audio/decode-mp3
+
+Decode MP3 audio with [mpg123-decoder](https://github.com/eshaz/wasm-audio-decoders/tree/main/src/mpg123-decoder).
+
+```js
+import decode, { decoder } from '@audio/decode-mp3'
+
+let { channelData, sampleRate } = await decode(mp3Bytes)
+
+let dec = await decoder() // initialize WASM
+let a = dec.decode(chunk1)
+let b = dec.decode(chunk2)
+dec.free()
+```
+
+`decoder()` is asynchronous. Its `decode()` method is synchronous.
+
+## License
+
+[ॐ](https://github.com/krishnized/license/) · [MIT](./LICENSE)