@poe-platform/safe-bash 0.1.799 → 0.1.801

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

@@ -0,0 +1,25 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-tar/src/listing.ts
+init_buffer();
+import { encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+function quoteName(name, style) {
+  if (style === "literal") return name;
+  const escapes = { "\x07": "\\a", "\b": "\\b", "	": "\\t", "\n": "\\n", "\v": "\\v", "\f": "\\f", "\r": "\\r" };
+  let result = style === "c" ? '"' : "";
+  for (const character of name) {
+    const escape = escapes[character];
+    if (escape !== void 0) result += escape;
+    else if (style === "c" && character === '"' || character === "\\") result += `\\${character}`;
+    else if (character.charCodeAt(0) < 32 || character.charCodeAt(0) >= 127 && character.charCodeAt(0) <= 159 || character === "\u2028" || character === "\u2029") {
+      for (const byte of encodeBytes(character)) result += `\\${byte.toString(8).padStart(3, "0")}`;
+    } else result += character;
+  }
+  return style === "c" ? result + '"' : result;
+}
+
+export {
+  quoteName
+};

package/dist/safe-bash/command-chunks/{chunk-4ONEXMD3.js → chunk-CAP7ZJSY.js}

@@ -1,16 +1,16 @@
 import {
   renderCellText
-} from "./chunk-KBEURXFF.js";
+} from "./chunk-UN6WS55J.js";
 import {
   exportOptionPairs
-} from "./chunk-OT4LZMLB.js";
+} from "./chunk-BR73BIOW.js";
 import {
   readGnumericRichText,
   writeGnumericRichText
-} from "./chunk-X6NJC3IC.js";
+} from "./chunk-75OFBY5R.js";
 import {
   richTextSegments
-} from "./chunk-TF6OA2GK.js";
+} from "./chunk-3NV3HYT2.js";
 import {
   createOdfXml,
   dateSerial,
@@ -27,10 +27,10 @@ import {
   translateOdfHyperlink,
   upgradeOdfAnnotation,
   visitFormula
-} from "./chunk-5SHGJ7NO.js";
+} from "./chunk-VA5ZHYYA.js";
 import {
   converterLocale
-} from "./chunk-4QJOYXVB.js";
+} from "./chunk-JV7LBUTP.js";
 import {
   DEFAULT_SHEET_SIZE,
   MAX_SHEET_SIZE,
@@ -46,10 +46,10 @@ import {
   quoteNativeSheet,
   quotedLabelText,
   serializeExpression
-} from "./chunk-DWFLVJC6.js";
+} from "./chunk-CCRHMAU5.js";
 import {
   createZipCodec
-} from "./chunk-MKQVQMXO.js";
+} from "./chunk-5LU4UCBR.js";
 import {
   CodecError,
   createCompressionCodec

package/dist/safe-bash/command-chunks/{chunk-DWFLVJC6.js → chunk-CCRHMAU5.js}

@@ -4909,12 +4909,13 @@ function parseExpression(source, options) {
           scalar: before !== "intersection" && after !== "intersection" && (before === "binary" || after === "binary")
         } };
         if (value.kind === "parentheses") return { ...value, child: select(value.child, "other", "other") };
-        if (value.kind === "unary") return { ...value, child: select(value.child, value.op === "%" ? before : "other", value.op === "%" ? "other" : after) };
+        if (value.kind === "unary") return { ...value, child: select(value.child, value.op === "%" ? before : "binary", value.op === "%" ? "binary" : after) };
         if (value.kind === "binary") {
           const neighbor = value.op === "intersection" || value.op === "label-intersection" ? "intersection" : "binary";
           return { ...value, left: select(value.left, before, neighbor), right: select(value.right, neighbor, after) };
         }
         if (value.kind === "call") return { ...value, args: value.args.map((child) => select(child, "other", "other")) };
+        if (value.kind === "array") return { ...value, rows: value.rows.map((row) => row.map((child) => select(child, "other", "other"))) };
         return value;
       };
       root = select(root, "binary", "binary");

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

