@poe-platform/safe-bash 0.1.809 → 0.1.811

package/dist/safe-bash/command-chunks/{chunk-GKYCV6BU.js → chunk-YSY6R6AS.js}

@@ -1,163 +1,110 @@
+import {
+  resolveFfprobeLimits
+} from "./chunk-MGBHGZEX.js";
 import {
   MediaBudgetTracker,
   allMediaAsts,
   createMediaAstRegistry,
   encodeUtf8,
   parseStreamingManifest
-} from "./chunk-DCD32BEY.js";
+} from "./chunk-VU3EQF7F.js";
 
-// packages/safe-bash-command-ffprobe/src/probe-output.ts
-import { PagedStorage } from "@poe-platform/safe-fs/storage";
-import { writeBytes } from "../../safe-bash-contracts/io.js";
+// packages/safe-bash-command-ffprobe/src/wav-tags.ts
+import { IntegerTable, PagedStorage } from "@poe-platform/safe-fs/storage";
 import { yieldTurn } from "../../safe-bash-contracts/yield.js";
-async function* encodeParts(parts, signal) {
-  const encoder = new TextEncoder();
-  let high = "", steps = 0;
-  for (const part of parts) {
-    signal.throwIfAborted();
-    for (let offset = 0; offset < part.length; offset += 4096) {
-      signal.throwIfAborted();
-      let text = high + part.slice(offset, offset + 4096);
-      high = "";
-      const last = text.charCodeAt(text.length - 1);
-      if (last >= 55296 && last <= 56319) {
-        high = text.at(-1);
-        text = text.slice(0, -1);
-      }
-      if (text) yield encoder.encode(text);
-      if (++steps % 256 === 0) await yieldTurn(signal);
-    }
+var WavTags = class {
+  constructor(source, context) {
+    this.source = source;
+    this.context = context;
+    this.storage = new PagedStorage(context, 4);
+    this.close = this.storage.close.bind(this.storage);
+    this.keys = new IntegerTable(this.storage, 128);
+    this.numeric = new IntegerTable(this.storage, 128);
   }
-  if (high) yield encoder.encode(high);
-}
-async function writeProbeOutput(context, parts, check) {
-  const storage = new PagedStorage(context, 4), start = storage.allocate(0);
-  let size = 0, failed = true;
-  try {
-    for await (const bytes of encodeParts(parts, context.signal)) {
-      size += bytes.length;
-      check(size);
-      await storage.append(bytes);
+  source;
+  context;
+  storage;
+  keys;
+  numeric;
+  head = 0;
+  tail = 0;
+  count = 0;
+  close;
+  async *decoded(offset, length) {
+    const decoder = new TextDecoder();
+    let steps = 0;
+    for (let at = 0; at < length; at += 16384) {
+      this.context.signal.throwIfAborted();
+      const bytes = await this.source.read(offset + at, Math.min(16384, length - at));
+      this.context.signal.throwIfAborted();
+      if (bytes.length !== Math.min(16384, length - at)) throw new Error("Truncated WAV tag");
+      yield decoder.decode(bytes, { stream: true });
+      if (++steps % 256 === 0) await yieldTurn(this.context.signal);
     }
-    context.signal.throwIfAborted();
-    if (size === 0) await writeBytes(context.stdout, new Uint8Array(0), context.signal);
-    for (let offset = 0; offset < size; offset += 16384)
-      await writeBytes(context.stdout, await storage.read(start + offset, Math.min(16384, size - offset)), context.signal);
-    failed = false;
-  } finally {
-    if (failed) {
-      try {
-        await storage.close();
-      } catch {
-      }
-    } else await storage.close();
+    yield decoder.decode();
   }
-}
-
-// packages/safe-bash-command-ffprobe/src/stream-input.ts
-import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
-import { readBytes } from "../../safe-bash-contracts/io.js";
-import { readFileStream } from "../../safe-bash-contracts/filesystem.js";
-import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
-async function openProbeStream(context, path) {
-  context.signal.throwIfAborted();
-  if (path === void 0) return readBytes(context.stdin, context.signal);
-  const capabilities = await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities;
-  context.signal.throwIfAborted();
-  if (!context.fs.readStream || capabilities.streamingRead === false || context.fs.capabilities.streamingRead === false) return void 0;
-  return readFileStream(context.fs, path, { signal: context.signal, chunkSize: 16384 });
-}
-async function sniffWavStream(source, signal, account) {
-  const iterator = source[Symbol.asyncIterator](), prefix = new Uint8Array(12);
-  let size = 0, total = 0, ended = false;
-  let remainder = new Uint8Array(0);
-  try {
-    while (size < prefix.length) {
-      signal.throwIfAborted();
-      const next = await iterator.next();
-      signal.throwIfAborted();
-      if (next.done) {
-        ended = true;
-        break;
+  async add(span) {
+    let units = 0, kept = 0;
+    for await (const text of this.decoded(span.offset, span.length)) {
+      const zero = text.indexOf("\0"), part = zero < 0 ? text : text.slice(0, zero);
+      for (const unit of part) {
+        units += unit.length;
+        if (unit.trimEnd()) kept = units;
       }
-      total += next.value.length;
-      account(total);
-      const take = Math.min(prefix.length - size, next.value.length);
-      prefix.set(next.value.subarray(0, take), size);
-      size += take;
-      remainder = next.value.subarray(take);
+      if (zero >= 0) break;
     }
-  } catch (error) {
-    try {
-      await iterator.return?.();
-    } catch {
+    let key = 0n;
+    for (let i = 0; i < span.key.length; i++) key = key << (span.key.length > 4 ? 7n : 16n) | BigInt(span.key.charCodeAt(i));
+    if (span.key.length > 4) key |= 1n << 63n;
+    const existing = await this.keys.get(key);
+    const position = existing === void 0 ? this.storage.allocate(56) : Number(existing);
+    const bytes = existing === void 0 ? new Uint8Array(56) : await this.storage.read(position, 56);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+    view.setFloat64(8, span.offset, true);
+    view.setFloat64(16, span.length, true);
+    view.setFloat64(24, kept, true);
+    view.setUint16(32, span.key.length, true);
+    for (let i = 0; i < span.key.length; i++) view.setUint16(34 + i * 2, span.key.charCodeAt(i), true);
+    await this.storage.write(position, bytes);
+    if (existing !== void 0) return;
+    await this.keys.set(key, BigInt(position));
+    this.count++;
+    const numeric = Number(span.key);
+    if (Number.isInteger(numeric) && numeric >= 0 && numeric < 4294967295 && String(numeric) === span.key) await this.numeric.set(BigInt(numeric), BigInt(position));
+    else {
+      if (this.tail) {
+        const link = new Uint8Array(8);
+        new DataView(link.buffer).setFloat64(0, position, true);
+        await this.storage.write(this.tail, link);
+      } else this.head = position;
+      this.tail = position;
     }
-    throw error;
   }
-  async function* replay() {
-    let failed = false;
-    try {
-      signal.throwIfAborted();
-      if (size) yield prefix.subarray(0, size);
-      if (remainder.length) yield remainder;
-      remainder = new Uint8Array(0);
-      while (!ended) {
-        signal.throwIfAborted();
-        const next = await iterator.next();
-        signal.throwIfAborted();
-        if (next.done) {
-          ended = true;
-          break;
-        }
-        total += next.value.length;
-        account(total);
-        yield next.value;
-      }
-    } catch (error) {
-      failed = true;
-      throw error;
-    } finally {
-      if (!ended) {
-        if (failed) {
-          try {
-            await iterator.return?.();
-          } catch {
-          }
-        } else await iterator.return?.();
+  async record(position) {
+    const bytes = await this.storage.read(position, 56), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+    let key = "";
+    for (let i = 0; i < view.getUint16(32, true); i++) key += String.fromCharCode(view.getUint16(34 + i * 2, true));
+    const offset = view.getFloat64(8, true), length = view.getFloat64(16, true), kept = view.getFloat64(24, true), decoded = this.decoded.bind(this);
+    return { key, next: view.getFloat64(0, true), async *text() {
+      let remaining = kept;
+      if (!remaining) return;
+      for await (const part of decoded(offset, length)) {
+        const take = Math.min(remaining, part.length);
+        if (take) yield part.slice(0, take);
+        remaining -= take;
+        if (!remaining) return;
       }
-    }
+    } };
   }
-  const text = new TextDecoder().decode(prefix);
-  return { wav: size === 12 && text.slice(0, 4) === "RIFF" && text.slice(8) === "WAVE", stream: replay() };
-}
-async function withStagedProbeSource(context, input, probe2) {
-  const storage = new PagedStorage2(context, 4);
-  let start;
-  let size = 0, steps = 0, failed = true;
-  try {
-    for await (const chunk of input) {
-      context.signal.throwIfAborted();
-      size += chunk.length;
-      start ??= storage.allocate(0);
-      await storage.append(chunk);
-      if (++steps % 256 === 0) await yieldTurn2(context.signal);
+  async *entries() {
+    for await (const [, position] of this.numeric.entries()) yield await this.record(Number(position));
+    for (let position = this.head; position; ) {
+      const entry = await this.record(position);
+      position = entry.next;
+      yield entry;
     }
-    context.signal.throwIfAborted();
-    start ??= storage.allocate(0);
-    const base = start;
-    const result = await probe2({ size, read: (offset, length) => storage.read(base + offset, length) });
-    context.signal.throwIfAborted();
-    failed = false;
-    return result;
-  } finally {
-    if (failed) {
-      try {
-        await storage.close();
-      } catch {
-      }
-    } else await storage.close();
   }
-}
+};
 
 // packages/safe-bash-command-ffprobe/src/probe.ts
 import { parseAudio } from "../../audio-ast/index.js";
@@ -221,8 +168,8 @@ function probe(data, args) {
   const parsed = parseArguments(args);
   return formatAudioProbe(parseAudio(data, { maxAtomDepth: 64 }), data.length, parsed);
 }
-function formatAudioProbe(audio, size, parsed) {
-  const { sections, format, settings } = parsed;
+function audioProbeRows(audio, size, parsed, retainedTags = false) {
+  const { sections } = parsed;
   const serials = [
     ...new Set(
       audio.nodes.filter((node) => node.type === "OggS").map((node) => node.fields?.serial)
@@ -285,11 +232,16 @@ function formatAudioProbe(audio, size, parsed) {
       duration: formatDuration.toFixed(6),
       size: String(size),
       bit_rate: String(formatDuration ? Math.floor(size * 8 / formatDuration) : 0),
-      ...Object.keys(formatTags).length ? { tags: formatTags } : {}
+      ...retainedTags || Object.keys(formatTags).length ? { tags: formatTags } : {}
     });
     if (sections.has("format_tags")) row.tags = tags;
     rows.push({ section: "format", row });
   }
+  return rows;
+}
+function formatAudioProbe(audio, size, parsed) {
+  const { sections, format, settings } = parsed;
+  const rows = audioProbeRows(audio, size, parsed);
   if (format === "json") {
     const result = {};
     if (sections.has("stream") || sections.has("stream_tags"))
@@ -334,6 +286,320 @@ function formatAudioProbe(audio, size, parsed) {
   return lines.length ? lines.join("\n") + "\n" : "";
 }
 
+// packages/safe-bash-command-ffprobe/src/tag-format.ts
+async function* parts(value, prefix = "") {
+  if (prefix) yield prefix;
+  if (typeof value === "function") yield* value();
+  else yield String(value);
+}
+async function* jsonString(input) {
+  yield '"';
+  for await (const part of input) yield JSON.stringify(part).slice(1, -1);
+  yield '"';
+}
+async function* replace(input, needle, replacement) {
+  let pending = "", first = true;
+  if (!needle) {
+    for await (const part of input) {
+      let text = "";
+      for (let i = 0; i < part.length; i++) {
+        text += (first ? "" : replacement) + part[i];
+        first = false;
+        if (text.length >= 4096) {
+          yield text;
+          text = "";
+        }
+      }
+      if (text) yield text;
+    }
+    return;
+  }
+  for await (const part of input) {
+    const text = pending + part;
+    let at = 0, found, output = "";
+    while ((found = text.indexOf(needle, at)) >= 0) {
+      output += text.slice(at, found) + replacement;
+      at = found + needle.length;
+      if (output.length >= 16384) {
+        yield output;
+        output = "";
+      }
+    }
+    const end = Math.max(at, text.length - needle.length + 1);
+    output += text.slice(at, end);
+    if (output) yield output;
+    pending = text.slice(end);
+  }
+  if (pending) yield pending;
+}
+async function needsQuotes(input, separator) {
+  if (!separator) return true;
+  let tail = "";
+  for await (const part of input) {
+    const text = tail + part;
+    if (text.includes(separator) || text.includes('"') || text.includes("\n")) return true;
+    tail = text.slice(Math.max(0, text.length - separator.length + 1));
+  }
+  return false;
+}
+async function* formatTaggedAudio(audio, size, args, tags) {
+  const parsed = parseArguments(args), { sections, format, settings } = parsed;
+  const rows = audioProbeRows({ ...audio, nodes: [] }, size, parsed, tags.count > 0);
+  async function* tagFields(section) {
+    const selected = sections.get(section + "_tags");
+    for await (const entry of tags.entries()) if (selected === void 0 || selected.includes(entry.key)) yield { key: entry.key, value: entry.text };
+  }
+  async function* jsonRow(row, section, indent) {
+    yield "{";
+    let first = true;
+    for (const [key, value] of Object.entries(row)) {
+      yield (first ? "\n" : ",\n") + " ".repeat(indent + 4) + JSON.stringify(key) + ": ";
+      first = false;
+      if (typeof value === "object") {
+        yield "{";
+        let firstTag = true;
+        for await (const field of tagFields(section)) {
+          yield (firstTag ? "\n" : ",\n") + " ".repeat(indent + 8) + JSON.stringify(field.key) + ": ";
+          firstTag = false;
+          yield* jsonString(parts(field.value));
+        }
+        yield (firstTag ? "" : "\n" + " ".repeat(indent + 4)) + "}";
+      } else if (typeof value === "number") yield JSON.stringify(value);
+      else yield* jsonString(parts(value));
+    }
+    yield (first ? "" : "\n" + " ".repeat(indent)) + "}";
+  }
+  if (format === "json") {
+    yield "{";
+    let first = true;
+    if (sections.has("stream") || sections.has("stream_tags")) {
+      yield '\n    "streams": [';
+      first = false;
+      let firstStream = true;
+      for (const { section, row } of rows) if (section === "stream") {
+        yield (firstStream ? "\n" : ",\n") + "        ";
+        firstStream = false;
+        yield* jsonRow(row, section, 8);
+      }
+      yield (firstStream ? "" : "\n    ") + "]";
+    }
+    for (const { section, row } of rows) if (section === "format") {
+      yield (first ? "\n" : ",\n") + '    "format": ';
+      first = false;
+      yield* jsonRow(row, section, 4);
+    }
+    yield (first ? "" : "\n") + "}\n";
+    return;
+  }
+  const enabled = (a, b, fallback) => {
+    const value = settings.get(a) ?? settings.get(b);
+    return value === void 0 ? fallback : value === "1";
+  };
+  let streamIndex = 0;
+  for (const { section, row } of rows) {
+    async function* fields() {
+      for (const [key, value] of Object.entries(row)) {
+        if (typeof value === "object") {
+          for await (const tag of tagFields(section)) yield { key: "tag:" + tag.key, value: tag.value };
+        } else yield { key, value };
+      }
+    }
+    if (format === "compact" || format === "csv") {
+      const separator = settings.get("item_sep") ?? settings.get("s") ?? (format === "csv" ? "," : "|");
+      let first = true;
+      if (enabled("print_section", "p", true)) {
+        yield section;
+        first = false;
+      }
+      for await (const field of fields()) {
+        if (!first) yield separator;
+        first = false;
+        const prefix = enabled("nokey", "nk", format === "csv") ? "" : field.key + "=";
+        if (format === "csv") {
+          const quote = await needsQuotes(parts(field.value, prefix), separator);
+          if (quote) yield '"';
+          yield* quote ? replace(parts(field.value, prefix), '"', '""') : parts(field.value, prefix);
+          if (quote) yield '"';
+        } else yield* replace(replace(replace(replace(parts(field.value, prefix), "\\", "\\\\"), "\n", "\\n"), "\r", "\\r"), separator, "\\" + separator);
+      }
+      yield "\n";
+    } else if (format === "flat") {
+      const prefix = section === "stream" ? `streams.stream.${streamIndex++}` : "format";
+      for await (const field of fields()) {
+        yield prefix + "." + (field.key.startsWith("tag:") ? "tags." + field.key.slice(4) : field.key) + "=";
+        if (typeof field.value === "number") yield String(field.value);
+        else yield* jsonString(parts(field.value));
+        yield "\n";
+      }
+    } else {
+      if (!enabled("noprint_wrappers", "nw", false)) yield "[" + section.toUpperCase() + "]\n";
+      for await (const field of fields()) {
+        if (!enabled("nokey", "nk", false)) yield (field.key.startsWith("tag:") ? "TAG:" + field.key.slice(4) : field.key) + "=";
+        yield* parts(field.value);
+        yield "\n";
+      }
+      if (!enabled("noprint_wrappers", "nw", false)) yield "[/" + section.toUpperCase() + "]\n";
+    }
+  }
+}
+
+// packages/safe-bash-command-ffprobe/src/probe-output.ts
+import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+import { writeBytes } from "../../safe-bash-contracts/io.js";
+import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
+async function* encodeParts(parts2, signal) {
+  const encoder = new TextEncoder();
+  let high = "", steps = 0;
+  for await (const part of parts2) {
+    signal.throwIfAborted();
+    for (let offset = 0; offset < part.length; offset += 4096) {
+      signal.throwIfAborted();
+      let text = high + part.slice(offset, offset + 4096);
+      high = "";
+      const last = text.charCodeAt(text.length - 1);
+      if (last >= 55296 && last <= 56319) {
+        high = text.at(-1);
+        text = text.slice(0, -1);
+      }
+      if (text) yield encoder.encode(text);
+      if (++steps % 256 === 0) await yieldTurn2(signal);
+    }
+  }
+  if (high) yield encoder.encode(high);
+}
+async function writeProbeOutput(context, parts2, check, beforePublish) {
+  const storage = new PagedStorage2(context, 4), start = storage.allocate(0);
+  let size = 0, failed = true;
+  try {
+    for await (const bytes of encodeParts(parts2, context.signal)) {
+      size += bytes.length;
+      check(size);
+      await storage.append(bytes);
+    }
+    context.signal.throwIfAborted();
+    await beforePublish?.();
+    context.signal.throwIfAborted();
+    if (size === 0) await writeBytes(context.stdout, new Uint8Array(0), context.signal);
+    for (let offset = 0; offset < size; offset += 16384)
+      await writeBytes(context.stdout, await storage.read(start + offset, Math.min(16384, size - offset)), context.signal);
+    failed = false;
+  } finally {
+    if (failed) {
+      try {
+        await storage.close();
+      } catch {
+      }
+    } else await storage.close();
+  }
+}
+
+// packages/safe-bash-command-ffprobe/src/stream-input.ts
+import { PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
+import { readBytes } from "../../safe-bash-contracts/io.js";
+import { readFileStream } from "../../safe-bash-contracts/filesystem.js";
+import { yieldTurn as yieldTurn3 } from "../../safe-bash-contracts/yield.js";
+async function openProbeStream(context, path) {
+  context.signal.throwIfAborted();
+  if (path === void 0) return readBytes(context.stdin, context.signal);
+  const capabilities = await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities;
+  context.signal.throwIfAborted();
+  if (!context.fs.readStream || capabilities.streamingRead === false || context.fs.capabilities.streamingRead === false) return void 0;
+  return readFileStream(context.fs, path, { signal: context.signal, chunkSize: 16384 });
+}
+async function sniffMediaStream(source, signal, account) {
+  const iterator = source[Symbol.asyncIterator](), prefix = new Uint8Array(12);
+  let size = 0, total = 0, ended = false;
+  let remainder = new Uint8Array(0);
+  try {
+    while (size < prefix.length) {
+      signal.throwIfAborted();
+      const next = await iterator.next();
+      signal.throwIfAborted();
+      if (next.done) {
+        ended = true;
+        break;
+      }
+      total += next.value.length;
+      account(total);
+      const take = Math.min(prefix.length - size, next.value.length);
+      prefix.set(next.value.subarray(0, take), size);
+      size += take;
+      remainder = next.value.subarray(take);
+    }
+  } catch (error) {
+    try {
+      await iterator.return?.();
+    } catch {
+    }
+    throw error;
+  }
+  async function* replay() {
+    let failed = false;
+    try {
+      signal.throwIfAborted();
+      if (size) yield prefix.subarray(0, size);
+      if (remainder.length) yield remainder;
+      remainder = new Uint8Array(0);
+      while (!ended) {
+        signal.throwIfAborted();
+        const next = await iterator.next();
+        signal.throwIfAborted();
+        if (next.done) {
+          ended = true;
+          break;
+        }
+        total += next.value.length;
+        account(total);
+        yield next.value;
+      }
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      if (!ended) {
+        if (failed) {
+          try {
+            await iterator.return?.();
+          } catch {
+          }
+        } else await iterator.return?.();
+      }
+    }
+  }
+  return { prefix: prefix.subarray(0, size), stream: replay() };
+}
+async function withStagedProbeSource(context, input, probe2, retain) {
+  const storage = new PagedStorage3(context, 4);
+  retain?.(storage.close.bind(storage));
+  let start;
+  let size = 0, steps = 0, failed = true;
+  try {
+    for await (const chunk of input) {
+      context.signal.throwIfAborted();
+      size += chunk.length;
+      start ??= storage.allocate(0);
+      await storage.append(chunk);
+      if (++steps % 256 === 0) await yieldTurn3(context.signal);
+    }
+    context.signal.throwIfAborted();
+    start ??= storage.allocate(0);
+    const base = start;
+    const result = await probe2({ size, read: (offset, length) => storage.read(base + offset, length) });
+    context.signal.throwIfAborted();
+    failed = false;
+    return result;
+  } finally {
+    if (!retain) {
+      if (failed) {
+        try {
+          await storage.close();
+        } catch {
+        }
+      } else await storage.close();
+    }
+  }
+}
+
 // packages/safe-bash-command-ffprobe/src/media.ts
 import { probeWavSource } from "../../audio-ast/index.js";
 import { commandRuntimeIdentity, getCommandArguments } from "../../safe-bash-contracts/command.js";
@@ -411,9 +677,9 @@ function resolvePath(cwd, p) {
   return normalizePath(`${cwd.endsWith("/") ? cwd : `${cwd}/`}${p}`);
 }
 function normalizePath(p) {
-  const parts = p.split("/");
+  const parts2 = p.split("/");
   const stack = [];
-  for (const part of parts) {
+  for (const part of parts2) {
     if (!part || part === ".") continue;
     if (part === "..") {
       stack.pop();
@@ -840,7 +1106,7 @@ function parseProbeArguments(args) {
     inputTarget
   };
 }
-async function probeSourceMetadata(context, plugin, input, filename, budget, records, onAudio) {
+async function probeSourceMetadata(context, plugins, input, filename, budget, records, onAudio, retain, detect = false) {
   let sourceFailed = false;
   const source = { size: input.size, async read(offset, length) {
     try {
@@ -852,21 +1118,26 @@ async function probeSourceMetadata(context, plugin, input, filename, budget, rec
       throw error;
     }
   } };
-  if (onAudio) {
-    if (input.size < 12) {
-      return void 0;
-    }
-    const header = await source.read(0, 12);
+  let plugin = plugins[0];
+  if (detect) {
+    const header = await source.read(0, Math.min(12, input.size));
     context.signal.throwIfAborted();
-    const text = new TextDecoder().decode(header);
-    if (text.slice(0, 4) !== "RIFF" || text.slice(8) !== "WAVE") {
-      return void 0;
-    }
+    plugin = plugins.find((candidate) => candidate.detect(header, filename));
   }
+  if (!plugin) return void 0;
   const result = await plugin.probeMetadata(source, { ...records, filename, signal: context.signal, budget, limits: budget.limits });
   if (onAudio) {
+    const tags = new WavTags(source, context);
+    retain(tags.close);
     try {
-      onAudio(await probeWavSource(source, { signal: context.signal }), input.size);
+      onAudio(await probeWavSource(source, { signal: context.signal, onTag: async (span) => {
+        try {
+          await tags.add(span);
+        } catch (error) {
+          sourceFailed = true;
+          throw error;
+        }
+      } }), input.size, tags);
     } catch (error) {
       context.signal.throwIfAborted();
       if (sourceFailed) throw error;
@@ -874,13 +1145,14 @@ async function probeSourceMetadata(context, plugin, input, filename, budget, rec
   }
   return result;
 }
-async function probeRetainedMetadata(context, plugin, path, filename, budget, records, onAudio) {
-  if (!plugin.canDemux || !plugin.probeMetadata || !context.fs.openReadFile) return void 0;
+async function probeRetainedMetadata(context, plugins, path, filename, budget, records, onAudio, retain, detect = false) {
+  if (!plugins.length || !context.fs.openReadFile) return void 0;
   context.signal.throwIfAborted();
   const capabilities = await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities;
   context.signal.throwIfAborted();
   if (capabilities.retainedRead !== true) return void 0;
   const handle = await context.fs.openReadFile(path, { signal: context.signal });
+  if (onAudio) retain(handle.close.bind(handle));
   let failed = true;
   try {
     context.signal.throwIfAborted();
@@ -889,20 +1161,22 @@ async function probeRetainedMetadata(context, plugin, path, filename, budget, re
     if (!Number.isSafeInteger(stat.size) || stat.size < 0) throw new Error("Invalid media source size");
     context.inputBudget?.check(stat.size);
     budget.checkInputBytes(stat.size);
-    const result = await probeSourceMetadata(context, plugin, {
+    const result = await probeSourceMetadata(context, plugins, {
       size: stat.size,
       read: (offset, length) => handle.read(offset, length, { signal: context.signal })
-    }, filename, budget, records, onAudio);
+    }, filename, budget, records, onAudio, retain, detect);
     context.signal.throwIfAborted();
     failed = false;
     return result;
   } finally {
-    if (failed) {
-      try {
-        await handle.close();
-      } catch {
-      }
-    } else await handle.close();
+    if (!onAudio) {
+      if (failed) {
+        try {
+          await handle.close();
+        } catch {
+        }
+      } else await handle.close();
+    }
   }
 }
 async function probeStreamMetadata(context, plugin, filename, budget, records) {
@@ -926,10 +1200,7 @@ async function probeStreamMetadata(context, plugin, filename, budget, records) {
   return result;
 }
 function createFfprobeCommand(options = {}) {
-  const limits = { maxInputBytes: 32 * 1024 * 1024, maxOutputBytes: 1024 * 1024, ...options.limits };
-  for (const value of [limits.maxInputBytes, limits.maxOutputBytes]) {
-    if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1)) throw new RangeError("Invalid ffprobe limit");
-  }
+  const limits = resolveFfprobeLimits(options.limits);
   const astPlugins = options.asts ?? getDefaultMediaRegistry().astPlugins;
   const registry = options.asts ? createMediaAstRegistry(astPlugins) : getDefaultMediaRegistry().registry;
   return {
@@ -967,6 +1238,25 @@ function createFfprobeCommand(options = {}) {
           return { exitCode: 0 };
         }
       }
+      const retained = [];
+      const retain = (close) => {
+        retained.push(close);
+      };
+      const closeInputs = async () => {
+        let failure, failed = false;
+        while (retained.length) {
+          try {
+            await retained.pop()();
+          } catch (error) {
+            if (!failed) {
+              failed = true;
+              failure = error;
+            }
+          }
+        }
+        if (failed) throw failure;
+      };
+      let storedTags;
       try {
         const {
           printFormat,
@@ -992,26 +1282,41 @@ function createFfprobeCommand(options = {}) {
             automaticAudio = false;
           }
         }
-        const automaticPlugin = automaticAudio ? registry.findByFormatName("wav") : void 0;
+        const automaticPlugins = !options.asts && !explicitFormat ? astPlugins.filter((plugin) => plugin.canDemux && plugin.probeMetadata && (!automaticAudio || plugin === registry.findByFormatName("wav"))) : [];
         const explicitPlugin = explicitFormat ? registry.findByFormatName(explicitFormat) : void 0;
-        const retainedPlugin = explicitPlugin ?? automaticPlugin;
-        let probeResult = retainedPlugin && !isStdin(inputTarget) ? await probeRetainedMetadata(context, retainedPlugin, resolvePath(context.cwd, inputTarget), inputTarget, budget, { showPackets, showFrames }, automaticAudio ? (audio, size) => {
+        const retainedPlugins = explicitPlugin ? explicitPlugin.canDemux && explicitPlugin.probeMetadata ? [explicitPlugin] : [] : automaticPlugins;
+        let probeResult = retainedPlugins.length && !isStdin(inputTarget) ? await probeRetainedMetadata(context, retainedPlugins, resolvePath(context.cwd, inputTarget), inputTarget, budget, { showPackets, showFrames }, automaticAudio ? (audio, size, tags) => {
           audioInput = { audio, size, args };
-        } : void 0) : void 0;
+          storedTags = tags;
+        } : void 0, retain, !explicitPlugin) : void 0;
         if (!probeResult && explicitPlugin)
           probeResult = await probeStreamMetadata(context, explicitPlugin, inputTarget, budget, { showPackets, showFrames });
         let replay;
-        if (!probeResult && automaticPlugin?.probeMetadata) {
+        if (!probeResult && automaticPlugins.length) {
           const source = await openProbeStream(context, isStdin(inputTarget) ? void 0 : resolvePath(context.cwd, inputTarget));
           if (source) {
-            const sniffed = await sniffWavStream(source, context.signal, (total) => {
+            const sniffed = await sniffMediaStream(source, context.signal, (total) => {
               context.inputBudget?.check(total);
               budget.checkInputBytes(total);
             });
-            if (sniffed.wav) {
-              probeResult = await withStagedProbeSource(context, sniffed.stream, (source2) => probeSourceMetadata(context, automaticPlugin, source2, inputTarget, budget, { showPackets, showFrames }, (audio, size) => {
-                audioInput = { audio, size, args };
-              }));
+            const automaticPlugin = automaticPlugins.find((plugin) => plugin.detect(sniffed.prefix, inputTarget));
+            if (automaticPlugin) {
+              if (!automaticAudio && automaticPlugin.probeMetadataStream) {
+                probeResult = await automaticPlugin.probeMetadataStream(sniffed.stream, {
+                  showPackets,
+                  showFrames,
+                  filename: inputTarget,
+                  signal: context.signal,
+                  budget,
+                  limits: budget.limits
+                });
+                context.signal.throwIfAborted();
+              } else {
+                probeResult = await withStagedProbeSource(context, sniffed.stream, (source2) => probeSourceMetadata(context, [automaticPlugin], source2, inputTarget, budget, { showPackets, showFrames }, automaticAudio ? (audio, size, tags) => {
+                  audioInput = { audio, size, args };
+                  storedTags = tags;
+                } : void 0, retain), retain);
+              }
             } else replay = sniffed.stream;
           }
         }
@@ -1022,6 +1327,7 @@ function createFfprobeCommand(options = {}) {
             const msg = explicitFormat ? `ffprobe: Unknown input format: '${explicitFormat}' (AST not registered)
 ` : `ffprobe: ${inputTarget}: Invalid data found when processing input or format AST not registered
 `;
+            await closeInputs();
             if (!quiet) await writeBytes2(context.stderr, encodeUtf8(msg), context.signal);
             return { exitCode: 1 };
           }
@@ -1036,7 +1342,7 @@ function createFfprobeCommand(options = {}) {
           });
           if (!options.asts && !explicitFormat) audioInput = { bytes, args };
         }
-        const formatted = formatFfprobeResultChunks(probeResult, {
+        const formatted = storedTags && audioInput && "audio" in audioInput ? formatTaggedAudio(audioInput.audio, audioInput.size, audioInput.args, storedTags) : formatFfprobeResultChunks(probeResult, {
           printFormat,
           showFormat,
           showStreams,
@@ -1049,10 +1355,14 @@ function createFfprobeCommand(options = {}) {
           countFrames,
           countPackets
         }, audioInput);
-        await writeProbeOutput(context, formatted, (total) => budget.checkOutputBytes(total));
+        await writeProbeOutput(context, formatted, (total) => budget.checkOutputBytes(total), closeInputs);
         options.onMetrics?.(budget.getStats());
         return { exitCode: 0 };
       } catch (err) {
+        try {
+          await closeInputs();
+        } catch {
+        }
         rethrowRuntimeError(context, err);
         const msg = err instanceof Error ? err.message : String(err);
         if (!quiet)