@poe-platform/safe-bash 0.1.809 → 0.1.811

package/dist/safe-bash/command-chunks/{chunk-K35BSUHO.js → chunk-UYWSIIUX.js}

@@ -1,26 +1,26 @@
 import {
   attr
-} from "./chunk-ORZRWT62.js";
+} from "./chunk-56NYSX65.js";
 import {
   SelectionError,
   readSelectionIndex
-} from "./chunk-S4IIOSRA.js";
+} from "./chunk-X7FA7ZD5.js";
 import {
   readPackage
-} from "./chunk-SFCERNHU.js";
+} from "./chunk-XPD636C4.js";
 import {
   readBinary
-} from "./chunk-KMMAJ6H6.js";
+} from "./chunk-PNGDJA6M.js";
 import {
   equationOpaqueElements,
   interpretCompatibility
-} from "./chunk-6UHGIWFX.js";
+} from "./chunk-2ZFLMWOX.js";
 import {
   parseXmlPart
-} from "./chunk-5L6GHFRW.js";
+} from "./chunk-554Z6IKP.js";
 import {
   OfficeError
-} from "./chunk-KJ3PEDI2.js";
+} from "./chunk-Q73EMLLZ.js";
 
 // packages/safe-bash-presentation-engine/src/media.ts
 import { sha1 } from "@noble/hashes/legacy.js";

package/dist/safe-bash/command-chunks/{chunk-JJQ72P3V.js → chunk-VCML4T5D.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-7WIC7SFR.js";
 import {
   mediaCommands
-} from "./chunk-45FI2IPY.js";
+} from "./chunk-WQ6ABTJU.js";
 
 // packages/safe-bash-command-media/src/remote.ts
 import { readBytes } from "@poe-platform/safe-fs/core";

package/dist/safe-bash/command-chunks/{chunk-DCD32BEY.js → chunk-VU3EQF7F.js}

@@ -338357,8 +338357,98 @@ function mp3Ast() {
     }
   };
 }
