@poe-platform/safe-bash 0.1.815 → 0.1.816

package/dist/safe-bash/command-chunks/{chunk-NEYITAAO.js → chunk-45DKGZYO.js}

@@ -1,128 +1,3 @@
-// packages/mp4-ast/src/types.ts
-function cloudflareWorkerLimits(overrides = {}) {
-  return {
-    maxInputBytes: 64 * 1024 * 1024,
-    maxOutputBytes: 64 * 1024 * 1024,
-    maxMemoryBytes: 96 * 1024 * 1024,
-    maxFrames: 900,
-    maxPixelsPerFrame: 1920 * 1080,
-    maxDurationSeconds: 3600,
-    maxStreams: 32,
-    maxSamplesPerTrack: 2e5,
-    maxConcatInputs: 128,
-    maxBoxDepth: 32,
-    maxCpuMs: 25e3,
-    ...overrides
-  };
-}
-var MediaLimitExceededError = class extends Error {
-  limitName;
-  limitValue;
-  actualValue;
-  constructor(limitName, limitValue, actualValue, message) {
-    super(
-      message ?? `Resource limit exceeded for ${limitName}: ${actualValue} exceeds maximum allowed ${limitValue}`
-    );
-    this.name = "MediaLimitExceededError";
-    this.limitName = limitName;
-    this.limitValue = limitValue;
-    this.actualValue = actualValue;
-  }
-};
-var MediaBudgetTracker = class {
-  limits;
-  startTimeMs;
-  allocatedBytes = 0;
-  peakAllocatedBytes = 0;
-  decodedFrames = 0;
-  constructor(limits = {}) {
-    this.limits = limits;
-    this.startTimeMs = Date.now();
-  }
-  checkCpu() {
-    if (this.limits.maxCpuMs !== void 0) {
-      const elapsed = Date.now() - this.startTimeMs;
-      if (elapsed > this.limits.maxCpuMs) {
-        throw new MediaLimitExceededError("maxCpuMs", this.limits.maxCpuMs, elapsed);
-      }
-    }
-  }
-  checkInputBytes(bytes) {
-    if (this.limits.maxInputBytes !== void 0 && bytes > this.limits.maxInputBytes) {
-      throw new MediaLimitExceededError("maxInputBytes", this.limits.maxInputBytes, bytes);
-    }
-  }
-  checkOutputBytes(bytes) {
-    if (this.limits.maxOutputBytes !== void 0 && bytes > this.limits.maxOutputBytes) {
-      throw new MediaLimitExceededError("maxOutputBytes", this.limits.maxOutputBytes, bytes);
-    }
-  }
-  allocateMemory(bytes) {
-    this.allocatedBytes += bytes;
-    if (this.allocatedBytes > this.peakAllocatedBytes) {
-      this.peakAllocatedBytes = this.allocatedBytes;
-    }
-    if (this.limits.maxMemoryBytes !== void 0 && this.allocatedBytes > this.limits.maxMemoryBytes) {
-      throw new MediaLimitExceededError(
-        "maxMemoryBytes",
-        this.limits.maxMemoryBytes,
-        this.allocatedBytes
-      );
-    }
-  }
-  releaseMemory(bytes) {
-    this.allocatedBytes = Math.max(0, this.allocatedBytes - bytes);
-  }
-  recordFrame(width, height) {
-    const pixels = width * height;
-    if (this.limits.maxPixelsPerFrame !== void 0 && pixels > this.limits.maxPixelsPerFrame) {
-      throw new MediaLimitExceededError("maxPixelsPerFrame", this.limits.maxPixelsPerFrame, pixels);
-    }
-    this.decodedFrames += 1;
-    if (this.limits.maxFrames !== void 0 && this.decodedFrames > this.limits.maxFrames) {
-      throw new MediaLimitExceededError("maxFrames", this.limits.maxFrames, this.decodedFrames);
-    }
-    this.checkCpu();
-  }
-  checkStreams(count) {
-    if (this.limits.maxStreams !== void 0 && count > this.limits.maxStreams) {
-      throw new MediaLimitExceededError("maxStreams", this.limits.maxStreams, count);
-    }
-  }
-  checkSamples(count) {
-    if (this.limits.maxSamplesPerTrack !== void 0 && count > this.limits.maxSamplesPerTrack) {
-      throw new MediaLimitExceededError("maxSamplesPerTrack", this.limits.maxSamplesPerTrack, count);
-    }
-  }
-  checkDuration(seconds) {
-    if (this.limits.maxDurationSeconds !== void 0 && seconds > this.limits.maxDurationSeconds) {
-      throw new MediaLimitExceededError(
-        "maxDurationSeconds",
-        this.limits.maxDurationSeconds,
-        seconds
-      );
-    }
-  }
-  checkConcatInputs(count) {
-    if (this.limits.maxConcatInputs !== void 0 && count > this.limits.maxConcatInputs) {
-      throw new MediaLimitExceededError("maxConcatInputs", this.limits.maxConcatInputs, count);
-    }
-  }
-  checkBoxDepth(depth) {
-    if (this.limits.maxBoxDepth !== void 0 && depth > this.limits.maxBoxDepth) {
-      throw new MediaLimitExceededError("maxBoxDepth", this.limits.maxBoxDepth, depth);
-    }
-  }
-  getStats() {
-    return {
-      currentMemoryBytes: this.allocatedBytes,
-      peakMemoryBytes: this.peakAllocatedBytes,
-      decodedFrames: this.decodedFrames,
-      elapsedMs: Date.now() - this.startTimeMs
-    };
-  }
-};
-
 // packages/mp4-ast/src/binary.ts
 var TEXT_DECODER = new TextDecoder("utf-8", { fatal: false });
 var TEXT_ENCODER = new TextEncoder();
@@ -736,6 +611,131 @@ function yuv420pToRgba(yPlane, uPlane, vPlane, width, height) {
   return rgba;
 }
 