@@ -0,0 +1,150 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-sed/src/inplace.ts
+init_buffer();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { dirname, FsError, joinPath } from "../../safe-bash-contracts/index.js";
+import { compareCopyIdentity } from "../../safe-bash-contracts/filesystem-identity.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
+import { decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { bytes, virtualPath } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+async function prepareInPlace(context, files, suffix) {
+  const fs = context.fs;
+  if (!fs.confineExtraction || !fs.writeFileConditional || !fs.openReadFile) {
+    throw new FsError("ENOTSUP", { message: "in-place editing requires retained ancestry, retained reads and atomic conditional writes" });
+  }
+  const targets = [];
+  for (const file of files) {
+    const operand = virtualPath(context, file);
+    const path = "/" + operand.split("/").filter((part) => part && part !== ".").join("/");
+    const capabilities = await fs.capabilitiesFor?.(path, { signal: context.signal }) ?? fs.capabilities;
+    if (capabilities.atomicFileMutation !== true || capabilities.retainedRead !== true) {
+      throw new FsError("ENOTSUP", { path, message: "in-place editing requires retained reads and atomic conditional writes" });
+    }
+    const parent = await fs.lstat(dirname(path), { signal: context.signal });
+    const original = await fs.lstat(operand, { signal: context.signal });
+    if (parent.type !== "directory" || original.type !== "file") throw new FsError("ENOTSUP", { path, message: "in-place editing requires regular files and directory parents" });
+    let backup = null;
+    const backupAncestors = [];
+    if (suffix) {
+      try {
+        backup = await fs.lstat(path + suffix, { signal: context.signal });
+      } catch (error) {
+        if (!(error instanceof FsError) || error.code !== "ENOENT") throw error;
+      }
+      if (backup && backup.type !== "file") throw new FsError("ENOTSUP", { path: path + suffix, message: "in-place backups require regular files" });
+      if (backup && compareCopyIdentity(original, backup) === "same") throw new FsError("EINVAL", { path, message: "backup aliases the edited file" });
+      if (backup && (backup.mode & 4095) !== (original.mode & 4095)) {
+        const backupCapabilities = await fs.capabilitiesFor?.(path + suffix, { signal: context.signal }) ?? fs.capabilities;
+        if (backupCapabilities.atomicFileStaging !== true || backupCapabilities.atomicStagingAncestry !== true || !fs.createStagedFile || !fs.publishStagedFile || !fs.removeStagedFile) {
+          throw new FsError("ENOTSUP", { path: path + suffix, message: "preserving backup permissions requires atomic staging with ancestry verification" });
+        }
+        for (let directory = dirname(path); ; directory = dirname(directory)) {
+          const stat = directory === dirname(path) ? parent : await fs.lstat(directory, { signal: context.signal });
+          if (stat.type !== "directory") throw new FsError("ENOTSUP", { path: directory, message: "in-place backups require directory ancestry" });
+          backupAncestors.unshift({ path: directory, stat });
+          if (directory === "/") break;
+        }
+      }
+    }
+    targets.push({ path, parent, original, backup, backupAncestors });
+  }
+  const view = await fs.confineExtraction([...new Set(targets.map((target) => dirname(target.path)))], { signal: context.signal });
+  if (!view.writeFileConditional) throw new FsError("ENOTSUP", { message: "in-place editing requires atomic conditional writes" });
+  return targets.map((target) => ({ ...target, fs: view }));
+}
+async function replaceBackup(context, target, suffix, data) {
+  let staging;
+  let operation;
+  let failure;
+  let closed = false;
+  const release = retainFileSystemCleanup(context.fs, async (view) => {
+    await operation?.catch(() => {
+    });
+    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 FsError("EPIPE", { message: "in-place backup publication is closed" });
+      staging = await context.fs.createStagedFile(joinPath(dirname(target.path), `.sed-${globalThis.crypto.randomUUID()}`), "backup", {
+        type: "file",
+        data
+      }, { parent: target.parent, mode: target.original.mode & 4095, signal: context.signal });
+      context.signal.throwIfAborted();
+      if (closed) throw new FsError("EPIPE", { message: "in-place backup publication is closed" });
+      await context.fs.publishStagedFile(staging, target.path + suffix, {
+        parent: target.parent,
+        destination: target.backup,
+        ancestors: target.backupAncestors,
+        signal: context.signal
+      });
+      context.signal.throwIfAborted();
+    });
+    await operation;
+  } catch (error) {
+    failure = { reason: error };
+  }
+  try {
+    await cleanup();
+  } catch (error) {
+    if (failure) throw new AggregateError([failure.reason, error], "in-place backup publication and cleanup failed");
+    throw error;
+  }
+  if (failure) throw failure.reason;
+}
+async function editInPlace(context, target, suffix, budget, run) {
+  const reader = await context.fs.openReadFile(target.path, { signal: context.signal });
+  let closing;
+  const close = () => closing ??= reader.close();
+  try {
+    context.registerCleanup?.(close);
+    const identity = compareCopyIdentity(target.original, await reader.stat({ signal: context.signal }));
+    if (identity !== "same") throw new FsError(identity === "unknown" ? "ENOTSUP" : "EAGAIN", { path: target.path, message: "in-place reader does not match the inspected file" });
+    const source = async function* () {
+      let position = 0;
+      while (true) {
+        const chunk = await reader.read(position, 64 * 1024, { signal: context.signal });
+        if (!chunk.byteLength) return;
+        position += chunk.byteLength;
+        yield chunk;
+      }
+    };
+    const { data, result } = await run(source());
+    if (suffix) {
+      let original = "";
+      for await (const chunk of source()) {
+        budget.step();
+        original = budget.check(original + decodeBytes(encodeBytes(chunk), "latin1"));
+        await budget.checkpoint();
+      }
+      context.signal.throwIfAborted();
+      if (target.backupAncestors.length) await replaceBackup(context, target, suffix, bytes(original));
+      else await target.fs.writeFileConditional(target.path + suffix, bytes(original), {
+        parent: target.parent,
+        expected: target.backup,
+        mode: target.original.mode & 4095,
+        signal: context.signal
+      });
+      context.signal.throwIfAborted();
+    }
+    await writeFileOutput(context, data, async (chunk) => {
+      await target.fs.writeFileConditional(target.path, chunk, { parent: target.parent, expected: target.original, signal: context.signal });
+    });
+    return result;
+  } finally {
+    await close();
+  }
+}
+
+export {
+  prepareInPlace,
+  editInPlace
+};