+function flacDocument(bytes, byteLength, data = new Uint8Array()) {
+  let sampleRate = 44100;
+  let channels = 2;
+  let totalSamples = 44100;
+  if (bytes.byteLength >= 42 && decodeFourCC(bytes, 0) === "fLaC") {
+    const b18 = bytes[18];
+    const b19 = bytes[19];
+    const b20 = bytes[20];
+    sampleRate = b18 << 12 | b19 << 4 | b20 >>> 4 || 44100;
+    channels = (b20 >>> 1 & 7) + 1 || 2;
+    const b21 = bytes[21];
+    const view = new DataView(bytes.buffer, bytes.byteOffset + 22, 4);
+    totalSamples = (b21 & 15) * 4294967296 + view.getUint32(0, false) || 44100;
+  }
+  return {
+    containerFormat: "flac",
+    timescale: sampleRate,
+    duration: totalSamples,
+    durationSeconds: totalSamples / sampleRate,
+    tracks: [
+      {
+        id: 1,
+        type: "audio",
+        handlerType: "soun",
+        timescale: sampleRate,
+        duration: totalSamples,
+        language: "und",
+        enabled: true,
+        codecDescriptions: [
+          {
+            formatFourCC: "fLaC",
+            codecName: "flac",
+            sampleRate,
+            channels,
+            bitsPerSample: 16
+          }
+        ],
+        samples: [
+          {
+            data,
+            dts: 0,
+            pts: 0,
+            cts: 0,
+            duration: totalSamples,
+            size: byteLength,
+            isKeyframe: true,
+            sampleDescriptionIndex: 1
+          }
+        ]
+      }
+    ],
+    metadata: {},
+    byteLength
+  };
+}
 function flacAst() {
   return {
+    async probeMetadata(source, options = {}) {
+      options.signal?.throwIfAborted();
+      if (!Number.isSafeInteger(source.size) || source.size < 0) throw new RangeError("Invalid FLAC source size");
+      const header = new Uint8Array(Math.min(42, source.size));
+      for (let offset = 0; offset < header.length; ) {
+        const chunk = await source.read(offset, header.length - offset);
+        options.signal?.throwIfAborted();
+        if (!chunk.length) throw new Error("Unexpected end of FLAC source");
+        if (chunk.length > header.length - offset) throw new Error("FLAC source returned more bytes than requested");
+        header.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return buildProbeResultFromDoc(flacDocument(header, source.size), source.size, options.filename ?? "input.flac", {
+        ...options,
+        formatName: "flac",
+        formatLongName: "raw FLAC"
+      });
+    },
+    async probeMetadataStream(source, options = {}) {
+      options.signal?.throwIfAborted();
+      const header = new Uint8Array(42);
+      let size = 0;
+      for await (const chunk of source) {
+        options.signal?.throwIfAborted();
+        if (size < header.length) header.set(chunk.subarray(0, header.length - size), size);
+        size += chunk.length;
+        if (!Number.isSafeInteger(size)) throw new RangeError("Invalid FLAC source size");
+      }
+      options.signal?.throwIfAborted();
+      return buildProbeResultFromDoc(flacDocument(header.subarray(0, Math.min(size, header.length)), size), size, options.filename ?? "input.flac", {
+        ...options,
+        formatName: "flac",
+        formatLongName: "raw FLAC"
+      });
+    },
     id: "flac",
     formatName: "flac",
     formatLongName: "raw FLAC",
@@ -338376,59 +338466,7 @@ function flacAst() {
       return false;
     },
     parse(bytes) {
-      let sampleRate = 44100;
-      let channels = 2;
-      let totalSamples = 44100;
-      if (bytes.byteLength >= 42 && decodeFourCC(bytes, 0) === "fLaC") {
-        const b18 = bytes[18];
-        const b19 = bytes[19];
-        const b20 = bytes[20];
-        sampleRate = b18 << 12 | b19 << 4 | b20 >>> 4 || 44100;
-        channels = (b20 >>> 1 & 7) + 1 || 2;
-        const b21 = bytes[21];
-        const view = new DataView(bytes.buffer, bytes.byteOffset + 22, 4);
-        totalSamples = (b21 & 15) * 4294967296 + view.getUint32(0, false) || 44100;
-      }
-      return {
-        containerFormat: "flac",
-        timescale: sampleRate,
-        duration: totalSamples,
-        durationSeconds: totalSamples / sampleRate,
-        tracks: [
-          {
-            id: 1,
-            type: "audio",
-            handlerType: "soun",
-            timescale: sampleRate,
-            duration: totalSamples,
-            language: "und",
-            enabled: true,
-            codecDescriptions: [
-              {
-                formatFourCC: "fLaC",
-                codecName: "flac",
-                sampleRate,
-                channels,
-                bitsPerSample: 16
-              }
-            ],
-            samples: [
-              {
-                data: bytes,
-                dts: 0,
-                pts: 0,
-                cts: 0,
-                duration: totalSamples,
-                size: bytes.byteLength,
-                isKeyframe: true,
-                sampleDescriptionIndex: 1
-              }
-            ]
-          }
-        ],
-        metadata: {},
-        byteLength: bytes.byteLength
-      };
+      return flacDocument(bytes, bytes.byteLength, bytes);
     },
     serialize(doc) {
       return concatBytes(encodeFlacPackets(doc));

package/dist/safe-bash/command-chunks/{chunk-2E2YEDVB.js → chunk-W5YSINXC.js}

@@ -1,9 +1,9 @@
 import {
   readImages
-} from "./chunk-MWVFP2HY.js";
+} from "./chunk-GEM47B2P.js";
 import {
   admitImage
-} from "./chunk-UQ6UIZMM.js";
+} from "./chunk-QD7ZRDUN.js";
 import {
   attr,
   child,
@@ -11,18 +11,18 @@ import {
   loadShared,
   nextRel,
   relPart
-} from "./chunk-ORZRWT62.js";
+} from "./chunk-56NYSX65.js";
 import {
   SelectionError
-} from "./chunk-S4IIOSRA.js";
+} from "./chunk-X7FA7ZD5.js";
 import {
   asciiKey,
   partName,
   relativePartReference
-} from "./chunk-AXWPJRY6.js";
+} from "./chunk-36XGIPOG.js";
 import {
   OfficeError
-} from "./chunk-KJ3PEDI2.js";
+} from "./chunk-Q73EMLLZ.js";
 
 // packages/safe-bash-presentation-engine/src/image-replacement.ts
 function invalid(message) {

package/dist/safe-bash/command-chunks/{chunk-EYNT4OEJ.js → chunk-WGG6G2KG.js}

@@ -3,29 +3,29 @@ import {
   readShapePath,
   shapePathXml,
   validateShapePath
-} from "./chunk-COKZFXHG.js";
+} from "./chunk-FIIAYCWS.js";
 import {
   addShape,
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-6XVMWFHD.js";
+} from "./chunk-TW73OXPR.js";
 import {
   validateShapeOptions
-} from "./chunk-Z4QJMDK3.js";
+} from "./chunk-IT7TAC3F.js";
 import {
   Length
-} from "./chunk-Z54Z3KRN.js";
+} from "./chunk-6QBMND4A.js";
 import {
   loadShared,
   required
-} from "./chunk-ORZRWT62.js";
+} from "./chunk-56NYSX65.js";
 import {
   SelectionError
-} from "./chunk-S4IIOSRA.js";
+} from "./chunk-X7FA7ZD5.js";
 import {
   OfficeError
-} from "./chunk-KJ3PEDI2.js";
+} from "./chunk-Q73EMLLZ.js";
 
 // packages/safe-bash-presentation-engine/src/shape-path-operations.ts
 function optionsFor(options, adding = false) {

package/dist/safe-bash/command-chunks/chunk-WH3TIOTS.js

@@ -0,0 +1,326 @@
+// packages/safe-bash-command-patch/src/patch-publication.ts
+import { compareCopyIdentity } from "../../safe-bash-contracts/filesystem-identity.js";
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+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 { IndexedDocument, closeDocumentResources } from "../../safe-bash-diff-engine/document.js";
+import { ToolError, host } from "../../safe-bash-diff-engine/shared.js";
+async function* targetBytes(line) {
+  if (typeof line !== "string") {
+    const range = await line.document.line(line.index);
+    yield* line.document.range(range.start, range.end);
+    return;
+  }
+  for (let start = 0; start < line.length; ) {
+    let end = Math.min(start + 4096, line.length);
+    const last = line.charCodeAt(end - 1);
+    if (end < line.length && last >= 55296 && last <= 56319) end--;
+    yield new TextEncoder().encode(line.slice(start, end));
+    start = end;
+  }
+}
+async function* normalized(line, whitespace) {
+  if (!whitespace) {
+    yield* targetBytes(line);
+    return;
+  }
+  let pending = false, cr = false;
+  let output = [];
+  for await (const block of targetBytes(line)) {
+    for (const byte of block) {
+      if (cr) {
+        if (byte !== 10 && pending) output.push(32);
+        output.push(13);
+        cr = false;
+        pending = false;
+      }
+      if (byte === 32 || byte === 9) pending = true;
+      else if (byte === 13 && pending) cr = true;
+      else {
+        if (pending && byte !== 10) output.push(32);
+        pending = false;
+        output.push(byte);
+      }
+      if (output.length >= 4096) {
+        yield Uint8Array.from(output);
+        output = [];
+      }
+    }
+  }
+  if (cr) output.push(32, 13);
+  if (output.length) yield Uint8Array.from(output);
+}
+async function equalTargetLines(left, right, budget, whitespace = false) {
+  const a = normalized(left, whitespace)[Symbol.asyncIterator]();
+  const b = normalized(right, whitespace)[Symbol.asyncIterator]();
+  try {
+    let x = await a.next(), y = await b.next(), i = 0, j = 0;
+    while (!x.done && !y.done) {
+      const count = Math.min(x.value.length - i, y.value.length - j);
+      budget.step(count);
+      for (let k = 0; k < count; k++) if (x.value[i + k] !== y.value[j + k]) return false;
+      i += count;
+      j += count;
+      if (i === x.value.length) {
+        x = await a.next();
+        i = 0;
+      }
+      if (j === y.value.length) {
+        y = await b.next();
+        j = 0;
+      }
+      const checkpoint = budget.checkpoint();
+      if (checkpoint) await checkpoint;
+    }
+    return !!x.done && !!y.done;
+  } finally {
+    await a.return?.();
+    await b.return?.();
+  }
+}
+var TargetDocuments = class {
+  constructor(budget) {
+    this.budget = budget;
+  }
+  budget;
+  documents = /* @__PURE__ */ new Set();
+  async load(source) {
+    const document = new IndexedDocument(this.budget, 2);
+    this.documents.add(document);
+    await document.load(source);
+    if (document.binary) throw new ToolError("binary input is unsupported (NUL byte)");
+    if (!document.validUtf8) throw new ToolError("binary input is unsupported (invalid UTF-8)");
+    return document;
+  }
+  async read(path) {
+    const iterator = this.budget.diffSource(path);
+    const context = this.budget.context;
+    return this.load({ async *[Symbol.asyncIterator]() {
+      try {
+        for (; ; ) {
+          const next = await host(context, () => iterator.next());
+          if (next.done) break;
+          yield next.value;
+        }
+      } finally {
+        const closed = iterator.return(void 0);
+        if (context.signal.aborted) void closed.catch(() => {
+        });
+        else await closed;
+      }
+    } });
+  }
+  async concat(left, right) {
+    return this.load({ async *[Symbol.asyncIterator]() {
+      yield* left.range(0, left.size);
+      yield* right.range(0, right.size);
+    } });
+  }
+  async release(document) {
+    await document.close();
+    this.documents.delete(document);
+  }
+  close() {
+    return closeDocumentResources([...this.documents]);
+  }
+};
+var TargetOutput = class {
+  constructor(documents) {
+    this.documents = documents;
+    this.data = new PagedStorage(documents.budget.context, 2);
+  }
+  documents;
+  data;
+  size = 0;
+  unterminated = false;
+  length = 0;
+  async append(line) {
+    if (this.unterminated) await this.write(new Uint8Array([10]));
+    this.unterminated = false;
+    for await (const bytes of targetBytes(line)) {
+      await this.write(bytes);
+      this.unterminated = bytes.at(-1) !== 10;
+    }
+    this.length++;
+  }
+  async write(bytes) {
+    this.size += bytes.length;
+    if (this.size > this.documents.budget.limits.maxOutputBytes) throw new ToolError("output byte limit exceeded");
+    await this.data.append(bytes);
+  }
+  async finish() {
+    const data = this.data, size = this.size;
+    this.documents.budget.outputLength(size);
+    return this.documents.load({ async *[Symbol.asyncIterator]() {
+      for (let offset = 0; offset < size; offset += 16384) yield await data.read(8 + offset, Math.min(16384, size - offset));
+    } });
+  }
+  close() {
+    return this.data.close();
+  }
+};
+
+// packages/safe-bash-command-patch/src/patch-publication.ts
+import { readBytes } from "../../safe-bash-contracts/index.js";
+var PatchPublication = class {
+  constructor(context, trusted = false) {
+    this.context = context;
+    this.trusted = trusted;
+  }
+  context;
+  trusted;
+  directories = /* @__PURE__ */ new Map();
+  removals = /* @__PURE__ */ new Map();
+  pruning = /* @__PURE__ */ new Map();
+  async capture(path, prune = []) {
+    const paths = [];
+    for (let parent = dirname(path); ; parent = dirname(parent)) {
+      paths.unshift(parent);
+      if (parent === "/") break;
+    }
+    for (const parent of paths) {
+      if (this.directories.has(parent)) continue;
+      let stat;
+      try {
+        stat = await host2(this.context, () => this.context.fs.lstat(parent, { signal: this.context.signal }));
+      } catch (error) {
+        if (isFsError(error, "ENOENT")) break;
+        throw error;
+      }
+      if (stat.type !== "directory") throw new ToolError2(`unsafe patch parent: ${parent}`);
+      this.directories.set(parent, stat);
+    }
+    if (this.trusted) return;
+    if (this.directories.has(dirname(path)) && !this.removals.has(path)) {
+      this.removals.set(path, await host2(this.context, () => this.context.fs.confineExtraction([dirname(path)], { signal: this.context.signal })));
+    }
+    const parents = prune.filter((parent) => this.directories.has(parent) && !this.pruning.has(parent));
+    if (this.directories.has(dirname(path)) && parents.length) {
+      const view = await host2(this.context, () => this.context.fs.confineExtraction([dirname(path), parents.at(-1)], { signal: this.context.signal }));
+      for (const parent of parents) this.pruning.set(parent, view);
+    }
+  }
+  async validate(path) {
+    const parents = [];
+    for (let parent = dirname(path); ; parent = dirname(parent)) {
+      parents.unshift(parent);
+      if (parent === "/") break;
+    }
+    for (const parent of parents) {
+      const expected = this.directories.get(parent);
+      const current = await host2(this.context, () => this.context.fs.lstat(parent, { signal: this.context.signal }));
+      if (current.type !== "directory" || compareCopyIdentity(current, expected) !== "same") {
+        throw new FsError("EAGAIN", { syscall: "patch", path: parent });
+      }
+    }
+  }
+  async mkdir(path) {
+    await this.capture(path);
+    await this.validate(path);
+    const stat = await host2(this.context, () => this.context.fs.prepareDirectory(path, {
+      parent: this.directories.get(dirname(path)),
+      expected: null,
+      signal: this.context.signal
+    }));
+    this.directories.set(path, stat);
+  }
+  async write(path, source, destination, mode, mtimeMs) {
+    await this.capture(path);
+    const ancestors = [];
+    for (let parent2 = dirname(path); ; parent2 = dirname(parent2)) {
+      const stat = this.directories.get(parent2);
+      if (!stat) throw new ToolError2(`patch parent does not exist: ${parent2}`);
+      ancestors.unshift({ path: parent2, stat });
+      if (parent2 === "/") break;
+    }
+    const context = this.context;
+    const parent = ancestors[ancestors.length - 1].stat;
+    let staging;
+    let operation;
+    let closed = false;
+    const release = retainFileSystemCleanup(context.fs, async (view) => {
+      await operation?.catch(() => {
+      });
+      if (staging?.cleanup) await staging.cleanup.remove();
+      else if (staging) await view.removeStagedFile(staging);
+    }, { maxOperations: 1 });
+    const cleanup = () => {
+      closed = true;
+      return release();
+    };
+    context.registerCleanup?.(cleanup);
+    try {
+      operation = Promise.resolve().then(async () => {
+        context.signal.throwIfAborted();
+        if (closed) throw new ToolError2("patch publication is closed");
+        if (this.trusted) await this.validate(path);
+        staging = await context.fs.createStagedFile(`${dirname(path) === "/" ? "" : dirname(path)}/.patch-${globalThis.crypto.randomUUID()}`, "file", {
+          type: "file",
+          data: new Uint8Array()
+        }, {
+          parent,
+          retainCleanup: true,
+          signal: context.signal,
+          ...mode === void 0 ? {} : { mode },
+          ...mtimeMs === void 0 ? {} : { atimeMs: mtimeMs, mtimeMs }
+        });
+        if (!staging.writer || !staging.cleanup) throw new ToolError2("filesystem does not support retained staging writes");
+        for await (const bytes of readBytes(typeof source === "string" ? targetBytes(source) : source, context.signal)) {
+          if (closed) throw new ToolError2("patch publication is closed");
+          await staging.writer.write(bytes, { signal: context.signal });
+        }
+        const stat = await staging.writer.finish({ signal: context.signal });
+        context.signal.throwIfAborted();
+        if (closed) throw new ToolError2("patch publication is closed");
+        if (this.trusted) await this.validate(path);
+        await context.fs.publishStagedFile({ ...staging, file: { ...staging.file, stat } }, path, {
+          parent,
+          destination: destination ?? null,
+          ...this.trusted ? {} : { ancestors },
+          signal: context.signal
+        });
+      });
+      await host2(context, () => operation);
+    } finally {
+      await cleanup();
+    }
+  }
+  async remove(path, expected) {
+    if (this.trusted) {
+      await this.validate(path);
+      await host2(this.context, () => this.context.fs.removeFileConditional(path, {
+        parent: this.directories.get(dirname(path)),
+        expected,
+        signal: this.context.signal
+      }));
+      return;
+    }
+    const fs = this.removals.get(path);
+    if (!fs) throw new ToolError2(`patch removal was not admitted: ${path}`);
+    await host2(this.context, () => fs.rm(path, { signal: this.context.signal }));
+  }
+  async prune(path) {
+    if (this.trusted) {
+      await this.validate(`${path}/.patch-prune`);
+      if (!this.context.fs.rmdir) throw new FsError("ENOTSUP", { syscall: "rmdir", path });
+      await host2(this.context, () => this.context.fs.rmdir(path, { signal: this.context.signal }));
+      this.directories.delete(path);
+      return;
+    }
+    const fs = this.pruning.get(path);
+    if (!fs) throw new ToolError2(`patch directory pruning was not admitted: ${path}`);
+    if (!fs.rmdir) throw new FsError("ENOTSUP", { syscall: "rmdir", path });
+    await host2(this.context, () => fs.rmdir(path, { signal: this.context.signal }));
+  }
+};
+
+export {
+  targetBytes,
+  equalTargetLines,
+  TargetDocuments,
+  TargetOutput,
+  PatchPublication
+};

package/dist/safe-bash/command-chunks/{chunk-DVQBZXMQ.js → chunk-WJCN2IXI.js}

@@ -1,10 +1,10 @@
 import {
   asciiKey,
   partName
-} from "./chunk-AXWPJRY6.js";
+} from "./chunk-36XGIPOG.js";
 import {
   OfficeError
-} from "./chunk-KJ3PEDI2.js";
+} from "./chunk-Q73EMLLZ.js";
 
 // packages/safe-bash-presentation-engine/src/content-types.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-45FI2IPY.js → chunk-WQ6ABTJU.js}

