@poe-platform/safe-bash 0.1.811 → 0.1.813

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

@@ -6,100 +6,361 @@ import {
   allMediaAsts,
   createMediaAstRegistry,
   encodeUtf8,
-  parseStreamingManifest
-} from "./chunk-VU3EQF7F.js";
+  parseStreamingManifest,
+  probeOggFlacSource,
+  probeOggStreamMetadata
+} from "./chunk-7NXTEWPR.js";
 
-// packages/safe-bash-command-ffprobe/src/wav-tags.ts
+// packages/safe-bash-command-ffprobe/src/ogg-probe.ts
+import { probeOggStreamSource } from "../../audio-ast/index.js";
+
+// packages/safe-bash-command-ffprobe/src/ogg-index.ts
+import { scanOggPages } from "../../audio-ast/index.js";
 import { IntegerTable, PagedStorage } from "@poe-platform/safe-fs/storage";
 import { yieldTurn } from "../../safe-bash-contracts/yield.js";
-var WavTags = class {
+var OggIndex = class {
   constructor(source, context) {
     this.source = source;
     this.context = context;
     this.storage = new PagedStorage(context, 4);
+    this.serials = new IntegerTable(this.storage, 128);
+    this.close = async () => {
+      this.closed = true;
+      await this.storage.close();
+    };
+  }
+  source;
+  context;
+  storage;
+  serials;
+  first = 0;
+  last = 0;
+  firstPage = 0;
+  lastPage = 0;
+  started = false;
+  ready = false;
+  closed = false;
+  close;
+  check() {
+    this.context.signal.throwIfAborted();
+    if (this.closed) throw new Error("Ogg index is closed");
+  }
+  async scan() {
+    this.check();
+    if (this.started) throw new Error("Ogg index already scanned");
+    this.started = true;
+    let active = 0, seen = 0, group = 0;
+    for await (const page of scanOggPages(this.source, { signal: this.context.signal, checkpoint: async () => {
+      this.check();
+      await yieldTurn(this.context.signal);
+      this.check();
+    } })) {
+      const key = BigInt(page.serial), existing = await this.serials.get(key);
+      const position = existing === void 0 ? this.storage.allocate(128) : Number(existing);
+      const bytes = existing === void 0 ? new Uint8Array(128) : await this.storage.read(position, 128);
+      const row = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+      if (existing === void 0) {
+        if (!(page.flags & 2) || page.sequence !== 0) throw new Error("Missing Ogg beginning-of-stream");
+        row.setUint32(8, 4294967295, true);
+        row.setUint32(96, page.serial, true);
+        await this.serials.set(key, BigInt(position));
+        if (!active) group++;
+        row.setFloat64(120, group, true);
+        if (this.lastPage) {
+          const link = new Uint8Array(8);
+          new DataView(link.buffer).setFloat64(0, position, true);
+          await this.storage.write(this.lastPage + 104, link);
+        } else this.firstPage = position;
+        this.lastPage = position;
+        active++;
+        seen++;
+      }
+      if (bytes[12] || page.sequence !== row.getUint32(8, true) + 1 >>> 0 || !!(page.flags & 1) !== !!bytes[13])
+        throw new Error("Invalid Ogg sequence/continuation");
+      row.setUint32(8, page.sequence, true);
+      if (page.granule !== 0xffffffffffffffffn) row.setBigUint64(112, page.granule, true);
+      row.setFloat64(32, row.getFloat64(32, true) + page.size, true);
+      let packet = row.getFloat64(16, true), pending = row.getFloat64(24, true);
+      let sourceOffset = page.payloadOffset, spanSize = 0, completed = false;
+      for (let i = 0; i < page.lacing.length; i++) {
+        const lace = page.lacing[i];
+        spanSize += lace;
+        if (lace === 255 && i !== page.lacing.length - 1) continue;
+        if (packet < 2 && spanSize) {
+          const span = this.storage.allocate(32), data = new Uint8Array(32), record = new DataView(data.buffer);
+          record.setFloat64(8, pending, true);
+          record.setFloat64(16, sourceOffset, true);
+          record.setFloat64(24, spanSize, true);
+          await this.storage.write(span, data);
+          const field = 48 + packet * 24, tail = row.getFloat64(field + 8, true);
+          if (tail) {
+            const link = new Uint8Array(8);
+            new DataView(link.buffer).setFloat64(0, span, true);
+            await this.storage.write(tail, link);
+          } else row.setFloat64(field, span, true);
+          row.setFloat64(field + 8, span, true);
+          row.setFloat64(field + 16, pending + spanSize, true);
+        }
+        sourceOffset += spanSize;
+        pending += spanSize;
+        spanSize = 0;
+        bytes[13] = lace === 255 ? 1 : 0;
+        if (lace < 255) {
+          if (packet === 0) {
+            if (this.last) {
+              const link = new Uint8Array(8);
+              new DataView(link.buffer).setFloat64(0, position, true);
+              await this.storage.write(this.last, link);
+            } else this.first = position;
+            this.last = position;
+          }
+          packet++;
+          pending = 0;
+          completed = true;
+        }
+      }
+      if (completed && page.granule !== 0xffffffffffffffffn) row.setBigUint64(40, page.granule, true);
+      if (page.flags & 4) {
+        if (bytes[13]) throw new Error("Incomplete final Ogg packet");
+        bytes[12] = 1;
+        active--;
+      }
+      row.setFloat64(16, packet, true);
+      row.setFloat64(24, pending, true);
+      await this.storage.write(position, bytes);
+    }
+    if (!seen || active) throw new Error("Incomplete Ogg stream");
+    this.ready = true;
+  }
+  packet(first, size) {
+    const { storage, source, context } = this, check = this.check.bind(this);
+    let cached;
+    return { size, async read(offset, length) {
+      check();
+      if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || offset > size)
+        throw new RangeError("Invalid Ogg packet range");
+      const output = new Uint8Array(Math.min(length, size - offset, 16384));
+      let used = 0, steps = 0, position = cached && offset >= cached.start ? cached.position : first;
+      while (used < output.length) {
+        if (++steps % 256 === 0) {
+          await yieldTurn(context.signal);
+          check();
+        }
+        if (!position) throw new Error("Truncated Ogg packet index");
+        if (!cached || position !== cached.position) {
+          const bytes = await storage.read(position, 32), row = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+          cached = { position, next: row.getFloat64(0, true), start: row.getFloat64(8, true), offset: row.getFloat64(16, true), length: row.getFloat64(24, true) };
+        }
+        if (offset >= cached.start + cached.length) {
+          position = cached.next;
+          continue;
+        }
+        if (offset < cached.start) throw new Error("Invalid Ogg packet index");
+        const take = Math.min(output.length - used, cached.start + cached.length - offset);
+        const chunk = await source.read(cached.offset + offset - cached.start, take);
+        check();
+        if (!chunk.length || chunk.length > take) throw new Error("Truncated Ogg packet source");
+        output.set(chunk, used);
+        used += chunk.length;
+        offset += chunk.length;
+      }
+      return output;
+    } };
+  }
+  async *streams(pageOrder = false) {
+    this.check();
+    if (!this.ready) throw new Error("Ogg index is not validated");
+    let steps = 0;
+    for (let position = pageOrder ? this.firstPage : this.first; position; ) {
+      if (++steps % 256 === 0) {
+        await yieldTurn(this.context.signal);
+        this.check();
+      }
+      const bytes = await this.storage.read(position, 128), row = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+      const packets = row.getFloat64(16, true);
+      yield {
+        group: row.getFloat64(120, true),
+        pageGranule: row.getBigUint64(112, true),
+        serial: row.getUint32(96, true),
+        size: row.getFloat64(32, true),
+        granule: row.getBigUint64(40, true),
+        packets,
+        head: packets ? this.packet(row.getFloat64(48, true), row.getFloat64(64, true)) : void 0,
+        comments: packets > 1 ? this.packet(row.getFloat64(72, true), row.getFloat64(88, true)) : void 0
+      };
+      position = row.getFloat64(pageOrder ? 104 : 0, true);
+    }
+  }
+};
+
+// packages/safe-bash-command-ffprobe/src/flac-tags.ts
+import { IntegerTable as IntegerTable2, PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+import { normalizeVorbisCommentKey } from "../../audio-ast/index.js";
+import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
+var FlacTags = class {
+  constructor(source, context, options = {}) {
+    this.source = source;
+    this.context = context;
+    this.options = options;
+    this.storage = new PagedStorage2(context, 4);
     this.close = this.storage.close.bind(this.storage);
-    this.keys = new IntegerTable(this.storage, 128);
-    this.numeric = new IntegerTable(this.storage, 128);
+    this.keys = new IntegerTable2(this.storage, 128);
+    this.numeric = new IntegerTable2(this.storage, 128);
   }
   source;
   context;
+  options;
   storage;
   keys;
   numeric;
   head = 0;
   tail = 0;
+  work = 0;
   count = 0;
   close;
-  async *decoded(offset, length) {
-    const decoder = new TextDecoder();
+  async read(offset, length) {
+    this.context.signal.throwIfAborted();
+    const bytes = await this.source.read(offset, length);
+    this.context.signal.throwIfAborted();
+    if (bytes.length !== length) throw new Error("Truncated FLAC comment");
+    return bytes;
+  }
+  async *decoded(offset, length, ignoreBOM, stored = false) {
+    const decoder = new TextDecoder("utf-8", { ignoreBOM });
     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);
+      yield decoder.decode(await (stored ? this.storage.read(offset + at, Math.min(16384, length - at)) : this.read(offset + at, Math.min(16384, length - at))), { stream: true });
+      if (++steps % 256 === 0) await yieldTurn2(this.context.signal);
     }
     yield decoder.decode();
   }
+  async record(position) {
+    const bytes = await this.storage.read(position, 64), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+    return Array.from({ length: 8 }, (_, i) => view.getFloat64(i * 8, true));
+  }
+  async write(position, values) {
+    const bytes = new Uint8Array(values.length * 8), view = new DataView(bytes.buffer);
+    values.forEach((value, i) => view.setFloat64(i * 8, value, true));
+    await this.storage.write(position, bytes);
+  }
+  async equal(a, b, units) {
+    for (let at = 0; at < units * 2; at += 16384) {
+      const size = Math.min(16384, units * 2 - at), left = await this.storage.read(a + at, size), right = await this.storage.read(b + at, size);
+      if (!left.every((value, i) => value === right[i])) return false;
+    }
+    return true;
+  }
+  async *keyText(position, units) {
+    let pending = "";
+    for (let at = 0; at < units; at += 8192) {
+      const bytes = await this.storage.read(position + at * 2, Math.min(8192, units - at) * 2), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+      let text = pending;
+      pending = "";
+      for (let i = 0; i < bytes.length; i += 2) text += String.fromCharCode(view.getUint16(i, true));
+      const last = text.charCodeAt(text.length - 1);
+      if (last >= 55296 && last <= 56319) {
+        pending = text.slice(-1);
+        text = text.slice(0, -1);
+      }
+      if (text) yield text;
+    }
+    if (pending) yield pending;
+  }
   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;
+    if (++this.work % 256 === 0) await yieldTurn2(this.context.signal);
+    let split = -1;
+    for (let at = 0; at < span.length; at += 16384) {
+      const bytes = await this.read(span.offset + at, Math.min(16384, span.length - at)), found = bytes.indexOf(61);
+      if (found >= 0) {
+        split = at + found;
+        break;
       }
-      if (zero >= 0) break;
+      if ((at / 16384 + 1) % 256 === 0) await yieldTurn2(this.context.signal);
     }
-    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));
+    if (split <= 0) return;
+    let keyPosition = this.storage.allocate(0), units = 0, hash = 2166136261, short = "";
+    const appendKey = async (text) => {
+      for (let at = 0; at < text.length; at += 8192) {
+        const part = text.slice(at, at + 8192), bytes = new Uint8Array(part.length * 2), view = new DataView(bytes.buffer);
+        for (let i = 0; i < part.length; i++) {
+          const code = part.charCodeAt(i);
+          view.setUint16(i * 2, code, true);
+          hash = Math.imul(hash ^ code, 16777619) >>> 0;
+        }
+        await this.storage.append(bytes);
+        units += part.length;
+        if (short.length <= 20) short += part.slice(0, 21 - short.length);
+      }
+    };
+    for await (const part of this.decoded(span.offset, split, false)) await appendKey(this.options.raw ? part : part.toUpperCase());
+    if (!units) return;
+    if (this.options.raw && short === "__proto__" && units === 9) return;
+    if (!this.options.raw && units <= 12) {
+      const normalized = normalizeVorbisCommentKey(short);
+      if (normalized !== short) {
+        keyPosition = this.storage.allocate(0);
+        units = 0;
+        hash = 2166136261;
+        short = "";
+        await appendKey(normalized);
+      }
+    }
+    const first = await this.keys.get(BigInt(hash));
+    let existing = 0, row;
+    for (let position2 = Number(first ?? 0n); position2; ) {
+      const candidate = await this.record(position2);
+      if (candidate[3] === units && await this.equal(candidate[2], keyPosition, units)) {
+        existing = position2;
+        row = candidate;
+        break;
+      }
+      position2 = candidate[1];
+    }
+    const position = existing || this.storage.allocate(64);
+    row ??= [0, Number(first ?? 0n), keyPosition, units, span.block, 0, 0, 0];
+    if (this.options.raw && !existing && units <= 20 && Object.hasOwn(Object.prototype, short)) {
+      const literal = new TextEncoder().encode(String(Reflect.get(Object.prototype, short))), offset2 = await this.storage.append(literal), value2 = this.storage.allocate(32);
+      await this.write(value2, [0, offset2, literal.length, 2]);
+      row[5] = value2;
+      row[6] = value2;
+      row[7] = literal.length ? 1 : 0;
+    }
+    const append = row[4] === span.block && !!row[7], value = this.storage.allocate(32), offset = span.offset + split + 1, length = span.length - split - 1;
+    await this.write(value, [0, offset, length, append ? 1 : 0]);
+    if (append) await this.write(row[6], [value]);
+    else row[5] = value;
+    row[4] = span.block;
+    row[6] = value;
+    row[7] = append || length > 0 ? 1 : 0;
+    await this.write(position, row);
+    if (existing) return;
+    await this.keys.set(BigInt(hash), 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));
+    const numeric = units <= 10 ? Number(short) : NaN;
+    if (Number.isInteger(numeric) && numeric >= 0 && numeric < 4294967295 && String(numeric) === short) 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;
+      if (this.tail) await this.write(this.tail, [position]);
+      else this.head = position;
       this.tail = position;
     }
   }
