@poe-platform/safe-bash 0.1.839 → 0.1.841

package/dist/safe-bash/command-chunks/{chunk-FH5VMAPS.js → chunk-BZW25LNV.js}

@@ -381276,7 +381276,7 @@ function buildProbeStream(track, desc, stats, idx, containerFormat) {
     duration_ts: track.duration,
     duration: durationSec.toFixed(6),
     bit_rate: bitRate,
-    nb_frames: String(nbFrames),
+    nb_frames: containerFormat === "wav" ? void 0 : String(nbFrames),
     disposition: {
       default: track.enabled ? 1 : 0,
       dub: 0,
@@ -381979,7 +381979,7 @@ function parseMp4(bytes, options = {}) {
       else if (step.kind === "sync-has") answer = syncSamples.has(step.sample);
       else {
         const { offset, ...sample } = step.sample;
-        samples.push({ ...sample, data: bytes.subarray(offset, offset + sample.size) });
+        samples.push({ ...sample, offset, data: bytes.subarray(offset, offset + sample.size) });
       }
     }
     if (moofBoxes.length > 0) {
@@ -382019,7 +382019,7 @@ function parseMp4(bytes, options = {}) {
               if (step.kind === "read") answer2 = bytes.subarray(step.offset, step.offset + step.length);
               else if (step.kind === "sample") {
                 const { offset, ...sample } = step.sample;
-                samples.push({ ...sample, data: bytes.subarray(offset, offset + sample.size) });
+                samples.push({ ...sample, offset, data: bytes.subarray(offset, offset + sample.size) });
               }
             }
           }
@@ -383203,8 +383203,8 @@ function buildProbeResultFromDoc(doc, byteLength, filename = "input.mp4", option
             duration: s.duration,
             duration_time: durTime,
             size: String(s.size),
-            pos: String(bytePos),
-            flags: s.isKeyframe ? "K_" : "__"
+            pos: String(s.offset ?? (doc.containerFormat === "mp4" || doc.containerFormat === "mov" ? -1 : bytePos)),
+            flags: s.isKeyframe ? "K__" : "___"
           });
         }
         if (options.showFrames) {
@@ -383218,13 +383218,12 @@ function buildProbeResultFromDoc(doc, byteLength, filename = "input.mp4", option
             pkt_dts_time: dtsTime,
             best_effort_timestamp: s.pts,
             best_effort_timestamp_time: ptsTime,
-            pkt_duration: s.duration,
-            pkt_duration_time: durTime,
+            ...doc.containerFormat === "gif" ? { duration: s.duration, duration_time: durTime } : { pkt_duration: s.duration, pkt_duration_time: durTime },
             pkt_size: String(s.size),
             width: w,
             height: h,
             pix_fmt: track.type === "video" ? desc?.pixFmt ?? "yuv420p" : void 0,
-            pict_type: track.type === "video" ? s.isKeyframe ? "I" : "P" : void 0,
+            pict_type: void 0,
             sample_fmt: sampleFormat,
             nb_samples: track.type === "audio" ? s.duration : void 0,
             channels: track.type === "audio" ? desc?.channels ?? 2 : void 0
@@ -384267,6 +384266,132 @@ function serializeDashDocument(doc, options = {}) {
   return { manifest, resources };
 }
 
+// packages/mp4-ast/src/containers/mp3-frames.ts
+import { mpegFrame } from "../../audio-ast/index.js";
+function* scanMp3Frames() {
+  const frames = [];
+  let offset = 0, first = true, skipSamples = 0, discardPadding = 0;
+  while (true) {
+    const bytes = yield { offset, length: 4 };
+    if (!bytes.length) break;
+    if (bytes.length < 4) throw new Error("Truncated MPEG frame");
+    const marker = String.fromCharCode(...bytes.subarray(0, 3));
+    if (marker === "ID3") {
+      const tag = yield { offset: offset + 4, length: 6 };
+      if (tag.length !== 6 || tag.subarray(2).some((b) => b > 127)) throw new Error("Invalid ID3 header");
+      const size = tag[2] * 2097152 + tag[3] * 16384 + tag[4] * 128 + tag[5];
+      offset += 10 + size + (bytes[3] === 4 && tag[1] & 16 ? 10 : 0);
+      continue;
+    }
+    if (marker === "TAG") {
+      const tag = yield { offset: offset + 4, length: 124 };
+      if (tag.length !== 124) throw new Error("Truncated ID3v1 tag");
+      offset += 128;
+      continue;
+    }
+    const header = new DataView(bytes.buffer, bytes.byteOffset, 4).getUint32(0);
+    const frame = mpegFrame(header, offset, Infinity);
+    const payload = yield { offset: offset + 4, length: frame.frameSize - 4 };
+    if (payload.length !== frame.frameSize - 4) throw new Error("Truncated MPEG frame");
+    const side = frame.version === 1 ? frame.channels === 1 ? 17 : 32 : frame.channels === 1 ? 9 : 17;
+    const xing = side + (header & 65536 ? 0 : 2);
+    const text = (pos) => String.fromCharCode(...payload.subarray(pos, pos + 4));
+    const metadata = first && (["Xing", "Info"].includes(text(xing)) || text(32) === "VBRI");
+    if (metadata && ["Xing", "Info"].includes(text(xing)) && xing + 8 <= payload.length) {
+      const flags = new DataView(payload.buffer, payload.byteOffset, payload.length).getUint32(xing + 4);
+      const encoder = xing + 8 + (flags & 1 ? 4 : 0) + (flags & 2 ? 4 : 0) + (flags & 4 ? 100 : 0) + (flags & 8 ? 4 : 0);
+      if (encoder + 24 <= payload.length && ["LAME", "Lavc", "Lavf"].includes(text(encoder))) {
+        const delay = payload[encoder + 21] * 16 + (payload[encoder + 22] >>> 4);
+        const padding = (payload[encoder + 22] & 15) * 256 + payload[encoder + 23];
+        skipSamples = delay + 529;
+        discardPadding = Math.max(0, padding - 529);
+      }
+    }
+    first = false;
+    if (!metadata) frames.push({ offset, size: frame.frameSize, sampleRate: frame.rate, channels: frame.channels, samples: frame.count, skipSamples: 0, discardPadding: 0 });
+    offset += frame.frameSize;
+  }
+  if (!frames.length) throw new Error("MP3 contains no MPEG frames");
+  for (const frame of frames) {
+    frame.skipSamples = Math.min(skipSamples, frame.samples);
+    skipSamples -= frame.skipSamples;
+  }
+  for (let i = frames.length - 1; i >= 0 && discardPadding; i--) {
+    const frame = frames[i];
+    frame.discardPadding = Math.min(discardPadding, frame.samples - frame.skipSamples);
+    discardPadding -= frame.discardPadding;
+  }
+  return frames;
+}
+function readMp3Frames(bytes) {
+  const scan = scanMp3Frames();
+  let step = scan.next();
+  while (!step.done) {
+    const { offset, length } = step.value;
+    step = scan.next(bytes.subarray(offset, offset + length));
+  }
+  return step.value;
+}
+async function readMp3SourceFrames(source, signal) {
+  signal?.throwIfAborted();
+  if (!Number.isSafeInteger(source.size) || source.size < 0) throw new RangeError("Invalid MP3 source size");
+  const scan = scanMp3Frames();
+  let step = scan.next();
+  while (!step.done) {
+    const { offset, length } = step.value;
+    const bytes = new Uint8Array(Math.max(0, Math.min(length, source.size - offset)));
+    let filled = 0;
+    while (filled < bytes.length) {
+      signal?.throwIfAborted();
+      const chunk = await source.read(offset + filled, bytes.length - filled);
+      signal?.throwIfAborted();
+      if (!chunk.length || chunk.length > bytes.length - filled) throw new Error("Invalid MP3 source read");
+      bytes.set(chunk, filled);
+      filled += chunk.length;
+    }
+    step = scan.next(bytes);
+  }
+  signal?.throwIfAborted();
+  return step.value;
+}
+async function readMp3StreamFrames(source, signal) {
+  signal?.throwIfAborted();
+  const scan = scanMp3Frames();
+  let step = scan.next(), bytes = new Uint8Array(step.done ? 0 : step.value.length);
+  let size = 0, filled = 0;
+  let failure;
+  for await (const chunk of source) {
+    signal?.throwIfAborted();
+    const start = size;
+    size += chunk.byteLength;
+    if (!Number.isSafeInteger(size)) throw new RangeError("Invalid MP3 source size");
+    if (failure) continue;
+    try {
+      while (!step.done && step.value.offset < size) {
+        signal?.throwIfAborted();
+        const request = step.value;
+        const from = Math.max(start, request.offset + filled), end = Math.min(size, request.offset + request.length);
+        if (end > from) {
+          bytes.set(chunk.subarray(from - start, end - start), filled);
+          filled += end - from;
+        }
+        if (filled < request.length) break;
+        step = scan.next(bytes);
+        bytes = new Uint8Array(step.done ? 0 : step.value.length);
+        filled = 0;
+      }
+    } catch (error) {
+      signal?.throwIfAborted();
+      failure = { error };
+    }
+  }
+  signal?.throwIfAborted();
+  if (failure) throw failure.error;
+  if (!step.done) step = scan.next(bytes.subarray(0, filled));
+  if (!step.done) throw new Error("Truncated MP3 source");
+  return { frames: step.value, size };
+}
+
 // packages/mp4-ast/src/aac.ts
 function decodeAacTrack(doc, track) {
   const description = track.codecDescriptions[0];
@@ -384514,6 +384639,101 @@ function encodeFlacPackets(doc) {
   return frames;
 }
 
+// packages/mp4-ast/src/containers/flac-probe.ts
+function checksum(value, byte, width, polynomial) {
+  value ^= byte << width - 8;
+  for (let bit = 0; bit < 8; bit++) value = value << 1 ^ (value & 1 << width - 1 ? polynomial : 0);
+  return value & (1 << width) - 1;
+}
+function frameHeader(bytes, start) {
+  if (bytes[start] !== 255 || (bytes[start + 1] & 254) !== 248 || bytes[start + 3] & 1) return;
+  const block = bytes[start + 2] >>> 4, rate = bytes[start + 2] & 15;
+  if (!block || rate === 15 || bytes[start + 3] >>> 4 > 10) return;
+  let pos = start + 4, number = bytes[pos++];
+  if (number >= 128) {
+    let tails = 0, mask = 128;
+    while (number & mask) {
+      tails++;
+      mask >>>= 1;
+    }
+    if (tails < 2 || tails > 7) return;
+    number &= mask - 1;
+    for (let i = 1; i < tails; i++) {
+      const byte = bytes[pos++];
+      if ((byte & 192) !== 128) return;
+      number = number * 64 + (byte & 63);
+    }
+  }
+  let duration = block === 1 ? 192 : block < 6 ? 576 * 2 ** (block - 2) : 256 * 2 ** (block - 8);
+  if (block === 6) duration = bytes[pos++] + 1;
+  if (block === 7) {
+    duration = bytes[pos] * 256 + bytes[pos + 1] + 1;
+    pos += 2;
+  }
+  pos += rate === 12 ? 1 : rate >= 13 ? 2 : 0;
+  if (pos >= bytes.length) return;
+  let crc2 = 0;
+  for (let i = start; i <= pos; i++) crc2 = checksum(crc2, bytes[i], 8, 7);
+  if (crc2) return;
+  return { duration, number, variable: !!(bytes[start + 1] & 1) };
+}
+var FlacFrameScanner = class {
+  header = new Uint8Array(42);
+  packets = [];
+  size = 0;
+  pending = new Uint8Array();
+  offset = 0;
+  metadataEnd = 4;
+  audio = false;
+  lastMetadata = false;
+  crc = 0;
+  frame;
+  fixedBlockSize = 0;
+  push(chunk, final = false) {
+    if (this.size < 42) this.header.set(chunk.subarray(0, 42 - this.size), this.size);
+    this.size += chunk.length;
+    let bytes = chunk;
+    if (this.pending.length) {
+      bytes = new Uint8Array(this.pending.length + chunk.length);
+      bytes.set(this.pending);
+      bytes.set(chunk, this.pending.length);
+    }
+    let pos = 0;
+    const end = final ? bytes.length : Math.max(0, bytes.length - 16);
+    for (; pos < end; pos++, this.offset++) {
+      if (!this.audio) {
+        if (this.offset < this.metadataEnd) continue;
+        if (!this.lastMetadata) {
+          if (pos + 4 > bytes.length) break;
+          this.lastMetadata = !!(bytes[pos] & 128);
+          this.metadataEnd = this.offset + 4 + bytes[pos + 1] * 65536 + bytes[pos + 2] * 256 + bytes[pos + 3];
+          continue;
+        }
+        this.audio = true;
+      }
+      if (!this.frame || this.crc === 0) {
+        const header = frameHeader(bytes, pos);
+        if (header) {
+          if (this.frame) this.packets.push({ ...this.frame, size: this.offset - this.frame.pos });
+          this.fixedBlockSize ||= header.duration;
+          this.frame = {
+            pts: header.variable ? header.number : header.number * this.fixedBlockSize,
+            duration: header.duration,
+            pos: this.offset
+          };
+          this.crc = 0;
+        }
+      }
+      if (this.frame) this.crc = checksum(this.crc, bytes[pos], 16, 32773);
+    }
+    this.pending = bytes.slice(pos);
+    if (final && this.frame && this.crc === 0) {
+      this.packets.push({ ...this.frame, size: this.offset - this.frame.pos });
+      this.frame = void 0;
+    }
+  }
+};
+
 // packages/mp4-ast/src/containers/ogg.ts
 function page(packet, sequence, flags, granule) {
   const segments = Math.floor(packet.length / 255) + 1;
@@ -384634,7 +384854,7 @@ async function readOggFlacHeader(source, options = {}) {
     const start = offset, header = await read(27);
     if (header[0] !== 79 || header[1] !== 103 || header[2] !== 103 || header[3] !== 83) throw new Error("Invalid Ogg page");
     const lacing = await read(header[26]);
-    let checksum = oggCrc(lacing, oggCrc(header), 27);
+    let checksum2 = oggCrc(lacing, oggCrc(header), 27);
     const continuation = Boolean(header[5] & 1) !== packetSize > 0;
     let remaining = 0, chunk = new Uint8Array(), used = 0;
     for (const length of lacing) remaining += length;
@@ -384643,7 +384863,7 @@ async function readOggFlacHeader(source, options = {}) {
         if (used === chunk.length) {
           chunk = await read(Math.min(16384, remaining));
           used = 0;
-          checksum = oggCrc(chunk, checksum, offset - start - chunk.length);
+          checksum2 = oggCrc(chunk, checksum2, offset - start - chunk.length);
           remaining -= chunk.length;
         }
         const take = Math.min(pending, chunk.length - used);
@@ -384661,7 +384881,7 @@ async function readOggFlacHeader(source, options = {}) {
         packetSize = 0;
       }
     }
-    if (checksum !== new DataView(header.buffer).getUint32(22, true)) throw new Error("Ogg CRC mismatch");
+    if (checksum2 !== new DataView(header.buffer).getUint32(22, true)) throw new Error("Ogg CRC mismatch");
     if (continuation) throw new Error("Invalid Ogg packet continuation");
     if (firstSize >= 0 && !mapped) return void 0;
   }
@@ -386509,7 +386729,10 @@ function aacAst() {
 function isWavSignature(bytes) {
   return bytes.byteLength >= 12 && decodeFourCC(bytes, 0) === "RIFF" && decodeFourCC(bytes, 8) === "WAVE";
 }
-var wavPacketFrames = 1024;
+function wavPacketFrames(sampleRate, block) {
+  const samples = Math.max(1, Math.min(Math.floor(sampleRate / 10), Math.floor(2147483647 / block)));
+  return 2 ** Math.floor(Math.log2(samples));
+}
 function parseWav(bytes, options = {}) {
   const header = readWavHeader(bytes);
   const { formatTag, channels, sampleRate, bitsPerSample } = header;
@@ -386540,7 +386763,7 @@ function parseWav(bytes, options = {}) {
     decodedAudio = { sampleRate, channels, channelData };
   }
   const samples = [];
-  const chunkFrames = wavPacketFrames;
+  const chunkFrames = wavPacketFrames(header.sampleRate, bytesPerFrame);
   for (let offsetSample = 0; offsetSample < totalPcmSamples; offsetSample += chunkFrames) {
     const count = Math.min(chunkFrames, totalPcmSamples - offsetSample);
     const byteStart = offsetSample * bytesPerFrame;
@@ -386643,7 +386866,6 @@ function wavMetadata(header, filename = "input.wav") {
   const bytesPerFrame = Math.max(1, header.channels * (header.bitsPerSample >>> 3));
   return { ...result, streams: [{
     ...result.streams[0],
-    nb_frames: String(Math.ceil(samples / wavPacketFrames)),
     bit_rate: doc.durationSeconds > 0 ? String(Math.round(samples * bytesPerFrame * 8 / doc.durationSeconds)) : "0"
   }] };
 }
@@ -386651,10 +386873,11 @@ function wavRecords(header, options) {
   const metadata = wavMetadata(header, options.filename), stream = metadata.streams[0];
   const bytesPerFrame = Math.max(1, header.channels * (header.bitsPerSample >>> 3));
   const samples = Math.floor(header.dataSize / bytesPerFrame), rate = Math.max(1, header.sampleRate);
+  const chunkFrames = wavPacketFrames(header.sampleRate, bytesPerFrame);
   function* spans() {
-    for (let pts = 0; pts < samples; pts += wavPacketFrames) {
+    for (let pts = 0; pts < samples; pts += chunkFrames) {
       options.signal?.throwIfAborted();
-      const count = Math.min(wavPacketFrames, samples - pts);
+      const count = Math.min(chunkFrames, samples - pts);
       yield { pts, count, size: String(count * bytesPerFrame), time: (pts / rate).toFixed(6), duration: (count / rate).toFixed(6) };
     }
     options.signal?.throwIfAborted();
@@ -386673,7 +386896,7 @@ function wavRecords(header, options) {
         duration_time: s.duration,
         size: s.size,
         pos: String(s.pts * bytesPerFrame),
-        flags: "K_"
+        flags: "K__"
       };
     } } : void 0,
     frames: options.showFrames ? { *[Symbol.iterator]() {
@@ -386753,20 +386976,21 @@ function isMp3Signature(bytes) {
   if (bytes[0] === 73 && bytes[1] === 68 && bytes[2] === 51) return true;
   return bytes[0] === 255 && (bytes[1] & 224) === 224 && (bytes[1] & 6) !== 0;
 }
-function mp3Document(byteLength, samples) {
-  const sampleRate = 44100, channels = 2, count = Math.max(1, Math.floor(byteLength / 417));
+function mp3Document(byteLength, frames, samples) {
+  const { sampleRate, channels } = frames[0];
+  const duration = frames.reduce((sum, frame) => sum + frame.samples * 14112e3 / frame.sampleRate, 0);
   return {
     containerFormat: "mp3",
-    timescale: sampleRate,
-    duration: count * 1152,
-    durationSeconds: count * 1152 / sampleRate,
+    timescale: 14112e3,
+    duration,
+    durationSeconds: duration / 14112e3,
     tracks: [
       {
         id: 1,
         type: "audio",
         handlerType: "soun",
-        timescale: sampleRate,
-        duration: count * 1152,
+        timescale: 14112e3,
+        duration,
         language: "und",
         enabled: true,
         codecDescriptions: [
@@ -386785,24 +387009,27 @@ function mp3Document(byteLength, samples) {
     byteLength
   };
 }
-function mp3Records(size, options) {
+function mp3Records(size, frames, options) {
   options.signal?.throwIfAborted();
-  if (!Number.isSafeInteger(size) || size < 0) throw new RangeError("Invalid MP3 source size");
-  const count = Math.max(1, Math.floor(size / 417)), doc = mp3Document(size, []);
+  const doc = mp3Document(size, frames, []);
   const metadata = buildProbeResultFromDoc(doc, size, options.filename ?? "input.mp3", {
     formatName: "mp3",
     formatLongName: "MP2/3 (MPEG audio layer 2/3)"
   });
   const stream = {
     ...metadata.streams[0],
-    nb_frames: String(count),
-    bit_rate: String(Math.round(Math.min(size, count * 417) * 8 / doc.durationSeconds))
+    nb_frames: void 0,
+    nb_read_packets: String(frames.length),
+    nb_read_frames: String(frames.filter((f) => f.samples > f.skipSamples + f.discardPadding).length),
+    bit_rate: String(Math.round(frames.reduce((sum, f) => sum + f.size, 0) * 8 / doc.durationSeconds))
   };
   function* spans() {
-    for (let index = 0; index < count; index++) {
+    let pts = 0;
+    for (const frame of frames) {
       options.signal?.throwIfAborted();
-      const pts = index * 1152;
-      yield { pts, time: (pts / 44100).toFixed(6), size: String(Math.min(417, size - index * 417)), pos: String(index * 417) };
+      const duration = frame.samples * 14112e3 / frame.sampleRate;
+      yield { ...frame, pts, duration, time: (pts / 14112e3).toFixed(6), durationTime: (duration / 14112e3).toFixed(6) };
+      pts += duration;
     }
     options.signal?.throwIfAborted();
   }
@@ -386817,52 +387044,48 @@ function mp3Records(size, options) {
         pts_time: s.time,
         dts: s.pts,
         dts_time: s.time,
-        duration: 1152,
-        duration_time: (1152 / 44100).toFixed(6),
-        size: s.size,
-        pos: s.pos,
-        flags: "K_"
+        duration: s.duration,
+        duration_time: s.durationTime,
+        size: String(s.size),
+        pos: String(s.offset),
+        flags: "K__"
       };
     } } : void 0,
     frames: options.showFrames ? { *[Symbol.iterator]() {
-      for (const s of spans()) yield {
-        media_type: "audio",
-        stream_index: 0,
-        key_frame: 1,
-        pts: s.pts,
-        pts_time: s.time,
-        pkt_dts: s.pts,
-        pkt_dts_time: s.time,
-        best_effort_timestamp: s.pts,
-        best_effort_timestamp_time: s.time,
-        pkt_duration: 1152,
-        pkt_duration_time: (1152 / 44100).toFixed(6),
-        pkt_size: s.size,
-        width: void 0,
-        height: void 0,
-        pix_fmt: void 0,
-        pict_type: void 0,
-        sample_fmt: stream.sample_fmt,
-        nb_samples: 1152,
-        channels: 2
-      };
+      for (const s of spans()) {
+        const samples = s.samples - s.skipSamples - s.discardPadding;
+        if (!samples) continue;
+        const pts = s.pts + s.skipSamples * 14112e3 / s.sampleRate, time = (pts / 14112e3).toFixed(6);
+        const duration = samples * 14112e3 / s.sampleRate;
+        yield {
+          media_type: "audio",
+          stream_index: 0,
+          key_frame: 1,
+          pts,
+          pts_time: time,
+          pkt_dts: pts,
+          pkt_dts_time: time,
+          best_effort_timestamp: pts,
+          best_effort_timestamp_time: time,
+          duration,
+          duration_time: (duration / 14112e3).toFixed(6),
+          pkt_size: String(s.size),
+          sample_fmt: stream.sample_fmt,
+          nb_samples: samples,
+          channels: s.channels
+        };
+      }
     } } : void 0
   };
 }
 function mp3Ast() {
   return {
     async probeMetadata(source, options = {}) {
-      return mp3Records(source.size, options);
+      return mp3Records(source.size, await readMp3SourceFrames(source, options.signal), options);
     },
     async probeMetadataStream(source, options = {}) {
-      options.signal?.throwIfAborted();
-      let size = 0;
-      for await (const chunk of source) {
-        options.signal?.throwIfAborted();
-        size += chunk.byteLength;
-        if (!Number.isSafeInteger(size)) throw new RangeError("Invalid MP3 source size");
-      }
-      return mp3Records(size, options);
+      const { frames, size } = await readMp3StreamFrames(source, options.signal);
+      return mp3Records(size, frames, options);
     },
     id: "mp3",
     formatName: "mp3",
@@ -386879,23 +387102,24 @@ function mp3Ast() {
       return false;
     },
     parse(bytes) {
-      const numFrames = Math.max(1, Math.floor(bytes.byteLength / 417));
-      const samples = [];
-      for (let i = 0; i < numFrames; i++) {
-        const start = Math.min(bytes.byteLength, i * 417);
-        const end = Math.min(bytes.byteLength, start + 417);
-        samples.push({
-          data: bytes.subarray(start, end),
-          dts: i * 1152,
-          pts: i * 1152,
+      const frames = readMp3Frames(bytes);
+      let pts = 0;
+      const samples = frames.map((frame) => {
+        const duration = frame.samples * 14112e3 / frame.sampleRate;
+        const sample = {
+          data: bytes.subarray(frame.offset, frame.offset + frame.size),
+          dts: pts,
+          pts,
           cts: 0,
-          duration: 1152,
-          size: end - start,
+          duration,
+          size: frame.size,
           isKeyframe: true,
           sampleDescriptionIndex: 1
-        });
-      }
-      return mp3Document(bytes.byteLength, samples);
+        };
+        pts += duration;
+        return sample;
+      });
+      return mp3Document(bytes.byteLength, frames, samples);
     },
     serialize(doc) {
       const numFrames = Math.max(1, Math.ceil((doc.durationSeconds || 1) * 44100 / 1152));
@@ -386906,13 +387130,13 @@ function mp3Ast() {
       frame[3] = 0;
       return concatBytes(Array.from({ length: numFrames }, () => frame));
     },
-    probe(bytes, options) {
-      const doc = this.parse(bytes, options);
-      return buildProbeResultFromDoc(doc, bytes.byteLength, options?.filename ?? "input.mp3", {
-        ...options,
-        formatName: "mp3",
-        formatLongName: "MP2/3 (MPEG audio layer 2/3)"
-      });
+    probe(bytes, options = {}) {
+      const result = mp3Records(bytes.length, readMp3Frames(bytes), options);
+      return {
+        ...result,
+        packets: result.packets ? Array.from(result.packets) : void 0,
+        frames: result.frames ? Array.from(result.frames) : void 0
+      };
     },
     concat(docs, options) {
       return concatMp4(docs, options);
@@ -386977,42 +387201,61 @@ function flacDocument(bytes, byteLength, data = new Uint8Array()) {
     byteLength
   };
 }
+function flacProbe(scanner, options = {}) {
+  const doc = flacDocument(scanner.header.subarray(0, Math.min(42, scanner.size)), scanner.size);
+  const samples = scanner.packets.map((packet) => ({
+    ...packet,
+    dts: packet.pts,
+    cts: 0,
+    data: new Uint8Array(),
+    isKeyframe: true,
+    sampleDescriptionIndex: 1
+  }));
+  const result = buildProbeResultFromDoc(
+    { ...doc, tracks: [{ ...doc.tracks[0], samples }] },
+    scanner.size,
+    options.filename ?? "input.flac",
+    { ...options, formatName: "flac", formatLongName: "raw FLAC" }
+  );
+  return {
+    ...result,
+    streams: result.streams.map((stream) => ({
+      ...stream,
+      nb_frames: void 0,
+      nb_read_packets: String(samples.length),
+      nb_read_frames: String(samples.length)
+    })),
+    packets: result.packets?.map((packet, index) => ({ ...packet, pos: String(scanner.packets[index].pos) }))
+  };
+}
 function flacAst() {
   return {
     async probeMetadata(source, options = {}) {
       options.signal?.throwIfAborted();
       if (!Number.isSafeInteger(source.size) || source.size < 0) throw new RangeError("Invalid FLAC source size");
-      const header = new Uint8Array(Math.min(42, source.size));
-      for (let offset = 0; offset < header.length; ) {
-        const chunk = await source.read(offset, header.length - offset);
+      const scanner = new FlacFrameScanner();
+      while (scanner.size < source.size) {
+        const length = Math.min(16384, source.size - scanner.size);
+        const chunk = await source.read(scanner.size, length);
         options.signal?.throwIfAborted();
         if (!chunk.length) throw new Error("Unexpected end of FLAC source");
-        if (chunk.length > header.length - offset) throw new Error("FLAC source returned more bytes than requested");
-        header.set(chunk, offset);
-        offset += chunk.length;
+        if (chunk.length > length) throw new Error("FLAC source returned more bytes than requested");
+        scanner.push(chunk);
       }
-      return buildProbeResultFromDoc(flacDocument(header, source.size), source.size, options.filename ?? "input.flac", {
-        ...options,
-        formatName: "flac",
-        formatLongName: "raw FLAC"
-      });
+      scanner.push(new Uint8Array(), true);
+      return flacProbe(scanner, options);
     },
     async probeMetadataStream(source, options = {}) {
       options.signal?.throwIfAborted();
-      const header = new Uint8Array(42);
-      let size = 0;
+      const scanner = new FlacFrameScanner();
       for await (const chunk of source) {
         options.signal?.throwIfAborted();
-        if (size < header.length) header.set(chunk.subarray(0, header.length - size), size);
-        size += chunk.length;
-        if (!Number.isSafeInteger(size)) throw new RangeError("Invalid FLAC source size");
+        scanner.push(chunk);
+        if (!Number.isSafeInteger(scanner.size)) throw new RangeError("Invalid FLAC source size");
       }
       options.signal?.throwIfAborted();
-      return buildProbeResultFromDoc(flacDocument(header.subarray(0, Math.min(size, header.length)), size), size, options.filename ?? "input.flac", {
-        ...options,
-        formatName: "flac",
-        formatLongName: "raw FLAC"
-      });
+      scanner.push(new Uint8Array(), true);
+      return flacProbe(scanner, options);
     },
     id: "flac",
     formatName: "flac",
@@ -387037,12 +387280,9 @@ function flacAst() {
       return concatBytes(encodeFlacPackets(doc));
     },
     probe(bytes, options) {
-      const doc = this.parse(bytes, options);
-      return buildProbeResultFromDoc(doc, bytes.byteLength, options?.filename ?? "input.flac", {
-        ...options,
-        formatName: "flac",
-        formatLongName: "raw FLAC"
-      });
+      const scanner = new FlacFrameScanner();
+      scanner.push(bytes, true);
+      return flacProbe(scanner, options);
     },
     concat(docs, options) {
       return concatMp4(docs, options);
@@ -387269,7 +387509,7 @@ function gifAst() {
           enabled: true,
           width,
           height,
-          codecDescriptions: [{ formatFourCC: "gif ", codecName: "gif", width, height, pixFmt: "rgb8" }],
+          codecDescriptions: [{ formatFourCC: "gif ", codecName: "gif", width, height, pixFmt: "bgra" }],
           samples,
           decodedVideoFrames: frames
         }],
@@ -387299,11 +387539,28 @@ function gifAst() {
     },
     probe(bytes, options) {
       const doc = this.parse(bytes, options);
-      return buildProbeResultFromDoc(doc, bytes.byteLength, options?.filename ?? "input.gif", {
+      const result = buildProbeResultFromDoc(doc, bytes.byteLength, options?.filename ?? "input.gif", {
         ...options,
         formatName: "gif",
         formatLongName: "CompuServe Graphics Interchange Format (GIF)"
       });
+      const track = doc.tracks[0];
+      const stream = result.streams[0];
+      if (track.samples.length > 1) {
+        const averageDelay = Math.floor(track.duration / track.samples.length);
+        const averageDivisor = gcd(track.timescale, averageDelay);
+        let interval = 0;
+        for (let index = 1; index < track.samples.length; index++) {
+          interval = gcd(interval, track.samples[index].dts - track.samples[index - 1].dts);
+        }
+        const nominalDivisor = gcd(track.timescale, interval);
+        return { ...result, streams: [{
+          ...stream,
+          avg_frame_rate: `${track.timescale / averageDivisor}/${averageDelay / averageDivisor}`,
+          r_frame_rate: `${track.timescale / nominalDivisor}/${interval / nominalDivisor}`
+        }] };
+      }
+      return result;
     },
     concat(docs, options) {
       return concatMp4(docs, options);
@@ -388114,9 +388371,9 @@ async function* scanMp4CodecDescriptions(source, range, options = {}) {
 async function* scanMp4Packets(source, options = {}) {
   for await (const record of scanProbeRecords(source, options, "packets")) {
     if (!("sample" in record)) continue;
-    const { sample, track, bytePos } = record;
+    const { sample, track } = record;
     const scale = Math.max(1, track.timescale);
-    yield { codec_type: track.type, stream_index: track.index, pts: sample.pts, pts_time: (sample.pts / scale).toFixed(6), dts: sample.dts, dts_time: (sample.dts / scale).toFixed(6), duration: sample.duration, duration_time: (sample.duration / scale).toFixed(6), size: String(sample.size), pos: String(bytePos), flags: sample.isKeyframe ? "K_" : "__" };
+    yield { codec_type: track.type, stream_index: track.index, pts: sample.pts, pts_time: (sample.pts / scale).toFixed(6), dts: sample.dts, dts_time: (sample.dts / scale).toFixed(6), duration: sample.duration, duration_time: (sample.duration / scale).toFixed(6), size: String(sample.size), pos: String(sample.offset), flags: sample.isKeyframe ? "K__" : "___" };
   }
 }
 async function* scanMp4Frames(source, options = {}) {
@@ -388140,7 +388397,7 @@ async function* scanMp4Frames(source, options = {}) {
       width: track.width,
       height: track.height,
       pix_fmt: track.type === "video" ? track.codec?.pixFmt ?? "yuv420p" : void 0,
-      pict_type: track.type === "video" ? sample.isKeyframe ? "I" : "P" : void 0,
+      pict_type: void 0,
       sample_fmt: probeSampleFormat(track.type, track.codec?.codecName ?? (track.type === "video" ? "h264" : "aac")),
       nb_samples: track.type === "audio" ? sample.duration : void 0,
       channels: track.type === "audio" ? track.codec?.channels ?? 2 : void 0
@@ -388266,11 +388523,16 @@ async function* scanProbeRecords(source, options, mode) {
       }
     }
     let duration = 0, mediaEnd = 0, allPacked = true, count = 0, firstPts = 0;
+    let highestPts = -Infinity, reorderSpan = 0;
     for await (const sample of samples()) {
       if (!count) firstPts = sample.pts;
       count++;
       duration += sample.duration;
       mediaEnd = Math.max(mediaEnd, sample.pts + sample.duration);
+      if (mode === "frames" && type === "video") {
+        highestPts = Math.max(highestPts, sample.pts);
+        reorderSpan = Math.max(reorderSpan, highestPts - sample.pts);
+      }
       if (type === "subtitle" && allPacked) {
         if (sample.size < 2) allPacked = false;
         else allPacked = new BinaryReader(await readMp4SampleRange(source, sample.offset, 2, work)).readU16BE() === sample.size - 2;
@@ -388283,18 +388545,20 @@ async function* scanProbeRecords(source, options, mode) {
       const version = header2.readU8();
       header2.skip(3);
       const count2 = header2.readU32BE(), width2 = version === 1 ? 20 : 12;
-      let total = 0, entries = 0, delay = 0, foundMedia = false;
+      let total = 0, entries = 0, delay = 0, mediaStart = 0, foundMedia = false;
       for (let i = 0; i < count2 && 8 + i * width2 < elst.payloadSize; i++) {
         const row = new BinaryReader(yield { kind: "read", table: elst, offset: elst.payloadOffset + 8 + i * width2, length: Math.min(width2, elst.payloadSize - 8 - i * width2) });
         let segment = version === 1 ? row.readU64BE() : row.readU32BE();
         const mediaTime = version === 1 ? row.readI64BE() : row.readI32BE();
         if (fragmented && segment === 0 && mediaTime >= 0) segment = Math.round(Math.max(0, mediaEnd - mediaTime) * movieTimescale / timescale);
-        if (mediaTime >= 0) foundMedia = true;
-        else if (!foundMedia) delay += segment;
+        if (mediaTime >= 0 && !foundMedia) {
+          mediaStart = mediaTime;
+          foundMedia = true;
+        } else if (!foundMedia) delay += segment;
         total += segment;
         entries++;
       }
-      return entries ? { duration: Math.round(total * timescale / movieTimescale), start: Math.round(delay * timescale / movieTimescale) } : void 0;
+      return entries ? { duration: Math.round(total * timescale / movieTimescale), start: Math.round(delay * timescale / movieTimescale), mediaStart } : void 0;
     }
     const edits = consumeMp4SampleSteps(source, editDuration(), sampleOptions), result = await edits.next();
     if (!result.done) throw new Error("Unexpected MP4 edit sample");
@@ -388307,7 +388571,8 @@ async function* scanProbeRecords(source, options, mode) {
     formatStart = Math.min(formatStart, start);
     formatEnd = Math.max(formatEnd, start + probeDuration / Math.max(1, timescale));
     if (mode === "summary") continue;
-    let bytePos = 0, cursor = 0, previousPts = -Infinity;
+    const timestampOffset = result.value ? result.value.start - result.value.mediaStart : 0;
+    let cursor = 0, previousPts = -Infinity;
     const stats = { totalBytes: 0, count: 0, ticks: 0, firstPts: startPts, hasReorderedSamples: false };
     const packet = (sample) => {
       if (mode === "streams") {
@@ -388317,11 +388582,34 @@ async function* scanProbeRecords(source, options, mode) {
         stats.hasReorderedSamples ||= sample.pts < previousPts;
         previousPts = sample.pts;
       }
-      const record = { sample, track, bytePos };
-      bytePos += sample.size;
-      return record;
+      return { sample, track };
     };
-    for await (const sample of samples()) {
+    async function* frameSamples() {
+      const pending = [];
+      let highest = -Infinity;
+      try {
+        for await (const sample of samples()) {
+          highest = Math.max(highest, sample.pts);
+          const index2 = pending.findIndex((row) => row.pts <= sample.pts);
+          pending.splice(index2 < 0 ? pending.length : index2, 0, sample);
+          budget.allocateMemory(128);
+          while (pending.length && pending[pending.length - 1].pts <= highest - reorderSpan) {
+            const next = pending.pop();
+            budget.releaseMemory(128);
+            yield next;
+          }
+        }
+        while (pending.length) {
+          const next = pending.pop();
+          budget.releaseMemory(128);
+          yield next;
+        }
+      } finally {
+        budget.releaseMemory(pending.length * 128);
+      }
+    }
+    for await (const rawSample of reorderSpan > 0 ? frameSamples() : samples()) {
+      const sample = { ...rawSample, pts: rawSample.pts + timestampOffset, dts: rawSample.dts + timestampOffset };
       if (type !== "subtitle" || !count || allPacked) {
         const row2 = packet(sample);
         if (mode !== "streams") yield row2;
@@ -388329,12 +388617,12 @@ async function* scanProbeRecords(source, options, mode) {
       }
       const start2 = Math.max(cursor, Math.round(sample.pts));
       if (start2 > cursor) {
-        const row2 = packet({ pts: cursor, dts: cursor, duration: start2 - cursor, size: 2, isKeyframe: true });
+        const row2 = packet({ offset: -1, pts: cursor, dts: cursor, duration: start2 - cursor, size: 2, isKeyframe: true });
         if (mode !== "streams") yield row2;
         cursor = start2;
       }
       const duration2 = Math.max(1, Math.round(sample.duration));
-      const row = packet({ pts: cursor, dts: cursor, duration: duration2, size: sample.size + 2, isKeyframe: true });
+      const row = packet({ offset: sample.offset, pts: cursor, dts: cursor, duration: duration2, size: sample.size + 2, isKeyframe: true });
       if (mode !== "streams") yield row;
       cursor += duration2;
     }
@@ -388387,6 +388675,7 @@ export {
   createSyntheticMp4,
   parseStreamingManifest,
   serializeDashDocument,
+  wavPacketFrames,
   probeOggStreamMetadata,
   probeOggFlacSource,
   parseSubtitleDocument,