+// packages/mp4-ast/src/types.ts
+function cloudflareWorkerLimits(overrides = {}) {
+  return {
+    maxInputBytes: 64 * 1024 * 1024,
+    maxOutputBytes: 64 * 1024 * 1024,
+    maxMemoryBytes: 96 * 1024 * 1024,
+    maxFrames: 900,
+    maxPixelsPerFrame: 1920 * 1080,
+    maxDurationSeconds: 3600,
+    maxStreams: 32,
+    maxSamplesPerTrack: 2e5,
+    maxConcatInputs: 128,
+    maxBoxDepth: 32,
+    maxCpuMs: 25e3,
+    ...overrides
+  };
+}
+var MediaLimitExceededError = class extends Error {
+  limitName;
+  limitValue;
+  actualValue;
+  constructor(limitName, limitValue, actualValue, message) {
+    super(
+      message ?? `Resource limit exceeded for ${limitName}: ${actualValue} exceeds maximum allowed ${limitValue}`
+    );
+    this.name = "MediaLimitExceededError";
+    this.limitName = limitName;
+    this.limitValue = limitValue;
+    this.actualValue = actualValue;
+  }
+};
+var MediaBudgetTracker = class {
+  limits;
+  startTimeMs;
+  allocatedBytes = 0;
+  peakAllocatedBytes = 0;
+  decodedFrames = 0;
+  constructor(limits = {}) {
+    this.limits = limits;
+    this.startTimeMs = Date.now();
+  }
+  checkCpu() {
+    if (this.limits.maxCpuMs !== void 0) {
+      const elapsed = Date.now() - this.startTimeMs;
+      if (elapsed > this.limits.maxCpuMs) {
+        throw new MediaLimitExceededError("maxCpuMs", this.limits.maxCpuMs, elapsed);
+      }
+    }
+  }
+  checkInputBytes(bytes) {
+    if (this.limits.maxInputBytes !== void 0 && bytes > this.limits.maxInputBytes) {
+      throw new MediaLimitExceededError("maxInputBytes", this.limits.maxInputBytes, bytes);
+    }
+  }
+  checkOutputBytes(bytes) {
+    if (this.limits.maxOutputBytes !== void 0 && bytes > this.limits.maxOutputBytes) {
+      throw new MediaLimitExceededError("maxOutputBytes", this.limits.maxOutputBytes, bytes);
+    }
+  }
+  allocateMemory(bytes) {
+    this.allocatedBytes += bytes;
+    if (this.allocatedBytes > this.peakAllocatedBytes) {
+      this.peakAllocatedBytes = this.allocatedBytes;
+    }
+    if (this.limits.maxMemoryBytes !== void 0 && this.allocatedBytes > this.limits.maxMemoryBytes) {
+      throw new MediaLimitExceededError(
+        "maxMemoryBytes",
+        this.limits.maxMemoryBytes,
+        this.allocatedBytes
+      );
+    }
+  }
+  releaseMemory(bytes) {
+    this.allocatedBytes = Math.max(0, this.allocatedBytes - bytes);
+  }
+  recordFrame(width, height) {
+    const pixels = width * height;
+    if (this.limits.maxPixelsPerFrame !== void 0 && pixels > this.limits.maxPixelsPerFrame) {
+      throw new MediaLimitExceededError("maxPixelsPerFrame", this.limits.maxPixelsPerFrame, pixels);
+    }
+    this.decodedFrames += 1;
+    if (this.limits.maxFrames !== void 0 && this.decodedFrames > this.limits.maxFrames) {
+      throw new MediaLimitExceededError("maxFrames", this.limits.maxFrames, this.decodedFrames);
+    }
+    this.checkCpu();
+  }
+  checkStreams(count) {
+    if (this.limits.maxStreams !== void 0 && count > this.limits.maxStreams) {
+      throw new MediaLimitExceededError("maxStreams", this.limits.maxStreams, count);
+    }
+  }
+  checkSamples(count) {
+    if (this.limits.maxSamplesPerTrack !== void 0 && count > this.limits.maxSamplesPerTrack) {
+      throw new MediaLimitExceededError("maxSamplesPerTrack", this.limits.maxSamplesPerTrack, count);
+    }
+  }
+  checkDuration(seconds) {
+    if (this.limits.maxDurationSeconds !== void 0 && seconds > this.limits.maxDurationSeconds) {
+      throw new MediaLimitExceededError(
+        "maxDurationSeconds",
+        this.limits.maxDurationSeconds,
+        seconds
+      );
+    }
+  }
+  checkConcatInputs(count) {
+    if (this.limits.maxConcatInputs !== void 0 && count > this.limits.maxConcatInputs) {
+      throw new MediaLimitExceededError("maxConcatInputs", this.limits.maxConcatInputs, count);
+    }
+  }
+  checkBoxDepth(depth) {
+    if (this.limits.maxBoxDepth !== void 0 && depth > this.limits.maxBoxDepth) {
+      throw new MediaLimitExceededError("maxBoxDepth", this.limits.maxBoxDepth, depth);
+    }
+  }
+  getStats() {
+    return {
+      currentMemoryBytes: this.allocatedBytes,
+      peakMemoryBytes: this.peakAllocatedBytes,
+      decodedFrames: this.decodedFrames,
+      elapsedMs: Date.now() - this.startTimeMs
+    };
+  }
+};
+
 // packages/media-codecs/vendor/runtime.js
 function Module(moduleArg = {}) {
   var moduleRtn;
@@ -332290,46 +332290,46 @@ function parseVpcC(payload) {
     rawBytes: payload
   };
 }