-  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;
-      }
-    } };
+  async *valueText(value) {
+    while (value) {
+      const bytes = await this.storage.read(value, 32), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+      const kind = view.getFloat64(24, true);
+      if (kind === 1) yield this.options.raw ? ";" : "\n";
+      yield* this.decoded(view.getFloat64(8, true), view.getFloat64(16, true), true, kind === 2);
+      value = view.getFloat64(0, true);
+    }
+  }
+  async entry(position) {
+    const row = await this.record(position);
+    return { next: row[0], key: () => this.keyText(row[2], row[3]), text: () => this.valueText(row[5]) };
   }
   async *entries() {
-    for await (const [, position] of this.numeric.entries()) yield await this.record(Number(position));
+    for await (const [, position] of this.numeric.entries()) yield await this.entry(Number(position));
     for (let position = this.head; position; ) {
-      const entry = await this.record(position);
+      const entry = await this.entry(position);
       position = entry.next;
       yield entry;
     }
@@ -286,9 +547,277 @@ function formatAudioProbe(audio, size, parsed) {
   return lines.length ? lines.join("\n") + "\n" : "";
 }
 
+// packages/safe-bash-command-ffprobe/src/ogg-probe.ts
+async function validatePictures(text) {
+  let quartet = "", line = false, ended = false, count = 0, word = 0, stage = 0, mark = 8;
+  const decode = () => {
+    const decoded = atob(quartet);
+    ended ||= quartet.includes("=");
+    quartet = "";
+    for (let i = 0; i < decoded.length; i++) {
+      count++;
+      word = (word << 8 | decoded.charCodeAt(i)) >>> 0;
+      if (stage === 3 && count > mark) throw new Error("Trailing FLAC picture bytes");
+      if (count === mark && stage < 3) {
+        mark += word + (stage === 0 ? 4 : stage === 1 ? 20 : 0);
+        stage++;
+      }
+    }
+  };
+  const finish = () => {
+    if (line) {
+      if (quartet) decode();
+      if (stage !== 3 || count !== mark) throw new Error("Truncated or invalid audio structure");
+    }
+    quartet = "";
+    line = false;
+    ended = false;
+    count = 0;
+    word = 0;
+    stage = 0;
+    mark = 8;
+  };
+  for await (const part of text) for (const char of part) {
+    if (char === "\n") {
+      finish();
+      continue;
+    }
+    line = true;
+    if (char === " " || char === "	" || char === "\r" || char === "\f") continue;
+    if (ended) throw new Error("Invalid character");
+    quartet += char;
+    if (quartet.length >= 4) decode();
+  }
+  finish();
+}
+async function probeStoredOgg(source, context, retain) {
+  const index = new OggIndex(source, context);
+  retain(index.close);
+  await index.scan();
+  let count = 0, group = 0, groupDuration = 0, duration = 0, adjustment = 0;
+  let first, pictures, failed = true;
+  try {
+    const physical = index.streams(true);
+    for await (const stream of index.streams()) {
+      const page = (await physical.next()).value;
+      if (!stream.head || !page) throw new Error("Ogg input contains no audio stream");
+      let current, currentFailed = true;
+      try {
+        const audio = await probeOggStreamSource({ head: stream.head, comments: stream.comments, granule: stream.granule, size: stream.size }, {
+          signal: context.signal,
+          onComment: async (span) => {
+            const prefix = new TextDecoder().decode(await stream.comments.read(span.offset, Math.min(128, span.length))), equals = prefix.indexOf("=");
+            context.signal.throwIfAborted();
+            if (equals > 0 && prefix.slice(0, equals).toUpperCase() === "METADATA_BLOCK_PICTURE") {
+              current ??= new FlacTags(stream.comments, context);
+              await current.add({ ...span, block: 0 });
+            }
+          }
+        });
+        first ??= audio;
+        count++;
+        if (stream.group !== group) {
+          duration += groupDuration;
+          groupDuration = 0;
+          group = stream.group;
+        }
+        groupDuration = Math.max(groupDuration, audio.duration);
+        if (audio.codec === "opus") adjustment = Math.max(adjustment, Number(page.pageGranule) / audio.sampleRate - audio.duration);
+        if (current) {
+          const previous = pictures;
+          pictures = current;
+          current = void 0;
+          await previous?.close();
+        }
+        currentFailed = false;
+      } finally {
+        if (current) {
+          if (currentFailed) {
+            try {
+              await current.close();
+            } catch {
+            }
+          } else await current.close();
+        }
+      }
+    }
+    if (!first || !(await physical.next()).done) throw new Error("Ogg input contains no audio stream");
+    for await (const entry of pictures?.entries() ?? []) await validatePictures(entry.text());
+    failed = false;
+  } finally {
+    if (pictures) {
+      if (failed) {
+        try {
+          await pictures.close();
+        } catch {
+        }
+      } else await pictures.close();
+    }
+  }
+  duration += groupDuration + adjustment;
+  const firstStream = first;
+  return { first: firstStream, rows: async function* (args) {
+    const parsed = parseArguments(args), streamSections = new Map([...parsed.sections].filter(([key]) => key === "stream" || key === "stream_tags"));
+    if (streamSections.size) {
+      let number = 0;
+      const physical = index.streams(true);
+      for await (const stream of index.streams()) {
+        const page = (await physical.next()).value;
+        if (parsed.selector && number !== 0) {
+          number++;
+          continue;
+        }
+        const tags = new FlacTags(stream.comments, context, { raw: true });
+        let failed2 = true;
+        try {
+          const audio = await probeOggStreamSource({ head: stream.head, comments: stream.comments, granule: stream.granule, size: stream.size }, {
+            signal: context.signal,
+            onComment: (span) => tags.add({ ...span, block: 0 })
+          });
+          for (const entry of audioProbeRows({
+            format: "ogg",
+            tags: {},
+            duration: audio.duration,
+            bitrate: audio.bitrate,
+            streams: [{ ...audio, tags: tags.count ? { "": "" } : {} }],
+            nodes: [{ type: "OggS", offset: 0, size: 0, data: new Uint8Array(0), fields: { serial: page.serial, granule: page.pageGranule } }]
+          }, source.size, { ...parsed, sections: streamSections })) {
+            if ("index" in entry.row) entry.row.index = number;
+            yield { ...entry, tags };
+          }
+          failed2 = false;
+        } finally {
+          if (failed2) {
+            try {
+              await tags.close();
+            } catch {
+            }
+          } else await tags.close();
+        }
+        number++;
+      }
+    }
+    const formatSections = new Map([...parsed.sections].filter(([key]) => key === "format" || key === "format_tags"));
+    for (const entry of audioProbeRows({ format: "ogg", streams: [firstStream], tags: {}, nodes: [], duration, bitrate: duration ? source.size * 8 / duration : 0 }, source.size, { ...parsed, sections: formatSections })) {
+      if ("nb_streams" in entry.row) entry.row.nb_streams = count;
+      yield entry;
+    }
+  } };
+}
+
+// packages/safe-bash-command-ffprobe/src/media.ts
+import { yieldTurn as yieldTurn6 } from "../../safe-bash-contracts/yield.js";
+
+// packages/safe-bash-command-ffprobe/src/source-tags.ts
+import { IntegerTable as IntegerTable3, PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
+import { readId3Text } from "../../audio-ast/index.js";
+import { yieldTurn as yieldTurn3 } from "../../safe-bash-contracts/yield.js";
+var SourceAudioTags = class {
+  constructor(source, context) {
+    this.source = source;
+    this.context = context;
+    this.storage = new PagedStorage3(context, 4);
+    this.close = this.storage.close.bind(this.storage);
+    this.keys = new IntegerTable3(this.storage, 128);
+    this.numeric = new IntegerTable3(this.storage, 128);
+  }
+  source;
+  context;
+  storage;
+  keys;
+  numeric;
+  head = 0;
+  tail = 0;
+  count = 0;
+  close;
+  async *decoded(offset, length, encoding = 255, unsynchronized = false) {
+    if (encoding < 4) {
+      yield* readId3Text(this.source, { key: "", offset, length, encoding, unsynchronized }, { signal: this.context.signal, checkpoint: () => yieldTurn3(this.context.signal) });
+      return;
+    }
+    const decoder = new TextDecoder();
+    let steps = 0;
+    for (let at = 0; at < length; at += 16384) {
+      this.context.signal.throwIfAborted();
+      const bytes = await (encoding === 254 ? this.storage : 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 audio tag");
+      yield decoder.decode(bytes, { stream: true });
+      if (++steps % 256 === 0) await yieldTurn3(this.context.signal);
+    }
+    yield decoder.decode();
+  }
+  async add(tag) {
+    const literal = "value" in tag ? new TextEncoder().encode(tag.value) : void 0;
+    const span = "value" in tag ? { key: tag.key, offset: await this.storage.append(literal), length: literal.length } : tag;
+    const encoding = literal ? 254 : "encoding" in tag ? tag.encoding : 255;
+    const unsynchronized = "unsynchronized" in tag && tag.unsynchronized;
+    let units = 0, kept = 0;
+    for await (const text of this.decoded(span.offset, span.length, encoding, unsynchronized)) {
+      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;
+      }
+      if (zero >= 0) break;
+    }
+    let key = 0n;
+    for (let i = 0; i < span.key.length; i++) key = key << (span.key.length > 4 ? 5n : 16n) | BigInt(span.key.length > 4 ? span.key.charCodeAt(i) & 31 : 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(64) : Number(existing);
+    const bytes = existing === void 0 ? new Uint8Array(64) : await this.storage.read(position, 64);
+    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);
+    bytes[56] = encoding;
+    bytes[57] = unsynchronized ? 1 : 0;
+    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;
+    }
+  }
+  async record(position) {
+    const bytes = await this.storage.read(position, 64), 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), encoding = bytes[56], unsynchronized = !!bytes[57];
+    return { key, next: view.getFloat64(0, true), async *text() {
+      let remaining = kept;
+      if (!remaining) return;
+      for await (const part of decoded(offset, length, encoding, unsynchronized)) {
+        const take = Math.min(remaining, part.length);
+        if (take) yield part.slice(0, take);
+        remaining -= take;
+        if (!remaining) return;
+      }
+    } };
+  }
+  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;
+    }
+  }
+};
+
 // packages/safe-bash-command-ffprobe/src/tag-format.ts