package/dist/safe-bash/command-chunks/{chunk-JCNNOMBV.js → chunk-CQTRW45K.js}

@@ -1,12 +1,12 @@
 import {
   describe
-} from "./chunk-YZ5SVZFD.js";
+} from "./chunk-KXU3IRUO.js";
 import {
   JqError,
   JqLimitError,
   object,
   put
-} from "./chunk-VVI4Z73I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -93,5 +93,6 @@ async function* capture(input, pattern, modifiers, budget) {
 }
 
 export {
+  extendedPattern,
   capture
 };

package/dist/safe-bash/command-chunks/{chunk-N2F74VRO.js → chunk-CZ7EN3JG.js}

@@ -1,6 +1,6 @@
 import {
   ProgramError
-} from "./chunk-HLGKIZ25.js";
+} from "./chunk-F6OYH562.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

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

@@ -0,0 +1,122 @@
+import {
+  Reader
+} from "./chunk-7K6JYKPJ.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-pipes.ts
+init_buffer();
+import { createBytePipe } from "../../safe-bash-contracts/index.js";
+import { shellValueByteLength } from "../../safe-bash-contracts/value.js";
+import { ProgramError, bytes } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+var AwkPipes = class {
+  constructor(context, budget, retention) {
+    this.context = context;
+    this.budget = budget;
+    this.retention = retention;
+    context.registerCleanup?.(() => this.closeAll(true));
+  }
+  context;
+  budget;
+  retention;
+  reads = /* @__PURE__ */ new Map();
+  writes = /* @__PURE__ */ new Map();
+  cleanup;
+  open(command, reading) {
+    if (this.cleanup) throw new ProgramError("awk pipes are closed");
+    const map = reading ? this.reads : this.writes;
+    const existing = map.get(command);
+    if (existing) return existing;
+    if (!this.context.invoke) throw new ProgramError("command pipes require virtual command invocation");
+    if (!command) throw new ProgramError("empty pipe command");
+    if (this.reads.size + this.writes.size >= (this.budget.options.maxGetlineFiles ?? Infinity)) throw new ProgramError("awk open-pipe limit exceeded");
+    this.budget.check(command);
+    const size = shellValueByteLength(command);
+    this.retention.admit(0, size);
+    const abort = new AbortController();
+    const signal = AbortSignal.any([this.context.signal, abort.signal]);
+    const channel = createBytePipe({ highWaterMark: 1, signal });
+    const invoke = this.context.invoke;
+    const done = Promise.resolve().then(() => invoke("sh", ["-c", command], {
+      signal,
+      stdin: reading ? this.context.stdin : channel.endpoints.read.readable,
+      stdout: reading ? { write: async (chunk) => {
+        this.retention.admit(0, chunk.byteLength);
+        try {
+          await channel.writable.write(chunk);
+        } finally {
+          this.retention.release(chunk.byteLength);
+        }
+      } } : this.context.stdout,
+      stderr: this.context.stderr
+    })).then(async (result) => {
+      if (reading) await channel.close();
+      else await channel.endpoints?.read.close();
+      return { status: result.exitCode };
+    }).catch(async (error) => {
+      await channel.abort(error);
+      return { error };
+    });
+    const pipe = { channel, abort, done, ...reading ? { reader: new Reader(channel.endpoints.read.readable, this.budget, this.retention) } : {} };
+    map.set(command, pipe);
+    return pipe;
+  }
+  async read(command, separator) {
+    const pipe = this.open(command, true);
+    return pipe.reader.read(separator);
+  }
+  async write(command, output) {
+    const pipe = this.open(command, false);
+    this.budget.step(output.length);
+    this.retention.admit(0, output.length);
+    try {
+      await pipe.channel.writable.write(bytes(output));
+    } finally {
+      this.retention.release(output.length);
+    }
+  }
+  async close(command) {
+    let status;
+    for (const map of [this.reads, this.writes]) {
+      const pipe = map.get(command);
+      if (!pipe) continue;
+      status = await (pipe.closing ??= this.finish(pipe).finally(() => {
+        map.delete(command);
+        this.retention.release(shellValueByteLength(command));
+      }));
+    }
+    return status;
+  }
+  async finish(pipe) {
+    let failed = false;
+    let failure;
+    try {
+      if (pipe.reader) {
+        await pipe.channel.endpoints.read.close();
+        await pipe.reader.close();
+      } else await pipe.channel.close();
+    } catch (error) {
+      failed = true;
+      failure = error;
+    }
+    const result = await pipe.done;
+    if (failed && !pipe.abort.signal.aborted) throw failure;
+    if ("error" in result) {
+      if (!pipe.abort.signal.aborted) throw result.error;
+      return -1;
+    }
+    return result.status;
+  }
+  closeAll(cancel = false) {
+    if (cancel) for (const pipe of [...this.reads.values(), ...this.writes.values()]) pipe.abort.abort();
+    return this.cleanup ??= (async () => {
+      const results = await Promise.allSettled([.../* @__PURE__ */ new Set([...this.reads.keys(), ...this.writes.keys()])].map((command) => this.close(command)));
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  }
+};
+
+export {
+  AwkPipes
+};

package/dist/safe-bash/command-chunks/{chunk-KKG4BAFZ.js → chunk-DIEPXUM4.js}

@@ -105,6 +105,12 @@ var Budget = class {
       this.assertOpen();
     });
   }