@@ -1,4 +1,5 @@
 // packages/safe-bash-command-media/src/plugin.ts
+import { readFileStream } from "@poe-platform/safe-fs/core";
 import { getCommandArguments } from "../../safe-bash-contracts/command.js";
 import { createFFmpegShims } from "../../safe-bash-media-engine/index.js";
 import { createImageMagickShims } from "../../safe-bash-media-engine/index.js";
@@ -46,12 +47,8 @@ function mediaShims(options) {
                 return void 0;
               }
             },
-            async read(bytes) {
-              try {
-                return await context.fs.readFile(path(bytes), { signal: context.signal });
-              } catch {
-                return void 0;
-              }
+            readStream(bytes) {
+              return readFileStream(context.fs, path(bytes), { signal: context.signal, chunkSize: 65536 });
             }
           };
         }

package/dist/safe-bash/command-chunks/{chunk-XBZ4ZWGL.js → chunk-WVMHRNXZ.js}

@@ -2,15 +2,15 @@ import {
   nodeFor,
   selected,
   validateSelection
-} from "./chunk-6XVMWFHD.js";
+} from "./chunk-TW73OXPR.js";
 import {
   attr,
   child,
   loadShared
-} from "./chunk-ORZRWT62.js";
+} from "./chunk-56NYSX65.js";
 import {
   OfficeError
-} from "./chunk-KJ3PEDI2.js";
+} from "./chunk-Q73EMLLZ.js";
 
 // packages/safe-bash-presentation-engine/src/charts.ts
 import { SaxesParser } from "saxes";

package/dist/safe-bash/command-chunks/{chunk-7GXUCQI4.js → chunk-WXRYDALR.js}

@@ -1,16 +1,16 @@
 import {
   attr,
   child
-} from "./chunk-ORZRWT62.js";
+} from "./chunk-56NYSX65.js";
 import {
   parseXmlPart
-} from "./chunk-5L6GHFRW.js";
+} from "./chunk-554Z6IKP.js";
 import {
   TypeError
-} from "./chunk-NXCMXD74.js";
+} from "./chunk-S6R3IB36.js";
 import {
   OfficeError
-} from "./chunk-KJ3PEDI2.js";
+} from "./chunk-Q73EMLLZ.js";
 
 // packages/safe-bash-presentation-engine/src/shape-id.ts
 var ShapeIdAllocator = class {