@poe-platform/safe-bash 0.1.811 → 0.1.812

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

@@ -7,12 +7,13 @@ import {
   createMediaAstRegistry,
   encodeUtf8,
   parseStreamingManifest
-} from "./chunk-VU3EQF7F.js";
+} from "./chunk-2JSDKQ4J.js";
 
-// packages/safe-bash-command-ffprobe/src/wav-tags.ts
+// packages/safe-bash-command-ffprobe/src/flac-tags.ts
 import { IntegerTable, PagedStorage } from "@poe-platform/safe-fs/storage";
+import { normalizeVorbisCommentKey } from "../../audio-ast/index.js";
 import { yieldTurn } from "../../safe-bash-contracts/yield.js";
-var WavTags = class {
+var FlacTags = class {
   constructor(source, context) {
     this.source = source;
     this.context = context;
@@ -28,6 +29,168 @@ var WavTags = class {
   numeric;
   head = 0;
   tail = 0;
+  work = 0;
+  count = 0;
+  close;
+  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) {
+    const decoder = new TextDecoder("utf-8", { ignoreBOM });
+    let steps = 0;
+    for (let at = 0; at < length; at += 16384) {
+      yield decoder.decode(await this.read(offset + at, Math.min(16384, length - at)), { stream: true });
+      if (++steps % 256 === 0) await yieldTurn(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) {
+    if (++this.work % 256 === 0) await yieldTurn(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 ((at / 16384 + 1) % 256 === 0) await yieldTurn(this.context.signal);
+    }
+    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 <= 12) short += part.slice(0, 13 - short.length);
+      }
+    };
+    for await (const part of this.decoded(span.offset, split, false)) await appendKey(part.toUpperCase());
+    if (!units) return;
+    if (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];
+    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 = 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) await this.write(this.tail, [position]);
+      else this.head = position;
+      this.tail = position;
+    }
+  }
+  async *valueText(value) {
+    while (value) {
+      const bytes = await this.storage.read(value, 32), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+      if (view.getFloat64(24, true)) yield "\n";
+      yield* this.decoded(view.getFloat64(8, true), view.getFloat64(16, true), true);
+      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.entry(Number(position));
+    for (let position = this.head; position; ) {
+      const entry = await this.entry(position);
+      position = entry.next;
+      yield entry;
+    }
+  }
+};
+
+// packages/safe-bash-command-ffprobe/src/wav-tags.ts
+import { IntegerTable as IntegerTable2, PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
+import { yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
+var WavTags = class {
+  constructor(source, context) {
+    this.source = source;
+    this.context = context;
+    this.storage = new PagedStorage2(context, 4);
+    this.close = this.storage.close.bind(this.storage);
+    this.keys = new IntegerTable2(this.storage, 128);
+    this.numeric = new IntegerTable2(this.storage, 128);
+  }
+  source;
+  context;
+  storage;
+  keys;
+  numeric;
+  head = 0;
+  tail = 0;
   count = 0;
   close;
   async *decoded(offset, length) {
@@ -39,7 +202,7 @@ var WavTags = class {
       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);
+      if (++steps % 256 === 0) await yieldTurn2(this.context.signal);
     }
     yield decoder.decode();
   }
@@ -287,8 +450,7 @@ function formatAudioProbe(audio, size, parsed) {
 }
 
 // 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);
 }
@@ -347,7 +509,24 @@ async function* formatTaggedAudio(audio, size, args, tags) {
   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 };
+    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 +538,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)) + "}";
@@ -400,7 +581,7 @@ async function* formatTaggedAudio(audio, size, args, 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 +595,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 +624,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 +638,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 PagedStorage3 } 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 yieldTurn3 } from "../../safe-bash-contracts/yield.js";
 async function* encodeParts(parts2, signal) {
   const encoder = new TextEncoder();
   let high = "", steps = 0;
@@ -462,13 +656,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 yieldTurn3(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 PagedStorage3(context, 4), start = storage.allocate(0);
   let size = 0, failed = true;
   try {
     for await (const bytes of encodeParts(parts2, context.signal)) {
@@ -494,10 +688,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 PagedStorage4 } 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 yieldTurn4 } 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 +763,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 PagedStorage4(context, 4);
   retain?.(storage.close.bind(storage));
   let start;
   let size = 0, steps = 0, failed = true;
@@ -579,7 +773,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 yieldTurn4(context.signal);
     }
     context.signal.throwIfAborted();
     start ??= storage.allocate(0);
@@ -601,7 +795,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 } 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) {
@@ -1127,17 +1321,25 @@ async function probeSourceMetadata(context, plugins, input, filename, budget, re
   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);
+    const tags = plugin.formatName === "flac" ? new FlacTags(source, context) : new WavTags(source, context);
     retain(tags.close);
     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;
+        }
+      } }) : 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,7 +1484,7 @@ 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 && (!automaticAudio || plugin === registry.findByFormatName("wav") || plugin === registry.findByFormatName("flac"))) : [];
         const explicitPlugin = explicitFormat ? registry.findByFormatName(explicitFormat) : void 0;
         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) => {

package/dist/safe-bash/command-chunks/{chunk-WH3TIOTS.js → chunk-ZEGNRZV2.js}

@@ -5,7 +5,7 @@ import { dirname, FsError, isFsError } from "../../safe-bash-contracts/index.js"
 import { host as host2, ToolError as ToolError2 } from "../../safe-bash-diff-engine/shared.js";
 
 // packages/safe-bash-command-patch/src/stored-target.ts
-import { PagedStorage } from "@poe-platform/safe-fs/storage";
+import { PagedStorage, PagedStorageCache } from "@poe-platform/safe-fs/storage";
 import { IndexedDocument, closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
 import { ToolError, host } from "../../safe-bash-diff-engine/shared.js";
 async function* targetBytes(line) {
@@ -84,11 +84,18 @@ async function equalTargetLines(left, right, budget, whitespace = false) {
 var TargetDocuments = class {
   constructor(budget) {
     this.budget = budget;
+    this.documentBudget = {
+      context: budget.context,
+      documentCache: new PagedStorageCache(16),
+      step: budget.step.bind(budget),
+      checkpoint: budget.checkpoint.bind(budget)
+    };
   }
   budget;
   documents = /* @__PURE__ */ new Set();
+  documentBudget;
   async load(source) {
-    const document = new IndexedDocument(this.budget, 2);
+    const document = new IndexedDocument(this.documentBudget, 2);
     this.documents.add(document);
     await document.load(source);
     if (document.binary) throw new ToolError("binary input is unsupported (NUL byte)");