@openclaw/whatsapp 2026.10.2 → 2026.10.5-beta.2

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

@@ -729,11 +729,11 @@ var experimentalFlag = "experimentalFlag";
 var footerPresent = "footerPresent";
 var ID3v2 = class _ID3v2 {
   static *getID3v2Header(codecParser, headerCache, readOffset) {
-    const headerLength = 10;
+    const headerLength2 = 10;
     const header2 = {};
     let data3 = yield* codecParser[readRawData](3, readOffset);
     if (data3[0] !== 73 || data3[1] !== 68 || data3[2] !== 51) return null;
-    data3 = yield* codecParser[readRawData](headerLength, readOffset);
+    data3 = yield* codecParser[readRawData](headerLength2, readOffset);
     header2[version] = `id3v2.${data3[3]}.${data3[4]}`;
     if (data3[5] & 15) return null;
     header2[unsynchronizationFlag] = !!(data3[5] & 128);
@@ -743,7 +743,7 @@ var ID3v2 = class _ID3v2 {
     if (data3[6] & 128 || data3[7] & 128 || data3[8] & 128 || data3[9] & 128)
       return null;
     const dataLength = data3[6] << 21 | data3[7] << 14 | data3[8] << 7 | data3[9];
-    header2[length] = headerLength + dataLength;
+    header2[length] = headerLength2 + dataLength;
     return new _ID3v2(header2);
   }
   constructor(header2) {
@@ -974,7 +974,7 @@ var MPEGHeader = class _MPEGHeader extends CodecHeader {
     if (header2[emphasis] === reserved) return null;
     header2[bitDepth] = 16;
     {
-      const { length: length2, frameLength: frameLength2, samples: samples3, ...codecUpdateFields } = header2;
+      const { length: length2, frameLength: frameLength2, samples: samples2, ...codecUpdateFields } = header2;
       headerCache[setHeader](key, header2, codecUpdateFields);
     }
     return new _MPEGHeader(header2);
@@ -1009,8 +1009,8 @@ var MPEGFrame = class _MPEGFrame extends CodecFrame {
       readOffset
     );
   }
-  constructor(header2, frame2, samples3) {
-    super(header2, frame2, samples3);
+  constructor(header2, frame2, samples2) {
+    super(header2, frame2, samples2);
   }
 };
 
@@ -1139,7 +1139,7 @@ var AACHeader = class _AACHeader extends CodecHeader {
           profileBits: profileBits2,
           sampleRateBits: sampleRateBits2,
           frameLength: frameLength2,
-          samples: samples3,
+          samples: samples2,
           numberAACFrames: numberAACFrames2,
           ...codecUpdateFields
         } = header2;
@@ -1193,8 +1193,8 @@ var AACFrame = class _AACFrame extends CodecFrame {
       readOffset
     );
   }
-  constructor(header2, frame2, samples3) {
-    super(header2, frame2, samples3);
+  constructor(header2, frame2, samples2) {
+    super(header2, frame2, samples2);
   }
 };
 
@@ -1443,7 +1443,7 @@ var FLACHeader = class _FLACHeader extends CodecHeader {
           blockingStrategyBits: blockingStrategyBits2,
           frameNumber: frameNumber2,
           sampleNumber: sampleNumber2,
-          samples: samples3,
+          samples: samples2,
           sampleRateBits: sampleRateBits2,
           blockSizeBits: blockSizeBits2,
           crc: crc2,
@@ -1638,10 +1638,10 @@ var OggPage = class _OggPage extends Frame {
     );
     if (header2) {
       const frameLengthValue = headerStore.get(header2)[frameLength];
-      const headerLength = headerStore.get(header2)[length];
-      const totalLength = headerLength + frameLengthValue;
+      const headerLength2 = headerStore.get(header2)[length];
+      const totalLength = headerLength2 + frameLengthValue;
       const rawDataValue = (yield* codecParser[readRawData](totalLength, 0))[subarray](0, totalLength);
-      const frame2 = rawDataValue[subarray](headerLength, totalLength);
+      const frame2 = rawDataValue[subarray](headerLength2, totalLength);
       return new _OggPage(header2, frame2, rawDataValue);
     } else {
       return null;
@@ -1670,8 +1670,8 @@ init_text_decoder();
 // ../../node_modules/codec-parser/src/codecs/opus/OpusFrame.js
 init_text_decoder();
 var OpusFrame = class extends CodecFrame {
-  constructor(data3, header2, samples3) {
-    super(header2, data3, samples3);
+  constructor(data3, header2, samples2) {
+    super(header2, data3, samples2);
   }
 };
 
@@ -1859,12 +1859,12 @@ var OpusParser = class extends Parser {
         if (header2) {
           if (this._preSkipRemaining === null)
             this._preSkipRemaining = header2[preSkip];
-          let samples3 = header2[frameSize] * header2[frameCount] / 1e3 * header2[sampleRate];
+          let samples2 = header2[frameSize] * header2[frameCount] / 1e3 * header2[sampleRate];
           if (this._preSkipRemaining > 0) {
-            this._preSkipRemaining -= samples3;
-            samples3 = this._preSkipRemaining < 0 ? -this._preSkipRemaining : 0;
+            this._preSkipRemaining -= samples2;
+            samples2 = this._preSkipRemaining < 0 ? -this._preSkipRemaining : 0;
           }
-          return new OpusFrame(segment, header2, samples3);
+          return new OpusFrame(segment, header2, samples2);
         }
         this._codecParser[logError2](
           "Failed to parse Ogg Opus Header",
@@ -1882,8 +1882,8 @@ init_text_decoder();
 // ../../node_modules/codec-parser/src/codecs/vorbis/VorbisFrame.js
 init_text_decoder();
 var VorbisFrame = class extends CodecFrame {
-  constructor(data3, header2, samples3) {
-    super(header2, data3, samples3);
+  constructor(data3, header2, samples2) {
+    super(header2, data3, samples2);
   }
 };
 
@@ -2421,7 +2421,6 @@ var codec_parser_default = CodecParser;
 var codecFrames2 = codecFrames;
 var data2 = data;
 var isLastPage2 = isLastPage;
-var samples2 = samples;
 var totalSamples2 = totalSamples;
 
 // ../../node_modules/@wasm-audio-decoders/flac/src/EmscriptenWasm.js
@@ -2880,10 +2879,10 @@ var FLACDecoder = class {
   [decodeFlac](flacFrames) {
     return this._decoder.decodeFrames(flacFrames.map((f) => f[data2] || f));
   }
-  [decodeOggFlac](oggPages) {
-    const frames = oggPages.map((page2) => page2[codecFrames2].map((f) => f[data2])).flat();
+  [decodeOggFlac](oggPages2) {
+    const frames = oggPages2.map((page2) => page2[codecFrames2].map((f) => f[data2])).flat();
     const decoded = this._decoder.decodeFrames(frames);
-    const oggPage = oggPages[oggPages.length - 1];
+    const oggPage = oggPages2[oggPages2.length - 1];
     if (oggPage && oggPage[isLastPage2]) {
       const samplesToTrim = this[totalSamplesDecoded] - oggPage[totalSamples2];
       if (samplesToTrim > 0) {
@@ -2936,6 +2935,44 @@ var FLACDecoder = class {
   }
 };
 
+// ../_build/ogg.js
+init_text_decoder();
+var isPage = (b, o) => b[o] === 79 && b[o + 1] === 103 && b[o + 2] === 103 && b[o + 3] === 83;
+function whole(buf) {
+  let o = 0;
+  while (o + 27 <= buf.length) {
+    if (!isPage(buf, o)) {
+      let k = o + 1;
+      while (k + 4 <= buf.length && !isPage(buf, k)) k++;
+      if (k + 4 > buf.length) return Math.max(o, buf.length - 3);
+      o = k;
+      continue;
+    }
+    let body = o + 27 + buf[o + 26], end = body;
+    if (body > buf.length) break;
+    for (let i = o + 27; i < body; i++) end += buf[i];
+    if (end > buf.length) break;
+    o = end;
+  }
+  return o;
+}
+function oggPages() {
+  let tail = null;
+  return {
+    push(chunk) {
+      let buf = tail ? concat(tail, chunk) : chunk, n = whole(buf);
+      tail = n < buf.length ? buf.slice(n) : null;
+      return buf.subarray(0, n);
+    }
+  };
+}
+function concat(a, b) {
+  let out = new Uint8Array(a.length + b.length);
+  out.set(a);
+  out.set(b, a.length);
+  return out;
+}
+
 // src/decode-flac.src.js
 var EMPTY = Object.freeze({ channelData: Object.freeze([]), sampleRate: 0 });
 async function decode(src) {
@@ -2967,7 +3004,7 @@ async function decoder() {
     upstream.free();
     throw Error("Unsupported @wasm-audio-decoders/flac internals");
   }
-  let parser = null, prefix = null, lookahead = null, ogg = false, total2 = 0, fresh = true;
+  let parser = null, prefix = null, lookahead = null, ogg = false, pages = oggPages(), total2 = 0, fresh = true;
   let pendingRaw = false, duplicateFrames = 0, ended = false, freed = false;
   let resetStream = () => {
     wasm.destroy_decoder(codec2._decoder);
@@ -2979,6 +3016,7 @@ async function decoder() {
     prefix = null;
     lookahead = null;
     ogg = false;
+    pages = oggPages();
     total2 = 0;
     fresh = true;
     pendingRaw = false;
@@ -3059,7 +3097,7 @@ async function decoder() {
         }
       }
     }
-    let r = decodeItems([...parser.parseChunk(buf)]);
+    let r = decodeItems([...parser.parseChunk(ogg ? pages.push(buf) : buf)]);
     return hasAudio(r) ? r : EMPTY;
   };
   upstream.flush = () => {
@@ -3090,20 +3128,114 @@ async function decoder() {
   return upstream;
 }
 function createParser(ogg) {
-  return new codec_parser_default(ogg ? "audio/ogg" : "audio/flac", {
+  if (!ogg) return rawParser();
+  return new codec_parser_default("audio/ogg", {
     onCodec: (codec2) => {
       if (codec2 !== "flac") throw Error("@audio/decode-flac does not support this codec " + codec2);
     },
     enableFrameCRC32: false
   });
 }
+function rawParser() {
+  let buf = new Uint8Array(0), meta = true, start = -1, scan = 0, crc2 = 0;
+  function* frames(end) {
+    if (meta) {
+      if (buf.length < 4) return;
+      let o = 0;
+      if (buf[0] === 102 && buf[1] === 76 && buf[2] === 97 && buf[3] === 67) {
+        o = 4;
+        for (; ; ) {
+          if (o + 4 > buf.length) return;
+          let last = buf[o] & 128, len = buf[o + 1] << 16 | buf[o + 2] << 8 | buf[o + 3];
+          o += 4 + len;
+          if (o > buf.length) return;
+          if (last) break;
+        }
+      }
+      meta = false;
+      buf = buf.subarray(o);
+    }
+    if (start < 0) {
+      let p = 0;
+      while (p + 1 < buf.length && headerLength(buf, p) < 0) p++;
+      if (headerLength(buf, p) < 0) {
+        buf = buf.subarray(p);
+        return;
+      }
+      start = p;
+      scan = p;
+      crc2 = 0;
+    }
+    for (; ; ) {
+      let next = -1;
+      for (; scan < buf.length; scan++) {
+        if (scan > start + 3 && crc2 === 0 && buf[scan] === 255 && (buf[scan + 1] & 254) === 248 && headerLength(buf, scan) > 0) {
+          next = scan;
+          break;
+        }
+        crc2 = CRC16[crc2 >> 8 ^ buf[scan]] ^ crc2 << 8 & 65535;
+      }
+      if (next < 0) {
+        if (end && start < buf.length && crc2 === 0) {
+          yield buf.subarray(start);
+          start = scan = buf.length;
+        }
+        break;
+      }
+      yield buf.subarray(start, next);
+      start = next;
+      crc2 = 0;
+      scan = next;
+    }
+    buf = buf.subarray(start);
+    scan -= start;
+    start = 0;
+  }
+  return {
+    parseChunk(chunk) {
+      buf = buf.length ? concatBytes(buf, chunk) : chunk;
+      return [...frames(false)];
+    },
+    parseAll(all) {
+      buf = all;
+      return [...frames(true)];
+    },
+    flush() {
+      return [...frames(true)];
+    }
+  };
+}
+var CRC16 = Uint16Array.from({ length: 256 }, (_, i) => {
+  let c = i << 8;
+  for (let k = 0; k < 8; k++) c = c & 32768 ? c << 1 ^ 32773 : c << 1;
+  return c & 65535;
+});
+function headerLength(b, p) {
+  if (p + 5 > b.length || b[p] !== 255 || (b[p + 1] & 254) !== 248) return -1;
+  let bs = b[p + 2] >> 4, sr = b[p + 2] & 15;
+  if (!bs || sr === 15 || b[p + 3] >> 4 > 10 || b[p + 3] & 1) return -1;
+  let q = p + 4, c = b[q], n = c < 128 ? 0 : c < 224 ? 1 : c < 240 ? 2 : c < 248 ? 3 : c < 252 ? 4 : c < 254 ? 5 : 6;
+  q += 1 + n + (bs === 6 ? 1 : bs === 7 ? 2 : 0) + (sr === 12 ? 1 : sr === 13 || sr === 14 ? 2 : 0);
+  if (q >= b.length) return -1;
+  let crc2 = 0;
+  for (let i = p; i < q; i++) {
+    crc2 ^= b[i];
+    for (let k = 0; k < 8; k++) crc2 = crc2 & 128 ? (crc2 << 1 ^ 7) & 255 : crc2 << 1 & 255;
+  }
+  return crc2 === b[q] ? q - p + 1 : -1;
+}
+function frameSamples(b) {
+  let bs = b[2] >> 4, c = b[4], n = c < 128 ? 0 : c < 224 ? 1 : c < 240 ? 2 : c < 248 ? 3 : c < 252 ? 4 : c < 254 ? 5 : 6;
+  let q = 5 + n;
+  return bs === 1 ? 192 : bs <= 5 ? 576 << bs - 2 : bs === 6 ? b[q] + 1 : bs === 7 ? (b[q] << 8 | b[q + 1]) + 1 : 256 << bs - 8;
+}
 function parseInitialFlac(buf) {
   let info = flacInfo(buf);
   if (!info) return null;
   try {
     let frames = [...createParser(false).parseAll(buf)];
     if (!frames.length) return null;
-    let parsed = frames.reduce((total2, frame2) => total2 + (frame2[samples2] || 0), 0);
+    let parsed = frames.reduce((total2, frame2) => total2 + frameSamples(frame2), 0);
     return !info.total || parsed === info.total ? { frames, total: info.total } : null;
   } catch {
     return null;

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

@@ -1,6 +1,6 @@
 {
   "name": "@audio/decode-flac",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "Decode FLAC audio with libFLAC WASM",
   "type": "module",
   "main": "decode-flac.js",

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

@@ -33,7 +33,7 @@ dec.free()
 | `dtsc`, `dtsh`, `dtsl`, `dtse`, `mp4a` (0xA9) | DTS (core) | [@audio/decode-dts](../decode-dts) |
 | `ec-3`, `mp4a` (0xA6) | E-AC-3 (Dolby Digital Plus) | [@audio/decode-eac3](../decode-eac3) |
 
-TrueHD tracks throw an error naming the codec. Fragmented MP4 (`moof`) is not supported. QuickTime sound descriptions v0, v1 and v2 are handled, including `wave`-wrapped configs and `enda` endianness flags. When `moov` follows `mdat` (typical of camera and QuickTime output) the file is buffered until the header arrives.
+TrueHD tracks throw an error naming the codec. Fragmented MP4 (ISO/IEC 14496-12 §8.8, `moof`+`mdat` after an empty-table `moov`) streams fragment by fragment, holding only the bytes not yet read. QuickTime sound descriptions v0, v1 and v2 are handled, including `wave`-wrapped configs and `enda` endianness flags. When `moov` follows `mdat` (typical of camera and QuickTime output) the file is buffered until the header arrives.
 
 Codec packages are imported dynamically, which is unavailable inside an AudioWorklet — decode in the main thread or a Worker.
 

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

@@ -41,6 +41,7 @@ class MP4Decoder {
 		this.pending = null   // codec load in flight
 		this.codec = null     // { feed(frames), flush(), free() }
 		this.st = null        // sample-table walker: { sizes, stco, stsc, idx, ci, sInC, spc, nextOff }
+		this.fr = null        // fragment walker (fragmented file): { id, trex, pos, queue, qi }
 		this.left = null      // unconsumed bytes
 		this.fileOff = 0      // absolute file offset of left[0]
 		this.skip = 0         // bytes to discard before the next sample
@@ -52,7 +53,7 @@ class MP4Decoder {
 		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))
-		if (this.st) return this.feed(buf)
+		if (this.st || this.fr) return this.feed(buf)
 
 		this.accum.push(buf); this.accumLen += buf.length
 		let all = this.accum.length === 1 ? this.accum[0] : concat(this.accum, this.accumLen)
@@ -64,8 +65,10 @@ class MP4Decoder {
 			if (this.freed) { codec.free(); return EMPTY }
 			this.codec = codec
 			let { sizes, stco, stsc } = track
-			this.st = { sizes, stco, stsc, idx: 0, ci: 0, sInC: 0, spc: spcAt(0, stsc), nextOff: stco[0] }
 			this.left = all; this.fileOff = 0; this.skip = 0
+			// fragmented (ISO/IEC 14496-12 §8.8): samples come in moof+mdat pairs after the moov
+			if (track.fragmented) { this.fr = { id: track.id, trex: track.trex, pos: 0, queue: [], qi: 0 }; return this.fragments() }
+			this.st = { sizes, stco, stsc, idx: 0, ci: 0, sInC: 0, spc: spcAt(0, stsc), nextOff: stco[0] }
 			return this.extract()
 		})
 	}
@@ -78,7 +81,37 @@ class MP4Decoder {
 			if (!buf.length) return EMPTY
 		}
 		this.left = append(this.left, buf)
-		return this.extract()
+		return this.fr ? this.fragments() : this.extract()
+	}
+
+	// Top-level boxes in order: each complete moof queues its samples (absolute offsets), which are
+	// read out of the following mdat as its bytes arrive; bytes nobody needs any more are dropped.
+	fragments() {
+		let fr = this.fr, frames = []
+		for (;;) {
+			let q = fr.queue
+			for (; fr.qi < q.length; fr.qi++) {
+				let [off, sz] = q[fr.qi], b = off - this.fileOff
+				if (!this.left || b + sz > this.left.length) break
+				frames.push(this.left.subarray(b, b + sz))
+			}
+			if (fr.qi === q.length) { q.length = 0; fr.qi = 0 }
+			let b = fr.pos - this.fileOff, left = this.left
+			if (fr.pos === Infinity || !left || b < 0 || b + 8 > left.length) break
+			let size = r32(left, b), type = str4(left, b + 4)
+			if (size === 1) { if (b + 16 > left.length) break; size = r32(left, b + 8) * 0x100000000 + r32(left, b + 12) }
+			else if (size === 0) size = Infinity  // to the end of the file
+			if (type === 'moof') {
+				if (b + size > left.length) break  // wait for the whole moof
+				moofSamples(left, b, size, fr.pos, fr)
+			}
+			fr.pos += size
+		}
+		// keep bytes from the next queued sample or the next box, whichever comes first
+		let keep = Math.min(fr.pos, fr.qi < fr.queue.length ? fr.queue[fr.qi][0] : Infinity), end = this.fileOff + (this.left?.length || 0)
+		if (keep >= end && keep !== Infinity) { this.skip = keep - end; this.fileOff = end; this.left = null }
+		else if (keep > this.fileOff && keep !== Infinity) { this.left = this.left.subarray(keep - this.fileOff).slice(); this.fileOff = keep }
+		return frames.length ? this.codec.feed(frames) : EMPTY
 	}
 
 	// Walk sample tables by absolute file offset so chunk boundaries are irrelevant.
@@ -104,7 +137,6 @@ class MP4Decoder {
 		if (this.pending) return this.pending.then(() => this.flush())
 		this.freed = true
 		if (!this.codec) {
-			if (this.accumLen && findBox(concat(this.accum, this.accumLen), 'moof')) throw Error('Fragmented MP4 is not supported')
 			throw Error(this.accumLen ? 'No audio track found in MP4' : 'Not an MP4 file')
 		}
 		try { return this.codec.flush() } finally { this.codec.free(); this.codec = null; this.left = null }
@@ -114,14 +146,14 @@ class MP4Decoder {
 		if (this.freed) return
 		this.freed = true
 		this.codec?.free(); this.codec = null
-		this.accum = []; this.left = null; this.st = null
+		this.accum = []; this.left = null; this.st = null; this.fr = null
 	}
 }
 
 
 // ===== ISO BMFF demuxer =====
 
-const CONTAINERS = new Set(['moov', 'trak', 'mdia', 'minf', 'stbl', 'udta', 'edts', 'sinf', 'wave'])
+const CONTAINERS = new Set(['moov', 'trak', 'mdia', 'minf', 'stbl', 'udta', 'edts', 'sinf', 'wave', 'mvex', 'traf'])
 
 /** Walk boxes in [start, end), calling cb(type, body, bodyOff) for leaves and cb(type, null) at container boundaries. */
 function walk(buf, start, end, cb) {
@@ -144,10 +176,37 @@ function walk(buf, start, end, cb) {
 	return true
 }
 
-function findBox(buf, name) {
-	let found = false
-	walk(buf, 0, buf.length, type => { if (type === name) found = true })
-	return found
+/** Queue the samples a moof's track fragments place (ISO/IEC 14496-12 §8.8.7 tfhd, §8.8.8 trun):
+ *  absolute [offset, size] pairs, sizes from trun, else tfhd's default, else trex's. */
+function moofSamples(buf, start, size, abs, fr) {
+	let traf = null
+	walk(buf, start + 8, start + size, (type, d) => {
+		if (type === 'traf') traf = { base: abs, size: fr.trex.size || 0, mine: false, next: null }
+		else if (type === 'tfhd') {
+			let flags = (d[1] << 16) | (d[2] << 8) | d[3], p = 8
+			traf.mine = r32(d, 4) === fr.id
+			if (flags & 1) { traf.base = r32(d, p) * 0x100000000 + r32(d, p + 4); p += 8 }  // else: default-base-is-moof, or the first traf
+			if (flags & 2) p += 4
+			if (flags & 8) p += 4
+			if (flags & 0x10) traf.size = r32(d, p)
+		}
+		else if (type === 'trun' && traf?.mine) {
+			let flags = (d[1] << 16) | (d[2] << 8) | d[3], n = r32(d, 4), p = 8
+			let off = traf.next ?? traf.base
+			if (flags & 1) { off = traf.base + (r32(d, p) | 0); p += 4 }
+			if (flags & 4) p += 4
+			for (let i = 0; i < n; i++) {
+				if (flags & 0x100) p += 4
+				let sz = traf.size
+				if (flags & 0x200) { sz = r32(d, p); p += 4 }
+				if (flags & 0x400) p += 4
+				if (flags & 0x800) p += 4
+				fr.queue.push([off, sz])
+				off += sz
+			}
+			traf.next = off
+		}
+	})
 }
 
 // QuickTime sound sample description: v0 = 36-byte header, v1 adds 16 bytes, v2 declares its own size.
@@ -179,13 +238,17 @@ function parseStsd(buf, off, end, cb) {
 
 /** Parse the first audio track out of a complete moov. Returns null while moov is incomplete or absent. */
 function parseTrack(buf) {
-	let traks = [], t = null, moov = false
+	let traks = [], t = null, moov = false, trex = new Map(), movie = {}
 	walk(buf, 0, buf.length, (type, data, off) => {
 		if (type === 'moov') moov = true
+		else if (type === 'mvhd' || type === 'ilst' && !t) movie[type] = data  // movie timescale; iTunes tags
 		else if (type === 'trak') traks.push(t = { children: {} })
+		else if (type === '/trak') t = null
+		else if (type === 'trex') trex.set(r32(data, 4), { size: r32(data, 16) })
 		else if (!t) return
+		else if (type === 'tkhd') t.id = r32(data, data[0] === 1 ? 20 : 12)
 		else if (type === 'hdlr') t.handler = str4(data, 8)
-		else if (type === 'mdhd') t.timescale = r32(data, data[0] === 1 ? 20 : 12)
+		else if (type === 'mdhd') { t.timescale = r32(data, data[0] === 1 ? 20 : 12); t.children.mdhd = data }
 		else if (type === 'entry') t.entry ??= data
 		else if (type === 'stsz') t.sizes = parseStsz(data)
 		else if (type === 'stco') t.stco = parseStco(data)
@@ -196,8 +259,11 @@ function parseTrack(buf) {
 	if (!moov) return null
 	let track = traks.find(t => t.handler === 'soun' && t.entry) ?? traks.find(t => t.entry && AUDIO_TYPES.has(t.entry.type))
 	if (!track) throw Error('No audio track found in MP4')
-	if (!track.sizes || !track.stco?.length) throw Error('Audio track has no sample tables')
+	// movie fragments carry the samples when mvex is there and the tables are empty
+	if (trex.size && !track.sizes?.length) { track.fragmented = true; track.trex = trex.get(track.id) || {} }
+	else if (!track.sizes || !track.stco?.length) throw Error('Audio track has no sample tables')
 	if (!track.entry.sampleRate && track.timescale) track.entry.sampleRate = track.timescale
+	track.movie = movie
 	return track
 }
 
@@ -252,32 +318,34 @@ const MP3_OTI = new Set([0x69, 0x6B]), AAC_OTI = new Set([0x40, 0x66, 0x67, 0x68
 const UNSUPPORTED = { 0xE1: 'QCELP' }
 const DTS_TYPES = new Set(['dtsc', 'dtsh', 'dtsl', 'dtse']) // DTS-HD variants carry a decodable core
 
-async function createCodec({ entry, children }) {
+async function createCodec({ entry, children, movie }) {
 	let { type } = entry
+	// AAC and ALAC trim the encoder's priming and padding by the track's edit list or iTunSMPB, MP3 and Opus by the edit list (gapless)
+	let boxes = { elst: children.elst, mdhd: children.mdhd, stts: children.stts, mvhd: movie?.mvhd, ilst: movie?.ilst ?? children.ilst }
 	if (type === 'mp4a') {
 		let { oti, dsi } = children.esds ? parseEsds(children.esds) : {}
-		if (MP3_OTI.has(oti)) return frames(import('@audio/decode-mp3'))
+		if (MP3_OTI.has(oti)) return mp3(boxes)
 		if (oti === 0xA5) return frames(import('@audio/decode-ac3'))
 		if (oti === 0xA9) return frames(import('@audio/decode-dts'))
 		if (oti === 0xA6) return frames(import('@audio/decode-eac3'))
 		if (!oti || AAC_OTI.has(oti)) {
 			if (!dsi) throw Error('MP4 AAC track has no AudioSpecificConfig')
-			return aac({ asc: dsi })
+			return aac({ asc: dsi }, boxes)
 		}
 		throw unsupported(UNSUPPORTED[oti] || 'esds object type 0x' + oti.toString(16))
 	}
 	if (type === 'alac') {
 		if (!children.alac) throw Error('MP4 ALAC track has no magic cookie')
-		return aac({ alac: children.alac })
+		return aac({ alac: children.alac }, boxes)
 	}
-	if (type === '.mp3') return frames(import('@audio/decode-mp3'))
+	if (type === '.mp3') return mp3(boxes)
 	if (type === 'fLaC') {
 		if (!children.dfLa) throw Error('MP4 FLAC track has no dfLa box')
 		return flac(children.dfLa.subarray(4))
 	}
 	if (type === 'Opus') {
 		if (!children.dOps) throw Error('MP4 Opus track has no dOps box')
-		return opus(children.dOps)
+		return opus(children.dOps, boxes)
 	}
 	if (type === 'samr' || type === 'sawb') return amr(type === 'sawb')
 	if (type === 'ac-3') return frames(import('@audio/decode-ac3'))
@@ -319,8 +387,9 @@ function pcmFormat(e, ch) {
 
 // --- adapters: { feed(frames: Uint8Array[]), flush(), free() } ---
 
-async function aac(opts) {
-	let dec = await (await import('@audio/decode-aac')).decoder(opts)
+async function aac(opts, boxes) {
+	let { decoder, gapless } = await import('@audio/decode-aac')
+	let dec = await decoder({ ...opts, gapless: gapless?.({ ...boxes, ...opts }) })
 	return { feed: frames => dec.decode(frames), flush: () => dec.flush(), free: () => dec.free() }
 }
 
@@ -330,6 +399,28 @@ async function frames(load) {
 	return { feed: frames => dec.decode(concat(frames)), flush: () => dec.flush?.() ?? EMPTY, free: () => dec.free() }
 }
 
+// MP3 samples carry no LAME tag, so mpg123 decodes from the media's first sample: the edit list's window drops the
+// encoder and decoder delay (1105 for LAME, as ffmpeg writes it) and the padding. decode-aac reads the window.
+async function mp3(boxes) {
+	let [codec, { gapless }] = await Promise.all([frames(import('@audio/decode-mp3')), import('@audio/decode-aac')])
+	return windowed(codec, gapless?.(boxes))
+}
+
+// the edit list's window { start, duration } (seconds) over a codec that decodes from the media's first sample
+function windowed(codec, g) {
+	if (!g) return codec
+	let skip = null, left = null
+	let cut = r => {
+		let n = r.channelData?.[0]?.length
+		if (!n) return r
+		skip ??= Math.round(g.start * r.sampleRate); left ??= g.duration == null ? Infinity : Math.round(g.duration * r.sampleRate)
+		let a = Math.min(n, skip), b = Math.min(n, a + left)
+		skip -= a; left -= b - a
+		return b <= a ? EMPTY : a || b < n ? { ...r, channelData: r.channelData.map(c => c.subarray(a, b)) } : r
+	}
+	return { feed: frames => cut(codec.feed(frames)), flush: () => cut(codec.flush()), free: codec.free }
+}
+
 async function flac(blocks) {
 	let dec = await (await import('@audio/decode-flac')).decoder()
 	let head = concat([new Uint8Array([0x66, 0x4C, 0x61, 0x43]), blocks]) // "fLaC" + METADATA_BLOCKs
@@ -341,16 +432,24 @@ async function flac(blocks) {
 	}
 }
 
-async function opus(dOps) {
-	let channels = dOps[1]
-	let opts = { channels, sampleRate: 48000, preSkip: r16(dOps, 2), outputGain: (r16(dOps, 8) << 16) >> 16 }
+// Mapping family 1 orders 3–8 channels as Vorbis does (RFC 7845 §5.1.1.2): out in SMPTE/WAV order (L R C LFE Ls Rs …)
+// as decode-opus reorders Ogg Opus: output channel j takes the coded channel of Vorbis position OPUS_ORDER[n][j]
+const OPUS_ORDER = { 3: [0, 2, 1], 5: [0, 2, 1, 3, 4], 6: [0, 2, 1, 5, 3, 4], 7: [0, 2, 1, 6, 5, 3, 4], 8: [0, 2, 1, 7, 5, 6, 3, 4] }
+
+// Opus in ISOBMFF: the edit list's media_time covers PreSkip and its duration is the real length, so with an edit
+// list the window trims both ends from the media's first sample; without one, dOps' PreSkip trims the start
+async function opus(dOps, boxes) {
+	let [{ createOpusDecoder }, { gapless }] = await Promise.all([import('@audio/decode-opus/core'), import('@audio/decode-aac')])
+	let g = gapless?.(boxes), channels = dOps[1]
+	let opts = { channels, sampleRate: 48000, preSkip: g ? 0 : r16(dOps, 2), outputGain: (r16(dOps, 8) << 16) >> 16 }
 	if (dOps[10] > 0) {
 		opts.streamCount = dOps[11]; opts.coupledStreamCount = dOps[12]
-		opts.channelMappingTable = Array.from(dOps.subarray(13, 13 + channels))
+		let table = Array.from(dOps.subarray(13, 13 + channels))
+		opts.channelMappingTable = dOps[10] === 1 && OPUS_ORDER[channels] ? OPUS_ORDER[channels].map(i => table[i]) : table
 	}
-	let dec = await (await import('@audio/decode-opus/core')).createOpusDecoder()
+	let dec = await createOpusDecoder()
 	dec.configure(opts)
-	return {
+	return windowed({
 		feed: frames => {
 			let r = dec.decodeFrames(frames)
 			if (!r.samplesDecoded) return EMPTY
@@ -358,7 +457,7 @@ async function opus(dOps) {
 		},
 		flush: () => EMPTY,
 		free: () => dec.free()
-	}
+	}, g)
 }
 
 async function amr(wb) {

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

@@ -1,6 +1,6 @@
 {
   "name": "@audio/decode-mp4",
-  "version": "1.1.1",
+  "version": "1.3.1",
   "description": "Decode the audio track of MP4, MOV, M4A, M4V and 3GP files (AAC, ALAC, MP3, FLAC, Opus, AMR, PCM) to PCM samples",
   "type": "module",
   "main": "decode-mp4.js",
@@ -27,13 +27,13 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@audio/decode-aac": "^1.5.0",
+    "@audio/decode-aac": "^1.6.0",
     "@audio/decode-ac3": "^1.0.0",
     "@audio/decode-amr": "^1.3.0",
     "@audio/decode-dts": "^1.0.0",
     "@audio/decode-flac": "^1.3.0",
     "@audio/decode-mp3": "^1.3.0",
-    "@audio/decode-opus": "^1.3.0",
+    "@audio/decode-opus": "^1.3.3",
     "@audio/decode-eac3": "^1.0.0"
   },
   "devDependencies": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@audio/decode-opus",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "Decode Ogg Opus audio with local libopus WASM",
   "type": "module",
   "main": "decode-opus.js",