-function parseEsds(payload) {
-  const reader = new BinaryReader(payload);
-  if (reader.remaining >= 4) reader.skip(4);
-  let objectTypeIndication = 64;
-  let maxBitrate = 128e3;
-  let avgBitrate = 128e3;
+function* esdsSteps(table, retainDecoderBytes = false) {
+  let offset = table.payloadSize >= 4 ? 4 : 0;
+  const skip = (length) => {
+    offset = Math.min(table.payloadSize, offset + length);
+  };
+  function* read(length) {
+    const size = Math.min(length, table.payloadSize - offset);
+    const bytes = size ? yield { kind: "read", table, offset: table.payloadOffset + offset, length: size } : new Uint8Array();
+    offset += size;
+    return new BinaryReader(bytes);
+  }
+  let objectTypeIndication = 64, maxBitrate = 128e3, avgBitrate = 128e3;
   let decoderSpecificInfo = new Uint8Array([18, 16]);
-  function readDescrLength() {
-    let len = 0;
-    for (let i = 0; i < 4 && !reader.eof; i++) {
-      const b = reader.readU8();
-      len = len << 7 | b & 127;
-      if ((b & 128) === 0) break;
+  while (offset < table.payloadSize) {
+    const tag = (yield* read(1)).readU8();
+    let length = 0;
+    for (let i = 0; i < 4 && offset < table.payloadSize; i++) {
+      const byte = (yield* read(1)).readU8();
+      length = length << 7 | byte & 127;
+      if (!(byte & 128)) break;
     }
-    return len;
-  }
-  while (!reader.eof) {
-    const tag = reader.readU8();
-    const len = readDescrLength();
     if (tag === 3) {
-      reader.skip(2);
-      const flags = reader.readU8();
-      if (flags & 128) reader.skip(2);
+      skip(2);
+      const flags = (yield* read(1)).readU8();
+      if (flags & 128) skip(2);
       if (flags & 64) {
-        const urlLen = reader.readU8();
-        reader.skip(urlLen);
+        const size = (yield* read(1)).readU8();
+        skip(size);
       }
-      if (flags & 32) reader.skip(2);
+      if (flags & 32) skip(2);
     } else if (tag === 4) {
-      objectTypeIndication = reader.readU8();
-      reader.skip(1);
-      reader.skip(3);
-      maxBitrate = reader.readU32BE();
-      avgBitrate = reader.readU32BE();
+      const config = yield* read(13);
+      objectTypeIndication = config.readU8();
+      config.skip(4);
+      maxBitrate = config.readU32BE();
+      avgBitrate = config.readU32BE();
     } else if (tag === 5) {
-      decoderSpecificInfo = reader.readSlice(len);
+      decoderSpecificInfo = (yield* read(retainDecoderBytes ? length : Math.min(length, 6))).bytes;
       break;
-    } else {
-      reader.skip(len);
-    }
+    } else skip(length);
   }
   const asc = parseAudioSpecificConfig(decoderSpecificInfo);
   return {
@@ -332339,10 +332339,19 @@ function parseEsds(payload) {
     channelCount: asc.channelCount,
     maxBitrate,
     avgBitrate,
-    decoderSpecificInfo,
-    rawEsdsBytes: payload
+    decoderSpecificInfo
   };
 }
+function parseEsds(payload) {
+  const steps = esdsSteps({ payloadOffset: 0, payloadSize: payload.length }, true);
+  let next = steps.next();
+  while (!next.done) {
+    const step = next.value;
+    if (step.kind !== "read") throw new Error("Unexpected ES descriptor step");
+    next = steps.next(payload.subarray(step.offset, step.offset + step.length));
+  }
+  return { ...next.value, rawEsdsBytes: payload };
+}
 function parseAudioSpecificConfig(asc) {
   if (asc.byteLength < 2) {
     return { audioObjectType: 2, sampleRate: 44100, channelCount: 2 };
@@ -332830,6 +332839,135 @@ function* decodeH264Samples(samples, descriptions, width, height, timescale) {
   if (decoded !== samples.length) throw new Error("H.264 stream did not decode every picture");
 }
 
+// packages/mp4-ast/src/mp4-codec-metadata.ts
+function sampleEntryHeader(formatFourCC, body) {
+  const metadata = {
+    formatFourCC,
+    codecName: formatFourCC.trim().toLowerCase(),
+    codecTagString: formatFourCC,
+    profile: void 0,
+    level: void 0,
+    width: void 0,
+    height: void 0,
+    pixFmt: void 0,
+    sarWidth: 1,
+    sarHeight: 1,
+    sampleRate: void 0,
+    channels: void 0,
+    bitsPerSample: void 0
+  };
+  const state = { metadata }, reader = new BinaryReader(body);
+  if (["avc1", "avc3", "hvc1", "hev1", "av01", "vp08", "vp09", "mp4v", "jpeg", "mjpa", "png ", "s263"].includes(formatFourCC)) {
+    state.kind = "video";
+    if (body.length >= 78) {
+      reader.skip(24);
+      metadata.width = reader.readU16BE();
+      metadata.height = reader.readU16BE();
+      state.childOffset = 78;
+    }
+  } else if (["mp4a", "Opus", "fLaC", "alac", "ac-3", "ec-3", "sowt", "twos", "lpcm", ".mp3", "ulaw", "alaw"].includes(formatFourCC)) {
+    state.kind = "audio";
+    if (body.length >= 28) {
+      reader.skip(8);
+      const version = reader.readU16BE();
+      reader.skip(6);
+      metadata.channels = reader.readU16BE();
+      metadata.bitsPerSample = reader.readU16BE();
+      reader.skip(4);
+      metadata.sampleRate = Math.round(reader.readU32BE() / 65536);
+      state.childOffset = 28 + (version === 1 ? 16 : version === 2 ? 36 : 0);
+    }
+  }
+  return state;
+}
+function applyCodecMetadata(state, child) {
+  const metadata = state.metadata;
+  if (state.kind === "video") {
+    if (child.type === "avcC") {
+      metadata.codecName = "h264";
+      metadata.level = child.levelIdc;
+      if (child.sps) {
+        const sps = parseH264Sps(child.sps);
+        metadata.profile = sps.profileName;
+        metadata.width = sps.width || metadata.width;
+        metadata.height = sps.height || metadata.height;
+        metadata.pixFmt = sps.pixFmt;
+        metadata.sarWidth = sps.sarWidth;
+        metadata.sarHeight = sps.sarHeight;
+      }
+    } else if (child.type === "hvcC") {
+      metadata.codecName = "hevc";
+      metadata.level = child.generalLevelIdc;
+      metadata.profile = child.generalProfileIdc === 2 ? "Main 10" : "Main";
+      metadata.pixFmt = child.bitDepthLumaMinus8 > 0 ? "yuv420p10le" : "yuv420p";
+    } else if (child.type === "av1C") {
+      metadata.codecName = "av1";
+      metadata.profile = child.seqProfile === 0 ? "Main" : child.seqProfile === 1 ? "High" : "Professional";
+      metadata.level = child.seqLevelIdx0;
+      metadata.pixFmt = child.highBitdepth ? "yuv420p10le" : "yuv420p";
+    } else if (child.type === "vpcC") {
+      metadata.codecName = metadata.formatFourCC === "vp08" ? "vp8" : "vp9";
+      metadata.profile = `Profile ${child.profile}`;
+      metadata.level = child.level;
+      metadata.pixFmt = "yuv420p";
+    } else if (child.type === "pasp") {
+      metadata.sarWidth = child.sarWidth || 1;
+      metadata.sarHeight = child.sarHeight || 1;
+    }
+  } else if (state.kind === "audio") {
+    if (child.type === "esds" || child.type === "wave-esds") {
+      if (child.config.sampleRate > 0) metadata.sampleRate = child.config.sampleRate;
+      if (child.config.channelCount > 0) metadata.channels = child.config.channelCount;
+      if (child.type === "esds") {
+        if (child.config.objectTypeIndication === 107 || child.config.objectTypeIndication === 105) metadata.codecName = "mp3";
+        else {
+          metadata.codecName = "aac";
+          metadata.profile = child.config.audioObjectType === 5 ? "HE-AAC" : "LC";
+        }
+      }
+    } else if (child.type === "dOps") {
+      metadata.codecName = "opus";
+      metadata.sampleRate = child.inputSampleRate || 48e3;
+      metadata.channels = child.outputChannelCount || metadata.channels;
+    }
+  }
+}
+function finishCodecMetadata(state) {
+  const metadata = state.metadata, format = metadata.formatFourCC;
+  if (state.kind === "video") {
+    const aliases = { avc1: "h264", avc3: "h264", hvc1: "hevc", hev1: "hevc", av01: "av1", vp08: "vp8", vp09: "vp9", jpeg: "mjpeg", mjpa: "mjpeg", mp4v: "mpeg4", "png ": "png" };
+    metadata.codecName = aliases[format] ?? metadata.codecName;
+    metadata.pixFmt ??= "yuv420p";
+  } else if (state.kind === "audio") {
+    if (format === "mp4a" && metadata.codecName === "mp4a") {
+      metadata.codecName = "aac";
+      metadata.profile ??= "LC";
+    } else {
+      const aliases = { Opus: "opus", fLaC: "flac", alac: "alac", "ac-3": "ac3", "ec-3": "eac3", sowt: "pcm_s16le", twos: "pcm_s16be", lpcm: "pcm_s16le", ".mp3": "mp3" };
+      metadata.codecName = aliases[format] ?? metadata.codecName;
+    }
+  } else if (format === "tx3g" || format === "text") metadata.codecName = "mov_text";
+  else if (format === "wvtt") metadata.codecName = "webvtt";
+  else if (format === "stpp") metadata.codecName = "ttml";
+  return metadata;
+}
+function probeSampleFormat(type, codecName) {
+  if (type !== "audio") return void 0;
+  return {
+    pcm_u8: "u8",
+    pcm_s16le: "s16",
+    pcm_s16be: "s16",
+    pcm_s24le: "s32",
+    pcm_s24be: "s32",
+    pcm_s32le: "s32",
+    pcm_s32be: "s32",
+    pcm_f32le: "flt",
+    pcm_f32be: "flt",
+    pcm_f64le: "dbl",
+    pcm_f64be: "dbl"
+  }[codecName] ?? "fltp";
+}
+
 // packages/mp4-ast/src/mp4-box-layout.ts
 var containers = /* @__PURE__ */ new Set([
   "moov",
@@ -332873,6 +333011,65 @@ function mp4BoxChildrenOffset(type, payloadSize, metaChildType) {
   return metaChildType === "hdlr" || metaChildType === "ilst" || metaChildType === "keys" || metaChildType === "free" ? 4 : 0;
 }
 
+// packages/mp4-ast/src/mp4-source.ts
+async function* scanMp4Boxes(source, options = {}) {
+  options.signal?.throwIfAborted();
+  if (!Number.isSafeInteger(source.size) || source.size < 0) throw new RangeError("Invalid MP4 source size");
+  let offset = options.offset ?? 0;
+  const length = options.length ?? source.size - offset, depth = options.depth ?? 0;
+  if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset > source.size || length > source.size - offset)
+    throw new RangeError("Invalid MP4 box range");
+  if (!Number.isSafeInteger(depth) || depth < 0) throw new RangeError("Invalid MP4 box depth");
+  options.budget?.checkBoxDepth(depth);
+  const end = offset + length;
+  const read = async (at, size) => {
+    const bytes = new Uint8Array(size);
+    for (let used = 0; used < size; ) {
+      options.signal?.throwIfAborted();
+      const chunk = await source.read(at + used, size - used);
+      options.signal?.throwIfAborted();
+      if (!chunk.length) throw new Error("Truncated MP4 source");
+      if (chunk.length > size - used) throw new Error("MP4 source returned more bytes than requested");
+      bytes.set(chunk, used);
+      used += chunk.length;
+    }
+    await options.checkpoint?.();
+    options.signal?.throwIfAborted();
+    return bytes;
+  };
+  while (end - offset >= 8) {
+    options.signal?.throwIfAborted();
+    options.budget?.checkCpu();
+    let prefix = await read(offset, 8);
+    if (new DataView(prefix.buffer).getUint32(0) === 1) {
+      if (end - offset < 16) break;
+      const extended = new Uint8Array(16);
+      extended.set(prefix);
+      extended.set(await read(offset + 8, 8), 8);
+      prefix = extended;
+    }
+    const layout = mp4BoxLayout(prefix, end - offset);
+    if (!layout) break;
+    const { type, size, headerSize, uuidOffset } = layout;
+    const uuid = uuidOffset === void 0 ? void 0 : await read(offset + uuidOffset, 16);
+    const payloadOffset = offset + headerSize, payloadSize = size - headerSize;
+    const metaType = type === "meta" && payloadSize >= 12 ? decodeFourCC(await read(payloadOffset + 8, 4), 0) : void 0;
+    const childOffset = mp4BoxChildrenOffset(type, payloadSize, metaType);
+    yield {
+      type,
+      offset,
+      size,
+      headerSize,
+      payloadOffset,
+      payloadSize,
+      ...uuid ? { uuid } : {},
+      ...childOffset === void 0 ? {} : { children: { offset: payloadOffset + childOffset, length: payloadSize - childOffset, depth: depth + 1 } }
+    };
+    offset += size;
+  }
+  options.signal?.throwIfAborted();
+}
+
 // packages/mp4-ast/src/mp4-sample-source.ts
 function* mp4SampleTableSteps(size, tables, options = {}) {
   function* read(table, offset, length) {
@@ -332949,6 +333146,90 @@ function* mp4SampleTableSteps(size, tables, options = {}) {
     }
   }
 }
+async function* scanMp4SampleTable(source, tables, options = {}) {
+  options.signal?.throwIfAborted();
+  if (!Number.isSafeInteger(source.size) || source.size < 0) throw new RangeError("Invalid MP4 source size");
+  for (const name of ["stts", "ctts", "stsc", "stsz", "stco", "co64", "stss"]) {
+    const table = tables[name];
+    if (table && (!Number.isSafeInteger(table.payloadOffset) || !Number.isSafeInteger(table.payloadSize) || table.payloadOffset < 0 || table.payloadSize < 0 || table.payloadOffset > source.size || table.payloadSize > source.size - table.payloadOffset)) throw new RangeError("Invalid MP4 sample table range");
+  }
+  yield* consumeMp4SampleSteps(source, mp4SampleTableSteps(source.size, tables, options), options);
+}
+async function readMp4SampleRange(source, offset, length, options) {
+  const bytes = new Uint8Array(length);
+  for (let used = 0; used < length; ) {
+    options.signal?.throwIfAborted();
+    const chunk = await source.read(offset + used, length - used);
+    options.signal?.throwIfAborted();
+    if (!chunk.length) throw new Error("Truncated MP4 sample source");
+    if (chunk.length > length - used) throw new Error("MP4 sample source returned more bytes than requested");
+    bytes.set(chunk, used);
+    used += chunk.length;
+  }
+  await options.checkpoint?.();
+  options.signal?.throwIfAborted();
+  return bytes;
+}
+async function* consumeMp4SampleSteps(source, steps, options) {
+  const cache = /* @__PURE__ */ new Map();
+  let answer, work = 0, retainedBytes = 0;
+  try {
+    for (; ; ) {
+      options.signal?.throwIfAborted();
+      if (++work % 256 === 0) {
+        options.budget?.checkCpu();
+        await options.checkpoint?.();
+        options.signal?.throwIfAborted();
+      }
+      const next = steps.next(answer);
+      if (next.done) return next.value;
+      const step = next.value;
+      answer = void 0;
+      if (step.kind === "sample") {
+        yield step.sample;
+        continue;
+      }
+      if (step.kind === "sync-add" || step.kind === "sync-has") {
+        if (!options.syncSamples) throw new Error("MP4 sync sample index is required");
+        if (step.kind === "sync-add") await options.syncSamples.add(step.sample);
+        else answer = await options.syncSamples.has(step.sample);
+        options.signal?.throwIfAborted();
+        continue;
+      }
+      if (!step.table) {
+        answer = await readMp4SampleRange(source, step.offset, step.length, options);
+        continue;
+      }
+      const bytes = new Uint8Array(step.length);
+      let used = 0;
+      while (used < bytes.length) {
+        const relative = step.offset + used - step.table.payloadOffset, page2 = Math.floor(relative / 16384) * 16384;
+        let cached = cache.get(step.table);
+        if (!cached || cached.offset !== page2) {
+          if (cached) {
+            retainedBytes -= cached.bytes.length;
+            options.budget?.releaseMemory(cached.bytes.length);
+            cache.delete(step.table);
+            cached = void 0;
+          }
+          const length = Math.min(16384, step.table.payloadSize - page2);
+          retainedBytes += length;
+          options.budget?.allocateMemory(length);
+          cached = { offset: page2, bytes: await readMp4SampleRange(source, step.table.payloadOffset + page2, length, options) };
+          cache.set(step.table, cached);
+        }
+        const from = relative - page2, take = Math.min(bytes.length - used, cached.bytes.length - from);
+        bytes.set(cached.bytes.subarray(from, from + take), used);
+        used += take;
+      }
+      answer = bytes;
+    }
+  } finally {
+    cache.clear();
+    options.budget?.releaseMemory(retainedBytes);
+    steps.return(void 0);
+  }
+}
 
 // packages/mp4-ast/src/mp4-fragment-source.ts
 function mp4FragmentHeader(bytes, options) {
@@ -332998,6 +333279,22 @@ function* mp4FragmentRunSteps(size, table, header, state, options) {
   }
   return { dts, sampleCount: state.sampleCount + count };
 }
+async function* scanMp4Fragment(source, range, options) {
+  let state = options.state ?? { dts: 0, sampleCount: 0 };
+  let tfhd, tfdt;
+  for await (const box of scanMp4Boxes(source, { ...range, ...options })) {
+    if (box.type === "tfhd" && !tfhd) tfhd = box;
+    if (box.type === "tfdt" && !tfdt) tfdt = box;
+  }
+  if (!tfhd) return state;
+  const header = mp4FragmentHeader(await readMp4SampleRange(source, tfhd.payloadOffset, Math.min(32, tfhd.payloadSize), options), options);
+  if (!header) return state;
+  if (tfdt) state = { ...state, dts: mp4FragmentTime(await readMp4SampleRange(source, tfdt.payloadOffset, Math.min(12, tfdt.payloadSize), options), state.dts) };
+  for await (const box of scanMp4Boxes(source, { ...range, ...options })) {
+    if (box.type === "trun") state = yield* consumeMp4SampleSteps(source, mp4FragmentRunSteps(source.size, box, header, state, options), options);
+  }
+  return state;
+}
 
 // packages/mp4-ast/src/work.ts
 function drainWork(work) {
@@ -333050,174 +333347,51 @@ function parseStsdBox(payload) {
   const reader = new BinaryReader(payload);
   if (reader.remaining < 8) return [];
   reader.skip(4);
-  const entryCount = reader.readU32BE();
-  const descriptions = [];
+  const entryCount = reader.readU32BE(), descriptions = [];
   for (let i = 0; i < entryCount && reader.remaining >= 8; i++) {
-    const entryStart = reader.offset;
-    const entrySize = reader.readU32BE();
-    const formatFourCC = reader.readFourCC();
-    if (entrySize < 8 || entryStart + entrySize > payload.byteLength) break;
-    const rawEntryBytes = payload.subarray(entryStart, entryStart + entrySize);
-    const body = payload.subarray(entryStart + 8, entryStart + entrySize);
-    let codecName = formatFourCC.trim().toLowerCase();
-    let profile;
-    let level;
-    let width;
-    let height;
-    let pixFmt;
-    let sarWidth = 1;
-    let sarHeight = 1;
-    let sampleRate;
-    let channels;
-    let bitsPerSample;
-    let avcC;
-    let hvcC;
-    let av1C;
-    let vpcC;
-    let esds;
-    let dOps;
-    if (formatFourCC === "avc1" || formatFourCC === "avc3" || formatFourCC === "hvc1" || formatFourCC === "hev1" || formatFourCC === "av01" || formatFourCC === "vp08" || formatFourCC === "vp09" || formatFourCC === "mp4v" || formatFourCC === "jpeg" || formatFourCC === "mjpa" || formatFourCC === "png " || formatFourCC === "s263") {
-      if (body.byteLength >= 78) {
-        const vReader = new BinaryReader(body);
-        vReader.skip(6 + 2 + 16);
-        width = vReader.readU16BE();
-        height = vReader.readU16BE();
-        vReader.skip(4 + 4 + 4 + 2 + 32 + 2 + 2);
-        const childBoxes = parseMp4Boxes(body.subarray(78));
-        for (const child of childBoxes) {
+    const start = reader.offset, size = reader.readU32BE(), format = reader.readFourCC();
+    if (size < 8 || start + size > payload.length) break;
+    const body = payload.subarray(start + 8, start + size), state = sampleEntryHeader(format, body);
+    let avcC, hvcC, av1C, vpcC, esds, dOps;
+    if (state.childOffset !== void 0 && state.childOffset < body.length) {
+      for (const child of parseMp4Boxes(body.subarray(state.childOffset))) {
+        if (state.kind === "video") {
           if (child.type === "avcC") {
             avcC = parseAvcC(child.payload);
-            codecName = "h264";
-            level = avcC.levelIdc;
-            if (avcC.sps[0]) {
-              const spsInfo = parseH264Sps(avcC.sps[0]);
-              profile = spsInfo.profileName;
-              width = spsInfo.width || width;
-              height = spsInfo.height || height;
-              pixFmt = spsInfo.pixFmt;
-              sarWidth = spsInfo.sarWidth;
-              sarHeight = spsInfo.sarHeight;
-            }
+            applyCodecMetadata(state, { type: "avcC", levelIdc: avcC.levelIdc, sps: avcC.sps[0] });
           } else if (child.type === "hvcC") {
             hvcC = parseHvcC(child.payload);
-            codecName = "hevc";
-            level = hvcC.generalLevelIdc;
-            profile = hvcC.generalProfileIdc === 2 ? "Main 10" : "Main";
-            pixFmt = hvcC.bitDepthLumaMinus8 > 0 ? "yuv420p10le" : "yuv420p";
+            applyCodecMetadata(state, { ...hvcC, type: "hvcC" });
           } else if (child.type === "av1C") {
             av1C = parseAv1C(child.payload);
-            codecName = "av1";
-            profile = av1C.seqProfile === 0 ? "Main" : av1C.seqProfile === 1 ? "High" : "Professional";
-            level = av1C.seqLevelIdx0;
-            pixFmt = av1C.highBitdepth ? "yuv420p10le" : "yuv420p";
+            applyCodecMetadata(state, { ...av1C, type: "av1C" });
           } else if (child.type === "vpcC") {
             vpcC = parseVpcC(child.payload);
-            codecName = formatFourCC === "vp08" ? "vp8" : "vp9";
-            profile = `Profile ${vpcC.profile}`;
-            level = vpcC.level;
-            pixFmt = "yuv420p";
-          } else if (child.type === "esds") {
+            applyCodecMetadata(state, { ...vpcC, type: "vpcC" });
+          } else if (child.type === "esds") esds = parseEsds(child.payload);
+          else if (child.type === "pasp" && child.payload.length >= 8) {
+            const aspect = new BinaryReader(child.payload);
+            applyCodecMetadata(state, { type: "pasp", sarWidth: aspect.readU32BE(), sarHeight: aspect.readU32BE() });
+          }
+        } else if (state.kind === "audio") {
+          if (child.type === "esds") {
             esds = parseEsds(child.payload);
-          } else if (child.type === "pasp" && child.payload.byteLength >= 8) {
-            const pReader = new BinaryReader(child.payload);
-            sarWidth = pReader.readU32BE() || 1;
-            sarHeight = pReader.readU32BE() || 1;
-          }
-        }
-      }
-      if (formatFourCC === "avc1" || formatFourCC === "avc3") codecName = "h264";
-      else if (formatFourCC === "hvc1" || formatFourCC === "hev1") codecName = "hevc";
-      else if (formatFourCC === "av01") codecName = "av1";
-      else if (formatFourCC === "vp08") codecName = "vp8";
-      else if (formatFourCC === "vp09") codecName = "vp9";
-      else if (formatFourCC === "jpeg" || formatFourCC === "mjpa") codecName = "mjpeg";
-      else if (formatFourCC === "mp4v") codecName = "mpeg4";
-      else if (formatFourCC === "png ") codecName = "png";
-      pixFmt = pixFmt ?? "yuv420p";
-    } else if (formatFourCC === "mp4a" || formatFourCC === "Opus" || formatFourCC === "fLaC" || formatFourCC === "alac" || formatFourCC === "ac-3" || formatFourCC === "ec-3" || formatFourCC === "sowt" || formatFourCC === "twos" || formatFourCC === "lpcm" || formatFourCC === ".mp3" || formatFourCC === "ulaw" || formatFourCC === "alaw") {
-      if (body.byteLength >= 28) {
-        const aReader = new BinaryReader(body);
-        aReader.skip(6 + 2);
-        const qtVersion = aReader.readU16BE();
-        aReader.skip(6);
-        channels = aReader.readU16BE();
-        bitsPerSample = aReader.readU16BE();
-        aReader.skip(4);
-        sampleRate = Math.round(aReader.readU32BE() / 65536);
-        let childOffset = 28;
-        if (qtVersion === 1) childOffset += 16;
-        else if (qtVersion === 2) childOffset += 36;
-        if (childOffset < body.byteLength) {
-          const childBoxes = parseMp4Boxes(body.subarray(childOffset));
-          for (const child of childBoxes) {
-            if (child.type === "esds") {
-              esds = parseEsds(child.payload);
-              if (esds.sampleRate > 0) sampleRate = esds.sampleRate;
-              if (esds.channelCount > 0) channels = esds.channelCount;
-              if (esds.objectTypeIndication === 107 || esds.objectTypeIndication === 105) {
-                codecName = "mp3";
-              } else {
-                codecName = "aac";
-                profile = esds.audioObjectType === 5 ? "HE-AAC" : "LC";
-              }
-            } else if (child.type === "dOps") {
-              dOps = parseDOps(child.payload);
-              codecName = "opus";
-              sampleRate = dOps.inputSampleRate || 48e3;
-              channels = dOps.outputChannelCount || channels;
-            } else if (child.type === "wave" && child.children) {
-              const waveEsds = findBox(child.children, "esds");
-              if (waveEsds) {
-                esds = parseEsds(waveEsds.payload);
-                if (esds.sampleRate > 0) sampleRate = esds.sampleRate;
-                if (esds.channelCount > 0) channels = esds.channelCount;
-              }
+            applyCodecMetadata(state, { type: "esds", config: esds });
+          } else if (child.type === "dOps") {
+            dOps = parseDOps(child.payload);
+            applyCodecMetadata(state, { ...dOps, type: "dOps" });
+          } else if (child.type === "wave" && child.children) {
+            const nested = findBox(child.children, "esds");
+            if (nested) {
+              esds = parseEsds(nested.payload);
+              applyCodecMetadata(state, { type: "wave-esds", config: esds });
             }
           }
         }
       }
-      if (formatFourCC === "mp4a" && codecName === "mp4a") {
-        codecName = "aac";
-        profile = profile ?? "LC";
-      } else if (formatFourCC === "Opus") codecName = "opus";
-      else if (formatFourCC === "fLaC") codecName = "flac";
-      else if (formatFourCC === "alac") codecName = "alac";
-      else if (formatFourCC === "ac-3") codecName = "ac3";
-      else if (formatFourCC === "ec-3") codecName = "eac3";
-      else if (formatFourCC === "sowt") codecName = "pcm_s16le";
-      else if (formatFourCC === "twos") codecName = "pcm_s16be";
-      else if (formatFourCC === "lpcm") codecName = "pcm_s16le";
-      else if (formatFourCC === ".mp3") codecName = "mp3";
-    } else if (formatFourCC === "tx3g" || formatFourCC === "text") {
-      codecName = "mov_text";
-    } else if (formatFourCC === "wvtt") {
-      codecName = "webvtt";
-    } else if (formatFourCC === "stpp") {
-      codecName = "ttml";
     }
-    descriptions.push({
-      formatFourCC,
-      codecName,
-      codecTagString: formatFourCC,
-      profile,
-      level,
-      width,
-      height,
-      pixFmt,
-      sarWidth,
-      sarHeight,
-      sampleRate,
-      channels,
-      bitsPerSample,
-      avcC,
-      hvcC,
-      av1C,
-      vpcC,
-      esds,
-      dOps,
-      rawStsdEntryBytes: rawEntryBytes
-    });
-    reader.seek(entryStart + entrySize);
+    descriptions.push({ ...finishCodecMetadata(state), avcC, hvcC, av1C, vpcC, esds, dOps, rawStsdEntryBytes: payload.subarray(start, start + size) });
+    reader.seek(start + size);
   }
   return descriptions;
 }
@@ -334702,19 +334876,7 @@ function buildProbeResultFromDoc(doc, byteLength, filename = "input.mp4", option
     const codecLongName = CODEC_LONG_NAMES[codecName] ?? codecName;
     const rawTag = desc?.formatFourCC ?? (track.type === "video" ? "avc1" : "mp4a");
     const tagFourCC = Array.from(rawTag).map((c) => c.charCodeAt(0) < 32 ? `[${c.charCodeAt(0)}]` : c).join("");
-    const sampleFormat = track.type !== "audio" ? void 0 : {
-      pcm_u8: "u8",
-      pcm_s16le: "s16",
-      pcm_s16be: "s16",
-      pcm_s24le: "s32",
-      pcm_s24be: "s32",
-      pcm_s32le: "s32",
-      pcm_s32be: "s32",
-      pcm_f32le: "flt",
-      pcm_f32be: "flt",
-      pcm_f64le: "dbl",
-      pcm_f64be: "dbl"
-    }[codecName] ?? "fltp";
+    const sampleFormat = probeSampleFormat(track.type, codecName);
     const tagHex = doc.containerFormat === "wav" ? "0x" + (rawTag.charCodeAt(0) | rawTag.charCodeAt(1) << 8).toString(16).padStart(4, "0") : "0x" + Array.from(rawTag.padEnd(4, " ").slice(0, 4)).map((c) => c.charCodeAt(0).toString(16).padStart(2, "0")).join("");
     const durationSec = track.duration / Math.max(1, track.timescale);
     const totalBytes = materialized.samples.reduce((acc, s) => acc + s.size, 0);
@@ -339432,12 +339594,264 @@ function createMediaAstRegistry(plugins) {
   };
 }
 
+// packages/mp4-ast/src/esds-source.ts
+async function probeEsdsSource(source, range, options = {}) {
+  options.signal?.throwIfAborted();
+  if (!Number.isSafeInteger(source.size) || source.size < 0 || !Number.isSafeInteger(range.payloadOffset) || !Number.isSafeInteger(range.payloadSize) || range.payloadOffset < 0 || range.payloadSize < 0 || range.payloadOffset > source.size || range.payloadSize > source.size - range.payloadOffset)
+    throw new RangeError("Invalid ES descriptor range");
+  const iterator = consumeMp4SampleSteps(source, esdsSteps(range), options);
+  const result = await iterator.next();
+  if (!result.done) {
+    await iterator.return(void 0);
+    throw new Error("Unexpected ES descriptor sample");
+  }
+  const { objectTypeIndication, audioObjectType, sampleRate, channelCount, maxBitrate, avgBitrate } = result.value;
+  return { objectTypeIndication, audioObjectType, sampleRate, channelCount, maxBitrate, avgBitrate };
+}
+
+// packages/mp4-ast/src/mp4-codec-source.ts
+async function* scanMp4CodecDescriptions(source, range, options = {}) {
+  options.signal?.throwIfAborted();
+  if (!Number.isSafeInteger(source.size) || source.size < 0 || !Number.isSafeInteger(range.payloadOffset) || !Number.isSafeInteger(range.payloadSize) || range.payloadOffset < 0 || range.payloadSize < 0 || range.payloadOffset > source.size || range.payloadSize > source.size - range.payloadOffset)
+    throw new RangeError("Invalid MP4 sample description range");
+  const read = async (offset, length) => readMp4SampleRange(source, offset, length, options);
+  if (range.payloadSize < 8) return;
+  const header = new BinaryReader(await read(range.payloadOffset, 8));
+  header.skip(4);
+  const count = header.readU32BE();
+  const end = range.payloadOffset + range.payloadSize;
+  for (let i = 0, offset = range.payloadOffset + 8; i < count && end - offset >= 8; i++) {
+    options.signal?.throwIfAborted();
+    options.budget?.checkCpu();
+    const entry = new BinaryReader(await read(offset, 8)), size = entry.readU32BE(), format = entry.readFourCC();
+    if (size < 8 || size > end - offset) break;
+    const bodyOffset = offset + 8, bodySize = size - 8;
+    const state = sampleEntryHeader(format, await read(bodyOffset, Math.min(78, bodySize)));
+    if (state.childOffset !== void 0 && state.childOffset < bodySize) {
+      for await (const child of scanMp4Boxes(source, { offset: bodyOffset + state.childOffset, length: bodySize - state.childOffset, ...options })) {
+        const prefix = async (length) => read(child.payloadOffset, Math.min(length, child.payloadSize));
+        if (state.kind === "video") {
+          if (child.type === "avcC") {
+            const config = await prefix(8), length = config.length >= 8 ? new DataView(config.buffer, config.byteOffset, config.length).getUint16(6) : 0;
+            const spsLength = Math.min(length, Math.max(0, child.payloadSize - 8));
+            if ((config[5] ?? 0) & 31) {
+              try {
+                options.budget?.allocateMemory(spsLength);
+                const sps = new Uint8Array(spsLength);
+                for (let used = 0; used < spsLength; used += 16384) sps.set(await read(child.payloadOffset + 8 + used, Math.min(16384, spsLength - used)), used);
+                applyCodecMetadata(state, { type: "avcC", levelIdc: config[3] ?? 0, sps });
+              } finally {
+                options.budget?.releaseMemory(spsLength);
+              }
+            } else applyCodecMetadata(state, { type: "avcC", levelIdc: config[3] ?? 0 });
+          } else if (child.type === "hvcC") applyCodecMetadata(state, { ...parseHvcC(await prefix(23)), type: "hvcC" });
+          else if (child.type === "av1C") applyCodecMetadata(state, { ...parseAv1C(await prefix(4)), type: "av1C" });
+          else if (child.type === "vpcC") applyCodecMetadata(state, { ...parseVpcC(await prefix(12)), type: "vpcC" });
+          else if (child.type === "pasp" && child.payloadSize >= 8) {
+            const aspect = new BinaryReader(await prefix(8));
+            applyCodecMetadata(state, { type: "pasp", sarWidth: aspect.readU32BE(), sarHeight: aspect.readU32BE() });
+          }
+        } else if (state.kind === "audio") {
+          if (child.type === "esds") applyCodecMetadata(state, { type: "esds", config: await probeEsdsSource(source, child, options) });
+          else if (child.type === "dOps") applyCodecMetadata(state, { ...parseDOps(await prefix(11)), type: "dOps" });
+        }
+      }
+    }
+    yield finishCodecMetadata(state);
+    offset += size;
+  }
+}
+
+// packages/mp4-ast/src/mp4-packets-source.ts
+async function* scanMp4Packets(source, options = {}) {
+  for await (const { sample, track, bytePos } of scanProbeSamples(source, options, false)) {
+    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_" : "__" };
+  }
+}
+async function* scanMp4Frames(source, options = {}) {
+  for await (const { sample, track } of scanProbeSamples(source, options, true)) {
+    const scale = Math.max(1, track.timescale), ptsTime = (sample.pts / scale).toFixed(6);
+    yield {
+      media_type: track.type,
+      stream_index: track.index,
+      key_frame: sample.isKeyframe ? 1 : 0,
+      pts: sample.pts,
+      pts_time: ptsTime,
+      pkt_dts: sample.dts,
+      pkt_dts_time: (sample.dts / scale).toFixed(6),
+      best_effort_timestamp: sample.pts,
+      best_effort_timestamp_time: ptsTime,
+      pkt_duration: sample.duration,
+      pkt_duration_time: (sample.duration / scale).toFixed(6),
+      pkt_size: String(sample.size),
+      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,
+      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
+    };
+  }
+}
+async function* scanProbeSamples(source, options, withCodec) {
+  options.signal?.throwIfAborted();
+  const budget = options.budget ?? new MediaBudgetTracker(options.limits), work = { budget, ...options.signal ? { signal: options.signal } : {}, ...options.checkpoint ? { checkpoint: options.checkpoint } : {} };
+  budget.checkInputBytes(source.size);
+  const read = async (box, length) => new BinaryReader(box ? await readMp4SampleRange(source, box.payloadOffset, Math.min(length, box.payloadSize), work) : new Uint8Array());
+  async function first(parent, type) {
+    if (!parent?.children) return;
+    for await (const box of scanMp4Boxes(source, { ...parent.children, ...work })) if (box.type === type) return box;
+  }
+  let moov, fragmented = false;
+  for await (const box of scanMp4Boxes(source, work)) {
+    if (box.type === "moov" && !moov) moov = box;
+    if (box.type === "moof") fragmented = true;
+  }
+  if (!moov) throw new Error("Invalid MP4/ISOBMFF file: missing 'moov' atom");
+  const mvhd = await first(moov, "mvhd"), movie = await read(mvhd, 32);
+  let movieTimescale = 1e3, movieDuration = 0;
+  if ((mvhd?.payloadSize ?? 0) >= 20) {
+    const version = movie.readU8();
+    movie.skip(3 + (version === 1 ? 16 : 8));
+    movieTimescale = movie.readU32BE() || 1e3;
+    movieDuration = version === 1 ? movie.readU64BE() : movie.readU32BE();
+  }
+  const mvex = await first(moov, "mvex");
+  let trackIndex = 0, maxDuration = movieDuration / Math.max(1, movieTimescale);
+  for await (const trak of scanMp4Boxes(source, { ...moov.children, ...work })) {
+    if (trak.type !== "trak") continue;
+    const index = trackIndex++;
+    budget.checkStreams(trackIndex);
+    const tkhd = await first(trak, "tkhd"), header = await read(tkhd, withCodec ? 96 : 36);
+    let id = index + 1, headerDuration = 0, width, height;
+    if ((tkhd?.payloadSize ?? 0) >= 24) {
+      const version = header.readU8();
+      header.skip(3 + (version === 1 ? 16 : 8));
+      id = header.readU32BE() || id;
+      header.skip(4);
+      headerDuration = version === 1 ? header.readU64BE() : header.readU32BE();
+      if (withCodec) {
+        header.skip(52);
+        const w = Math.round(header.readFixed16_16()), h = Math.round(header.readFixed16_16());
+        if (w > 0) width = w;
+        if (h > 0) height = h;
+      }
+    }
+    const mdia = await first(trak, "mdia"), mdhd = await first(mdia, "mdhd"), media = await read(mdhd, 32);
+    let timescale = movieTimescale, declaredDuration = 0;
+    if ((mdhd?.payloadSize ?? 0) >= 20) {
+      const version = media.readU8();
+      media.skip(3 + (version === 1 ? 16 : 8));
+      timescale = media.readU32BE() || 1e3;
+      declaredDuration = version === 1 ? media.readU64BE() : media.readU32BE();
+    }
+    const hdlr = await first(mdia, "hdlr"), handler = await read(hdlr, 12);
+    handler.skip(8);
+    const handlerType = (hdlr?.payloadSize ?? 0) >= 12 ? handler.readFourCC() : "vide";
+    const type = handlerType === "vide" ? "video" : handlerType === "soun" ? "audio" : ["sbtl", "text", "subp"].includes(handlerType) ? "subtitle" : "data";
+    const stbl = await first(await first(mdia, "minf"), "stbl"), tables = {};
+    if (stbl?.children) for await (const box of scanMp4Boxes(source, { ...stbl.children, ...work })) {
+      if (["stts", "ctts", "stsc", "stsz", "stco", "co64", "stss"].includes(box.type)) {
+        const name = box.type;
+        tables[name] ??= box;
+      }
+    }
+    let codec;
+    if (withCodec) {
+      const stsd = await first(stbl, "stsd");
+      if (stsd) for await (const description of scanMp4CodecDescriptions(source, stsd, work)) {
+        codec = description;
+        break;
+      }
+    }
+    const track = { index, type, timescale, width: width ?? codec?.width, height: height ?? codec?.height, codec };
+    let defaults = { defaultSampleDescriptionIndex: 1, defaultSampleDuration: type === "video" ? 3e3 : 1024, defaultSampleSize: 0, defaultSampleFlags: 0 };
+    if (mvex?.children) for await (const box of scanMp4Boxes(source, { ...mvex.children, ...work })) {
+      if (box.type !== "trex" || box.payloadSize < 24) continue;
+      const row = await read(box, 24);
+      row.skip(4);
+      if (row.readU32BE() !== id) continue;
+      defaults = { defaultSampleDescriptionIndex: row.readU32BE() || 1, defaultSampleDuration: row.readU32BE() || 1024, defaultSampleSize: row.readU32BE(), defaultSampleFlags: row.readU32BE() };
+    }
+    const syncSamples = await options.syncSamples?.(index), sampleOptions = { ...work, type, ...syncSamples ? { syncSamples } : {} };
+    async function* samples() {
+      let state = { dts: 0, sampleCount: 0 };
+      for await (const sample of scanMp4SampleTable(source, tables, sampleOptions)) {
+        state = { dts: sample.dts + sample.duration, sampleCount: state.sampleCount + 1 };
+        yield sample;
+      }
+      if (fragmented) for await (const moof of scanMp4Boxes(source, work)) {
+        if (moof.type !== "moof" || !moof.children) continue;
+        for await (const traf of scanMp4Boxes(source, { ...moof.children, ...work })) {
+          if (traf.type === "traf" && traf.children) state = yield* scanMp4Fragment(source, traf.children, { ...work, type, trackId: id, moofOffset: moof.offset, defaults, state });
+        }
+      }
+    }
+    let duration = 0, mediaEnd = 0, allPacked = true, count = 0;
+    for await (const sample of samples()) {
+      count++;
+      duration += sample.duration;
+      mediaEnd = Math.max(mediaEnd, sample.pts + sample.duration);
+      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;
+      }
+    }
+    const elst = await first(await first(trak, "edts"), "elst");
+    function* editDuration() {
+      if (!elst || elst.payloadSize < 8) return;
+      const header2 = new BinaryReader(yield { kind: "read", table: elst, offset: elst.payloadOffset, length: 8 });
+      const version = header2.readU8();
+      header2.skip(3);
+      const count2 = header2.readU32BE(), width2 = version === 1 ? 20 : 12;
+      let total = 0, entries = 0;
+      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);
+        total += segment;
+        entries++;
+      }
+      return entries ? Math.round(total * timescale / movieTimescale) : void 0;
+    }
+    const edits = consumeMp4SampleSteps(source, editDuration(), sampleOptions), result = await edits.next();
+    if (!result.done) throw new Error("Unexpected MP4 edit sample");
+    const trackDuration = result.value ?? (duration || declaredDuration || Math.round(headerDuration / Math.max(1, movieTimescale) * timescale));
+    maxDuration = Math.max(maxDuration, trackDuration / Math.max(1, timescale));
+    budget.checkDuration(maxDuration);
+    let bytePos = 0, cursor = 0;
+    const packet = (sample) => {
+      const record = { sample, track, bytePos };
+      bytePos += sample.size;
+      return record;
+    };
+    for await (const sample of samples()) {
+      if (type !== "subtitle" || !count || allPacked) {
+        yield packet(sample);
+        continue;
+      }
+      const start = Math.max(cursor, Math.round(sample.pts));
+      if (start > cursor) {
+        yield packet({ pts: cursor, dts: cursor, duration: start - cursor, size: 2, isKeyframe: true });
+        cursor = start;
+      }
+      const duration2 = Math.max(1, Math.round(sample.duration));
+      yield packet({ pts: cursor, dts: cursor, duration: duration2, size: sample.size + 2, isKeyframe: true });
+      cursor += duration2;
+    }
+  }
+  budget.checkDuration(maxDuration);
+}
+
 export {
+  encodeUtf8,
+  decodeUtf8,
   cloudflareWorkerLimits,
   MediaLimitExceededError,
   MediaBudgetTracker,
-  encodeUtf8,
-  decodeUtf8,
   decodeH264Samples,
   parseMp4,
   concatMp4,
@@ -339456,7 +339870,9 @@ export {
   hlsAst,
   dashAst,
   allMediaAsts,
-  createMediaAstRegistry
+  createMediaAstRegistry,
+  scanMp4Packets,
+  scanMp4Frames
 };
 /*!
 Generated portable media codecs.