-async function* parts(value, prefix = "") {
-  if (prefix) yield prefix;
+async function* parts(value) {
   if (typeof value === "function") yield* value();
   else yield String(value);
 }
@@ -343,11 +872,34 @@ async function needsQuotes(input, separator) {
   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);
+  const parsed = parseArguments(args), rows = audioProbeRows({ ...audio, nodes: audio.nodes ?? [] }, size, parsed, tags.count > 0);
+  yield* formatTaggedRows((async function* () {
+    for (const row of rows) yield { ...row, tags };
+  })(), args);
+}
+async function* formatTaggedRows(rows, args) {
+  const { sections, format, settings } = parseArguments(args);
+  let tags;
   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 };
+    for await (const entry of tags?.entries() ?? []) {
+      let included = selected === void 0;
+      for (const wanted of selected ?? []) {
+        let at = 0, matches = true;
+        for await (const part of parts(entry.key)) {
+          if (wanted.slice(at, at + part.length) !== part) {
+            matches = false;
+            break;
+          }
+          at += part.length;
+        }
+        if (matches && at === wanted.length) {
+          included = true;
+          break;
+        }
+      }
+      if (included) yield { key: entry.key, value: entry.text };
+    }
   }
   async function* jsonRow(row, section, indent) {
     yield "{";
@@ -359,8 +911,10 @@ async function* formatTaggedAudio(audio, size, args, tags) {
         yield "{";
         let firstTag = true;
         for await (const field of tagFields(section)) {
-          yield (firstTag ? "\n" : ",\n") + " ".repeat(indent + 8) + JSON.stringify(field.key) + ": ";
+          yield (firstTag ? "\n" : ",\n") + " ".repeat(indent + 8);
           firstTag = false;
+          yield* jsonString(parts(field.key));
+          yield ": ";
           yield* jsonString(parts(field.value));
         }
         yield (firstTag ? "" : "\n" + " ".repeat(indent + 4)) + "}";
@@ -371,23 +925,29 @@ async function* formatTaggedAudio(audio, size, args, tags) {
   }
   if (format === "json") {
     yield "{";
-    let first = true;
-    if (sections.has("stream") || sections.has("stream_tags")) {
+    let first = true, streamOpen = sections.has("stream") || sections.has("stream_tags"), firstStream = true;
+    if (streamOpen) {
       yield '\n    "streams": [';
       first = false;
-      let firstStream = true;
-      for (const { section, row } of rows) if (section === "stream") {
+    }
+    for await (const entry of rows) {
+      const { section, row } = entry;
+      tags = entry.tags;
+      if (section === "stream") {
         yield (firstStream ? "\n" : ",\n") + "        ";
         firstStream = false;
         yield* jsonRow(row, section, 8);
+      } else if (section === "format") {
+        if (streamOpen) {
+          yield (firstStream ? "" : "\n    ") + "]";
+          streamOpen = false;
+        }
+        yield (first ? "\n" : ",\n") + '    "format": ';
+        first = false;
+        yield* jsonRow(row, section, 4);
       }
-      yield (firstStream ? "" : "\n    ") + "]";
-    }
-    for (const { section, row } of rows) if (section === "format") {
-      yield (first ? "\n" : ",\n") + '    "format": ';
-      first = false;
-      yield* jsonRow(row, section, 4);
     }
+    if (streamOpen) yield (firstStream ? "" : "\n    ") + "]";
     yield (first ? "" : "\n") + "}\n";
     return;
   }
@@ -396,11 +956,13 @@ async function* formatTaggedAudio(audio, size, args, tags) {
     return value === void 0 ? fallback : value === "1";
   };
   let streamIndex = 0;
-  for (const { section, row } of rows) {
+  for await (const entry of rows) {
+    const { section, row } = entry;
+    tags = entry.tags;
     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 };
+          for await (const tag of tagFields(section)) yield { key: tag.key, value: tag.value, tag: true };
         } else yield { key, value };
       }
     }
@@ -414,19 +976,28 @@ async function* formatTaggedAudio(audio, size, args, tags) {
       for await (const field of fields()) {
         if (!first) yield separator;
         first = false;
-        const prefix = enabled("nokey", "nk", format === "csv") ? "" : field.key + "=";
+        async function* value() {
+          if (!enabled("nokey", "nk", format === "csv")) {
+            if (field.tag) yield "tag:";
+            yield* parts(field.key);
+            yield "=";
+          }
+          yield* parts(field.value);
+        }
         if (format === "csv") {
-          const quote = await needsQuotes(parts(field.value, prefix), separator);
+          const quote = await needsQuotes(value(), separator);
           if (quote) yield '"';
-          yield* quote ? replace(parts(field.value, prefix), '"', '""') : parts(field.value, prefix);
+          yield* quote ? replace(value(), '"', '""') : value();
           if (quote) yield '"';
-        } else yield* replace(replace(replace(replace(parts(field.value, prefix), "\\", "\\\\"), "\n", "\\n"), "\r", "\\r"), separator, "\\" + separator);
+        } else yield* replace(replace(replace(replace(value(), "\\", "\\\\"), "\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) + "=";
+        yield prefix + "." + (field.tag ? "tags." : "");
+        yield* parts(field.key);
+        yield "=";
         if (typeof field.value === "number") yield String(field.value);
         else yield* jsonString(parts(field.value));
         yield "\n";
@@ -434,7 +1005,11 @@ async function* formatTaggedAudio(audio, size, args, tags) {
     } 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) + "=";
+        if (!enabled("nokey", "nk", false)) {
+          if (field.tag) yield "TAG:";
+          yield* parts(field.key);
+          yield "=";
+        }
         yield* parts(field.value);
         yield "\n";
       }
@@ -444,9 +1019,9 @@ async function* formatTaggedAudio(audio, size, args, tags) {
 }
 
 // packages/safe-bash-command-ffprobe/src/probe-output.ts
-import { PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage4 } from "@poe-platform/safe-fs/storage";
 import { writeBytes } from "../../safe-bash-contracts/io.js";
-import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
+import { yieldTurn as yieldTurn4 } from "../../safe-bash-contracts/yield.js";
 async function* encodeParts(parts2, signal) {
   const encoder = new TextEncoder();
   let high = "", steps = 0;
@@ -462,13 +1037,13 @@ async function* encodeParts(parts2, signal) {
         text = text.slice(0, -1);
       }
       if (text) yield encoder.encode(text);
-      if (++steps % 256 === 0) await yieldTurn2(signal);
+      if (++steps % 256 === 0) await yieldTurn4(signal);
     }
   }
   if (high) yield encoder.encode(high);
 }
 async function writeProbeOutput(context, parts2, check, beforePublish) {
-  const storage = new PagedStorage2(context, 4), start = storage.allocate(0);
+  const storage = new PagedStorage4(context, 4), start = storage.allocate(0);
   let size = 0, failed = true;
   try {
     for await (const bytes of encodeParts(parts2, context.signal)) {
@@ -494,10 +1069,10 @@ async function writeProbeOutput(context, parts2, check, beforePublish) {
 }
 
 // packages/safe-bash-command-ffprobe/src/stream-input.ts
-import { PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage5 } 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";
+import { yieldTurn as yieldTurn5 } from "../../safe-bash-contracts/yield.js";
 async function openProbeStream(context, path) {
   context.signal.throwIfAborted();
   if (path === void 0) return readBytes(context.stdin, context.signal);
@@ -569,7 +1144,7 @@ async function sniffMediaStream(source, signal, account) {
   return { prefix: prefix.subarray(0, size), stream: replay() };
 }
 async function withStagedProbeSource(context, input, probe2, retain) {
-  const storage = new PagedStorage3(context, 4);
+  const storage = new PagedStorage5(context, 4);
   retain?.(storage.close.bind(storage));
   let start;
   let size = 0, steps = 0, failed = true;
@@ -579,7 +1154,7 @@ async function withStagedProbeSource(context, input, probe2, retain) {
       size += chunk.length;
       start ??= storage.allocate(0);
       await storage.append(chunk);
-      if (++steps % 256 === 0) await yieldTurn3(context.signal);
+      if (++steps % 256 === 0) await yieldTurn5(context.signal);
     }
     context.signal.throwIfAborted();
     start ??= storage.allocate(0);
@@ -601,7 +1176,7 @@ async function withStagedProbeSource(context, input, probe2, retain) {
 }
 
 // packages/safe-bash-command-ffprobe/src/media.ts
-import { probeWavSource } from "../../audio-ast/index.js";
+import { probeWavSource, probeFlacSource, probeMp3Source } from "../../audio-ast/index.js";
 import { commandRuntimeIdentity, getCommandArguments } from "../../safe-bash-contracts/command.js";
 import { readBytes as readBytes2, writeBytes as writeBytes2 } from "../../safe-bash-contracts/io.js";
 function isStdin(path) {
@@ -779,7 +1354,7 @@ function* formatFfprobeResultChunks(probe2, opts, audioInput) {
   if (audioInput && !opts.showPackets && !opts.showFrames && !opts.showChapters && !opts.showPrograms && !opts.countFrames && !opts.countPackets && probe2.streams.length > 0 && probe2.streams.every((stream) => stream.codec_type === "audio")) {
     let formatted;
     try {
-      formatted = "bytes" in audioInput ? probe(audioInput.bytes, audioInput.args) : formatAudioProbe({ ...audioInput.audio, nodes: [] }, audioInput.size, parseArguments(audioInput.args));
+      formatted = "bytes" in audioInput ? probe(audioInput.bytes, audioInput.args) : formatAudioProbe({ ...audioInput.audio, nodes: audioInput.audio.nodes ?? [] }, audioInput.size, parseArguments(audioInput.args));
     } catch {
     }
     if (formatted !== void 0) {
@@ -1125,19 +1700,44 @@ async function probeSourceMetadata(context, plugins, input, filename, budget, re
     plugin = plugins.find((candidate) => candidate.detect(header, filename));
   }
   if (!plugin) return void 0;
+  if (plugin.formatName === "ogg" && !plugin.probeMetadata) {
+    const probeOptions = { ...records, filename, signal: context.signal, budget, limits: budget.limits, checkpoint: () => yieldTurn6(context.signal) };
+    const flac = await probeOggFlacSource(source, probeOptions);
+    if (flac) return flac;
+    const ogg = await probeStoredOgg(source, context, retain);
+    return onAudio ? { oggRows: ogg.rows } : probeOggStreamMetadata(ogg.first, source.size, probeOptions);
+  }
   const result = await plugin.probeMetadata(source, { ...records, filename, signal: context.signal, budget, limits: budget.limits });
   if (onAudio) {
-    const tags = new WavTags(source, context);
+    const tags = plugin.formatName === "flac" ? new FlacTags(source, context) : new SourceAudioTags(source, context);
     retain(tags.close);
+    let checkpoints = 0;
     try {
-      onAudio(await probeWavSource(source, { signal: context.signal, onTag: async (span) => {
+      const audio = tags instanceof FlacTags ? await probeFlacSource(source, { signal: context.signal, onComment: async (span) => {
+        try {
+          await tags.add(span);
+        } catch (error) {
+          sourceFailed = true;
+          throw error;
+        }
+      } }) : plugin.formatName === "mp3" ? await probeMp3Source(source, { signal: context.signal, checkpoint: async () => {
+        if (++checkpoints % 256 === 0) await yieldTurn6(context.signal);
+      }, onTag: async (span) => {
+        try {
+          await tags.add(span);
+        } catch (error) {
+          sourceFailed = true;
+          throw error;
+        }
+      } }) : await probeWavSource(source, { signal: context.signal, onTag: async (span) => {
         try {
           await tags.add(span);
         } catch (error) {
           sourceFailed = true;
           throw error;
         }
-      } }), input.size, tags);
+      } });
+      onAudio(audio, input.size, tags);
     } catch (error) {
       context.signal.throwIfAborted();
       if (sourceFailed) throw error;
@@ -1282,9 +1882,9 @@ function createFfprobeCommand(options = {}) {
             automaticAudio = false;
           }
         }
-        const automaticPlugins = !options.asts && !explicitFormat ? astPlugins.filter((plugin) => plugin.canDemux && plugin.probeMetadata && (!automaticAudio || plugin === registry.findByFormatName("wav"))) : [];
+        const automaticPlugins = !options.asts && !explicitFormat ? astPlugins.filter((plugin) => plugin.canDemux && (plugin.probeMetadata || plugin === registry.findByFormatName("ogg")) && (!automaticAudio || ["wav", "flac", "mp3", "ogg"].some((format) => plugin === registry.findByFormatName(format)))) : [];
         const explicitPlugin = explicitFormat ? registry.findByFormatName(explicitFormat) : void 0;
-        const retainedPlugins = explicitPlugin ? explicitPlugin.canDemux && explicitPlugin.probeMetadata ? [explicitPlugin] : [] : automaticPlugins;
+        const retainedPlugins = explicitPlugin ? explicitPlugin.canDemux && (explicitPlugin.probeMetadata || !options.asts && explicitPlugin === registry.findByFormatName("ogg")) ? [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 };
           storedTags = tags;
@@ -1292,14 +1892,15 @@ function createFfprobeCommand(options = {}) {
         if (!probeResult && explicitPlugin)
           probeResult = await probeStreamMetadata(context, explicitPlugin, inputTarget, budget, { showPackets, showFrames });
         let replay;
-        if (!probeResult && automaticPlugins.length) {
+        const streamPlugins = explicitPlugin ? retainedPlugins : automaticPlugins;
+        if (!probeResult && streamPlugins.length) {
           const source = await openProbeStream(context, isStdin(inputTarget) ? void 0 : resolvePath(context.cwd, inputTarget));
           if (source) {
             const sniffed = await sniffMediaStream(source, context.signal, (total) => {
               context.inputBudget?.check(total);
               budget.checkInputBytes(total);
             });
-            const automaticPlugin = automaticPlugins.find((plugin) => plugin.detect(sniffed.prefix, inputTarget));
+            const automaticPlugin = explicitPlugin ?? streamPlugins.find((plugin) => plugin.detect(sniffed.prefix, inputTarget));
             if (automaticPlugin) {
               if (!automaticAudio && automaticPlugin.probeMetadataStream) {
                 probeResult = await automaticPlugin.probeMetadataStream(sniffed.stream, {
@@ -1342,7 +1943,7 @@ function createFfprobeCommand(options = {}) {
           });
           if (!options.asts && !explicitFormat) audioInput = { bytes, args };
         }
-        const formatted = storedTags && audioInput && "audio" in audioInput ? formatTaggedAudio(audioInput.audio, audioInput.size, audioInput.args, storedTags) : formatFfprobeResultChunks(probeResult, {
+        const formatted = "oggRows" in probeResult ? formatTaggedRows(probeResult.oggRows(args), args) : storedTags && audioInput && "audio" in audioInput ? formatTaggedAudio(audioInput.audio, audioInput.size, audioInput.args, storedTags) : formatFfprobeResultChunks(probeResult, {
           printFormat,
           showFormat,
           showStreams,