+  buffered(amount) {
+    this.check(this.retained + amount, this.limits.maxBufferedBytes, "buffered bytes");
+  }
+  outputCapacity(amount) {
+    this.check(this.output + amount, this.limits.maxOutputBytes, "output bytes");
+  }
   retain(amount) {
     this.check(this.retained + amount, this.limits.maxBufferedBytes, "buffered bytes");
     this.retained += amount;

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

@@ -0,0 +1,87 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-path.ts
+init_buffer();
+import { ToolError } from "../../safe-bash-diff-engine/shared.js";
+import { encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+function decodeHeaderPath(value) {
+  if (!value.startsWith('"')) return value.split("	", 1)[0];
+  const bytes = [];
+  const escapes = { a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13, '"': 34, "\\": 92 };
+  let index = 1;
+  while (index < value.length) {
+    const character = value[index++];
+    if (character === '"') {
+      if (index < value.length && value[index] !== "	") throw new ToolError("unexpected text after quoted filename");
+      try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Uint8Array.from(bytes));
+      } catch {
+        throw new ToolError("invalid UTF-8 in quoted filename");
+      }
+    }
+    if (character === "\\") {
+      const escaped = value[index++];
+      if (/[0-7]/u.test(escaped ?? "")) {
+        const octal = value.slice(index - 1, index + 2);
+        if (!/^[0-7]{3}$/u.test(octal) || parseInt(octal, 8) > 255) throw new ToolError("invalid octal filename escape");
+        bytes.push(parseInt(octal, 8));
+        index += 2;
+      } else {
+        const byte = escapes[escaped];
+        if (byte === void 0) throw new ToolError("invalid quoted filename escape");
+        bytes.push(byte);
+      }
+    } else {
+      const point = value.codePointAt(index - 1);
+      const literal = String.fromCodePoint(point);
+      bytes.push(...encodeBytes(literal));
+      index += literal.length - 1;
+    }
+  }
+  throw new ToolError("unterminated quoted filename");
+}
+function safeTarget(path, strip, allowAbsolute = false) {
+  if (path === "/dev/null") return void 0;
+  if (!path || !allowAbsolute && path.startsWith("/") || /[\\\0-\x08\x0a-\x1f\x7f]/u.test(path)) throw new ToolError(`unsafe patch path: ${JSON.stringify(path)}`);
+  const parts = path.split(/\/+/u);
+  if (parts.some((part) => part === ".." || /^[A-Za-z]:/u.test(part))) throw new ToolError(`unsafe patch path: ${JSON.stringify(path)}`);
+  if (path.endsWith("/") || parts.at(-1) === ".") throw new ToolError(`patch path names a directory: ${JSON.stringify(path)}`);
+  const stripped = parts.filter(Boolean).slice(strip).filter((part) => part !== ".").join("/");
+  if (!stripped) throw new ToolError(`strip count removes entire patch path: ${path}`);
+  return allowAbsolute && path.startsWith("/") && strip === 0 ? `/${stripped}` : stripped;
+}
+function isEpochHeader(line) {
+  const separator = line.lastIndexOf("	");
+  if (separator < 0) return false;
+  let timestamp = line.slice(separator + 1).trim();
+  const traditional = /^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) +([0-9]{1,2}) (\d{2}:\d{2}:\d{2}) (\d{4})(?: (UTC|GMT|[+-]\d{4}))?$/u.exec(timestamp);
+  if (traditional) {
+    const month = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"].indexOf(traditional[1]) + 1;
+    timestamp = `${traditional[4]}-${String(month).padStart(2, "0")}-${traditional[2].padStart(2, "0")} ${traditional[3]} ${traditional[5] ?? "+0000"}`;
+  }
+  const match = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(?:\.(\d{1,9}))?(?:\s*(Z|UTC|GMT|[+-]\d{2}:?\d{2}))?$/u.exec(timestamp);
+  if (!match) return false;
+  const iso = `${match[1]}T${match[2]}`;
+  const local = Date.parse(`${iso}Z`);
+  if (!Number.isFinite(local) || new Date(local).toISOString().slice(0, 19) !== iso) return false;
+  const zone = match[4];
+  let offset = 0;
+  if (zone && /^[+-]/u.test(zone)) {
+    const digits = zone.slice(1).replace(":", "");
+    const hours = Number(digits.slice(0, 2));
+    const minutes = Number(digits.slice(2));
+    if (hours > 25 || minutes > 59) return false;
+    offset = (hours * 60 + minutes) * 60 * (zone[0] === "+" ? 1 : -1);
+  }
+  const seconds = local / 1e3 - offset;
+  const fractional = match[3] !== void 0 && /[1-9]/u.test(match[3]);
+  return (seconds > -25 * 3600 || seconds === -25 * 3600 && fractional) && seconds < 26 * 3600;
+}
+
+export {
+  decodeHeaderPath,
+  safeTarget,
+  isEpochHeader
+};

package/dist/safe-bash/command-chunks/{chunk-2PX5B7T5.js → chunk-DQAVUDDX.js}

@@ -1,7 +1,7 @@
 import {
   crc32,
   createZipCodec
-} from "./chunk-MKQVQMXO.js";
+} from "./chunk-5LU4UCBR.js";
 import {
   CodecError,
   yieldEventLoop
@@ -13145,7 +13145,7 @@ var PackageView = class {
     if (input == null) throw new InputTypeError("Expected explicit package input.");
     if (settings2.template !== void 0) throw new InputTypeError("A context template conflicts with package input.");
     const admitted2 = await admitDocumentModel(input, settings2);
-    const { ModelStore: ModelStore2 } = await import("./model-store-L35QTZMJ.js");
+    const { ModelStore: ModelStore2 } = await import("./model-store-WPKMRPV4.js");
     const store = new ModelStore2(admitted2.archive, admitted2.settings, admitted2.archive.mainPart, admitted2.source);
     store.package.after_unmarshal();
     return store.package;