@poe-platform/safe-bash 0.1.798 → 0.1.800

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

@@ -0,0 +1,249 @@
+import {
+  parseUnified,
+  parseUnifiedSection
+} from "./chunk-67QKREJK.js";
+import {
+  decodeHeaderPath
+} from "./chunk-DOKKNRRM.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-formats.ts
+init_buffer();
+import { ToolError, integer } from "../../safe-bash-diff-engine/shared.js";
+import { byteLength } from "../../safe-bash-io-engine/byte-encoding.js";
+var Reader = class {
+  constructor(text, budget) {
+    this.budget = budget;
+    this.lines = budget.split(text).map((line) => line.slice(0, -1));
+  }
+  budget;
+  lines;
+  index = 0;
+  peek() {
+    return this.lines[this.index];
+  }
+  async take() {
+    this.budget.step();
+    {
+      const c = this.budget.checkpoint();
+      if (c) await c;
+    }
+    const line = this.lines[this.index++];
+    if (line === void 0) throw new ToolError("truncated patch");
+    return line;
+  }
+  number(value) {
+    const result = integer(value, "patch range");
+    if (result > this.budget.limits.maxLines) throw new ToolError("hunk coordinate exceeds line limit");
+    return result;
+  }
+  async content(prefix) {
+    const line = await this.take();
+    if (line !== prefix && !(prefix === " " && line === "") && !line.startsWith(`${prefix} `) && !line.startsWith(`${prefix}	`)) throw new ToolError("malformed patch body prefix");
+    let text = `${line.slice(2)}
+`;
+    if (this.peek() === "\") {
+      await this.take();
+      if (text === "\n") throw new ToolError("empty incomplete line is not a valid text line");
+      text = text.slice(0, -1);
+    }
+    return text;
+  }
+};
+function encoded(line) {
+  return `${line.kind}${line.text}${line.text.endsWith("\n") ? "" : "\n\\n"}`;
+}
+async function normal(reader, target) {
+  const quoted = JSON.stringify(target ?? "/dev/null");
+  const output = [`--- ${quoted}
++++ ${quoted}
+`];
+  while (reader.peek() !== void 0) {
+    if (reader.peek() === "") {
+      await reader.take();
+      continue;
+    }
+    if (!/^\d/u.test(reader.peek())) break;
+    const command = /^(\d+)(?:,(\d+))?([acd])(\d+)(?:,(\d+))?$/u.exec(await reader.take());
+    if (!command) throw new ToolError("malformed normal patch command");
+    const oldStart = reader.number(command[1]);
+    const oldLast = reader.number(command[2] ?? command[1]);
+    const newStart = reader.number(command[4]);
+    const newLast = reader.number(command[5] ?? command[4]);
+    const operation = command[3];
+    if (oldLast < oldStart || newLast < newStart || operation === "a" && command[2] !== void 0 || operation === "d" && command[5] !== void 0) throw new ToolError("invalid normal patch range");
+    const oldCount = operation === "a" ? 0 : oldLast - oldStart + 1;
+    const newCount = operation === "d" ? 0 : newLast - newStart + 1;
+    output.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@
+`);
+    for (let index = 0; index < oldCount; index++) output.push(encoded({ kind: "-", text: await reader.content("<") }));
+    if (operation === "c" && await reader.take() !== "---") throw new ToolError("missing normal change separator");
+    for (let index = 0; index < newCount; index++) output.push(encoded({ kind: "+", text: await reader.content(">") }));
+  }
+  return output.join("");
+}
+async function contextRange(reader, old) {
+  const line = await reader.take();
+  const match = (old ? /^\*\*\* (\d+)(?:,(\d+))? \*\*\*\*$/u : /^--- (\d+)(?:,(\d+))? ----$/u).exec(line);
+  if (!match) throw new ToolError("malformed context range");
+  const start = reader.number(match[1]);
+  const last = reader.number(match[2] ?? match[1]);
+  if (last < start || match[2] !== void 0 && start === 0) throw new ToolError("invalid context range");
+  return { start, last, multiple: match[2] !== void 0 };
+}
+async function contextSide(reader, old, range) {
+  const lines = [];
+  const count = range.start === 0 ? 0 : range.last - range.start + 1;
+  while (reader.peek() !== void 0 && lines.length < count) {
+    const kind = reader.peek() === "" ? " " : reader.peek()[0];
+    if (kind !== " " && kind !== "!" && kind !== (old ? "-" : "+")) break;
+    if (old && /^--- \d+(?:,\d+)? ----$/u.test(reader.peek())) break;
+    lines.push({ kind, text: await reader.content(kind) });
+    if (lines.length > reader.budget.limits.maxLines) throw new ToolError("context body line limit exceeded");
+  }
+  if (!old && lines.length === count && lines.at(-1)?.text.endsWith("\n") === false) {
+    while (reader.peek() === "\") await reader.take();
+  }
+  return lines;
+}
+function contextCount(range, lines) {
+  if (!lines.length) {
+    if (range.multiple) throw new ToolError("empty context side has a nonempty range");
+    return 0;
+  }
+  if (range.start === 0 || lines.length !== range.last - range.start + 1) throw new ToolError("context body count does not match range");
+  return lines.length;
+}
+async function context(reader) {
+  const output = [];
+  while (reader.peek() !== void 0) {
+    const header = await reader.take();
+    if (header === "") continue;
+    if (/^diff -[^ ]+ /u.test(header)) {
+      output.push(`${header}
+`);
+      continue;
+    }
+    if (!header.startsWith("*** ")) throw new ToolError("expected context file header");
+    const next = await reader.take();
+    if (!next.startsWith("--- ")) throw new ToolError("expected new context file header");
+    output.push(`--- ${header.slice(4)}
++++ ${next.slice(4)}
+`);
+    let hunks = 0;
+    while (reader.peek()?.startsWith("***************")) {
+      const delimiter = await reader.take();
+      if (!/^\*{15}(?: .*)?$/u.test(delimiter)) throw new ToolError("malformed context hunk separator");
+      if (++hunks > reader.budget.limits.maxHunks) throw new ToolError("hunk limit exceeded");
+      const oldRange = await contextRange(reader, true);
+      let oldLines = await contextSide(reader, true, oldRange);
+      const newRange = await contextRange(reader, false);
+      let newLines = await contextSide(reader, false, newRange);
+      if (!oldLines.length) {
+        if (newLines.some((line) => line.kind === "!")) throw new ToolError("missing old changed context body");
+        oldLines = newLines.filter((line) => line.kind === " ");
+      }
+      if (!newLines.length) {
+        if (oldLines.some((line) => line.kind === "!")) throw new ToolError("missing new changed context body");
+        newLines = oldLines.filter((line) => line.kind === " ");
+      }
+      const oldCount = contextCount(oldRange, oldLines);
+      const newCount = contextCount(newRange, newLines);
+      output.push(`@@ -${oldRange.start},${oldCount} +${newRange.start},${newCount} @@${delimiter.slice(15)}
+`);
+      let oldIndex = 0;
+      let newIndex = 0;
+      while (oldIndex < oldLines.length || newIndex < newLines.length) {
+        let oldChanged = false;
+        let newChanged = false;
+        while (oldIndex < oldLines.length && oldLines[oldIndex].kind !== " ") {
+          const line = oldLines[oldIndex++];
+          oldChanged ||= line.kind === "!";
+          output.push(encoded({ kind: "-", text: line.text }));
+          reader.budget.step();
+          {
+            const c = reader.budget.checkpoint();
+            if (c) await c;
+          }
+        }
+        while (newIndex < newLines.length && newLines[newIndex].kind !== " ") {
+          const line = newLines[newIndex++];
+          newChanged ||= line.kind === "!";
+          output.push(encoded({ kind: "+", text: line.text }));
+          reader.budget.step();
+          {
+            const c = reader.budget.checkpoint();
+            if (c) await c;
+          }
+        }
+        if (oldChanged !== newChanged) throw new ToolError("unpaired changed context group");
+        if (oldIndex < oldLines.length || newIndex < newLines.length) {
+          const oldLine = oldLines[oldIndex++];
+          const newLine = newLines[newIndex++];
+          if (!oldLine || !newLine || !reader.budget.equal(oldLine.text, newLine.text)) throw new ToolError("context halves disagree");
+          output.push(encoded({ kind: " ", text: oldLine.text }));
+        }
+      }
+    }
+    if (!hunks) throw new ToolError("context file patch has no hunks");
+    break;
+  }
+  return output.join("");
+}
+async function parsePatch(text, budget, format, target, progress) {
+  if (text && !text.endsWith("\n")) throw new ToolError("patch is truncated: missing final LF");
+  const reader = new Reader(text, budget);
+  const patches = [];
+  let convertedBytes = 0;
+  while (reader.peek() !== void 0) {
+    try {
+      if (reader.peek() === "") {
+        await reader.take();
+        continue;
+      }
+      if (!progress && patches.length && reader.peek().startsWith("-") && !reader.peek().startsWith("---")) {
+        throw new ToolError("unexpected deletion outside a patch hunk");
+      }
+      if (patches.length && !/^(?:Index: |diff |index |---|\*\*\*|@@|[+\\<>]|\d)/u.test(reader.peek())) {
+        await reader.take();
+        continue;
+      }
+      let indexPath;
+      if (reader.peek()?.startsWith("Index: ")) {
+        indexPath = decodeHeaderPath((await reader.take()).slice(7));
+        if (/^=+$/u.test(reader.peek() ?? "")) await reader.take();
+      }
+      const start = reader.index;
+      while (/^diff /u.test(reader.peek() ?? "")) await reader.take();
+      const first = reader.peek() ?? "";
+      const detected = first.startsWith("*** ") ? "context" : /^\d/u.test(first) ? "normal" : "unified";
+      if (format && detected !== format) throw new ToolError(`patch format is ${detected}, not requested ${format}`);
+      if (detected === "unified") {
+        reader.index = start;
+        patches.push(...(await parseUnifiedSection(reader, budget)).map((patch) => ({ ...patch, ...indexPath === void 0 ? {} : { indexPath } })));
+      } else {
+        if (detected === "context") reader.index = start;
+        const converted = detected === "normal" ? await normal(reader, target ?? indexPath) : await context(reader);
+        convertedBytes += byteLength(converted);
+        if (convertedBytes > budget.limits.maxInputBytes * 2 + 16384) throw new ToolError("converted patch byte limit exceeded");
+        patches.push(...(await parseUnified(converted, budget)).map((patch) => ({
+          ...patch,
+          format: detected,
+          ...indexPath === void 0 ? {} : { indexPath },
+          ...detected === "normal" && target === void 0 && indexPath === void 0 ? { unlocated: true } : {}
+        })));
+      }
+    } catch (error) {
+      if (!progress || !(error instanceof ToolError) || /limit|budget|filename|path|escape/u.test(error.message)) throw error;
+      progress.error = error;
+      break;
+    }
+  }
+  return patches;
+}
+
+export {
+  parsePatch
+};

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

@@ -0,0 +1,42 @@
+import {
+  CurlError
+} from "./chunk-IYPAQ7PH.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/form-headers.ts
+init_buffer();
+import { decodeBytes, encodeBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+function validatePartHeader(header) {
+  const colon = header.indexOf(":");
+  if (colon <= 0) throw new CurlError(2, "Invalid multipart part header");
+  for (const character of header.slice(0, colon)) {
+    const code = character.charCodeAt(0);
+    if (!(code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || "!#$%&'*+-.^_`|~".includes(character)))
+      throw new CurlError(2, "Invalid multipart part header");
+  }
+  for (const character of header) {
+    const code = character.charCodeAt(0);
+    if (code < 32 && code !== 9 || code === 127)
+      throw new CurlError(2, "Invalid multipart part header");
+  }
+  return header;
+}
+function filePartHeaders(bytes) {
+  const headers = [];
+  for (let line of decodeBytes(encodeBytes(bytes), "utf8").split("\n")) {
+    if (line.endsWith("\r")) line = line.slice(0, -1);
+    if (!line || line.startsWith("#")) continue;
+    if ((line.startsWith(" ") || line.startsWith("	")) && headers.length) {
+      headers[headers.length - 1] += " " + line.trim();
+      validatePartHeader(headers[headers.length - 1]);
+    } else headers.push(validatePartHeader(line));
+  }
+  return headers;
+}
+
+export {
+  validatePartHeader,
+  filePartHeaders
+};

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

@@ -0,0 +1,343 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/safety.ts
+init_buffer();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { readBytes } from "../../safe-bash-contracts/index.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
+import { checkPath, fail, hasIdentity as hasPosixIdentity, sameIdentity as samePosixIdentity } from "../../safe-bash-io-engine/commands/archive/internal.js";
+function hasZipIdentity(stat) {
+  return hasPosixIdentity(stat) || (typeof stat.identityScope === "object" && stat.identityScope !== null || typeof stat.identityScope === "symbol") && typeof stat.opaqueIdentity === "string" && stat.opaqueIdentity.length > 0 && stat.opaqueIdentity.length <= 4096 && hasZipVersion(stat);
+}
+function hasZipVersion(stat) {
+  return typeof stat.opaqueVersion === "string" && stat.opaqueVersion.length > 0 && stat.opaqueVersion.length <= 4096;
+}
+function sameZipIdentity(first, second) {
+  return samePosixIdentity(first, second) || hasZipIdentity(first) && hasZipIdentity(second) && first.opaqueIdentity !== void 0 && first.identityScope === second.identityScope && first.opaqueIdentity === second.opaqueIdentity;
+}
+function unchangedZipSource(before, after) {
+  return before.type === after.type && before.size === after.size && before.mode === after.mode && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs && before.nlink === after.nlink && before.opaqueVersion === after.opaqueVersion && before.revision === after.revision && (!hasZipIdentity(before) || sameZipIdentity(before, after));
+}
+async function safeZipFile(scope, path, stat, allowHardlinked = false) {
+  if (stat.type !== "file" || !hasZipIdentity(stat)) return false;
+  if (stat.nlink !== void 0) {
+    if (stat.nlink === 1) return true;
+    if (!allowHardlinked || stat.nlink < 1 || !hasPosixIdentity(stat)) return false;
+    const capabilities2 = await scope.operation(() => scope.context.fs.capabilitiesFor?.(path, { signal: scope.context.signal }) ?? scope.context.fs.capabilities);
+    return capabilities2.hardlinks === true && capabilities2.atomicFileMutation === true && typeof scope.context.fs.writeFileConditional === "function";
+  }
+  const capabilities = await scope.operation(() => scope.context.fs.capabilitiesFor?.(path, { signal: scope.context.signal }) ?? scope.context.fs.capabilities);
+  return stat.opaqueIdentity !== void 0 && capabilities.hardlinks === false;
+}
+var ZipScope = class {
+  constructor(original, limits) {
+    this.original = original;
+    this.limits = limits;
+    this.context = { ...original, signal: AbortSignal.any([original.signal, this.controller.signal]) };
+    original.registerCleanup?.(this.close);
+  }
+  original;
+  limits;
+  context;
+  controller = new AbortController();
+  pending = /* @__PURE__ */ new Set();
+  readers = /* @__PURE__ */ new Set();
+  closedReason = new Error("ZIP command is closed");
+  drain;
+  inputDrain;
+  work = 0;
+  stdinSource;
+  close = () => {
+    if (!this.drain) {
+      this.drain = Promise.resolve().then(async () => {
+        while (this.pending.size) await Promise.allSettled([...this.pending]);
+        await this.closeInputs();
+      });
+      this.controller.abort(this.original.signal.aborted ? this.original.signal.reason : this.closedReason);
+    }
+    return this.drain;
+  };
+  closeInputs() {
+    return this.inputDrain ??= Promise.allSettled([...this.readers].map((close) => close())).then((results) => {
+      const failures = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+      if (failures.length === 1) throw failures[0];
+      if (failures.length) throw new AggregateError(failures, "ZIP reader cleanup failed");
+    });
+  }
+  async operation(action) {
+    this.context.signal.throwIfAborted();
+    if (++this.work > this.limits.maxPatternSteps) fail("filesystem work limit exceeded");
+    const pending = Promise.resolve().then(() => {
+      this.context.signal.throwIfAborted();
+      return action();
+    });
+    this.pending.add(pending);
+    try {
+      const value = await pending;
+      this.context.signal.throwIfAborted();
+      return value;
+    } finally {
+      this.pending.delete(pending);
+    }
+  }
+  async stat(path) {
+    try {
+      return await this.operation(() => this.context.fs.lstat(path, { signal: this.context.signal }));
+    } catch (error) {
+      this.context.signal.throwIfAborted();
+      if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return void 0;
+      throw error;
+    }
+  }
+  get stdin() {
+    return this.stdinSource ??= this.source(this.original.stdin);
+  }
+  source(source, controller) {
+    if (this.inputDrain) fail("ZIP inputs are closed");
+    const iterator = source[Symbol.asyncIterator]();
+    let closing;
+    const close = () => closing ??= (async () => {
+      controller?.abort(this.closedReason);
+      try {
+        await iterator.return?.();
+      } finally {
+        this.readers.delete(close);
+      }
+    })();
+    this.readers.add(close);
+    return { [Symbol.asyncIterator]: () => ({
+      next: () => this.operation(async () => {
+        const result = await iterator.next();
+        if (result.done) this.readers.delete(close);
+        return result;
+      }),
+      async return() {
+        await close();
+        return { done: true, value: void 0 };
+      }
+    }) };
+  }
+  async *input(path, fifo = false, expected) {
+    const { fs } = this.context;
+    if (expected) {
+      if (!hasZipIdentity(expected)) fail("ZIP source requires known backing identity");
+      const controller2 = new AbortController();
+      const signal2 = AbortSignal.any([this.context.signal, controller2.signal]);
+      let handle;
+      let acquisition;
+      let reading;
+      let closing;
+      const close = () => closing ??= (async () => {
+        controller2.abort(this.closedReason);
+        try {
+          await acquisition?.catch(() => {
+          });
+          await reading?.catch(() => {
+          });
+          await handle?.close();
+        } finally {
+          this.readers.delete(close);
+        }
+      })();
+      if (this.inputDrain) fail("ZIP inputs are closed");
+      this.readers.add(close);
+      try {
+        await (acquisition = this.operation(async () => {
+          const capabilities2 = await (fs.capabilitiesFor?.(path, { signal: signal2 }) ?? fs.capabilities);
+          signal2.throwIfAborted();
+          if (capabilities2.retainedRead !== true || !fs.openReadFile) fail("ZIP source requires retained reads");
+          handle = await fs.openReadFile(path, { signal: signal2 });
+        }));
+        if (this.inputDrain) fail("ZIP inputs are closed");
+        const stat = await (reading = this.operation(() => handle.stat({ signal: signal2 })));
+        if (!unchangedZipSource(expected, stat)) fail(`source changed while opening: ${path}`);
+        let position = 0;
+        while (position < expected.size) {
+          const size = Math.min(this.limits.chunkSize, expected.size - position);
+          signal2.throwIfAborted();
+          const bytes = await (reading = this.operation(() => handle.read(position, size, { signal: signal2 })));
+          signal2.throwIfAborted();
+          if (!bytes.length || bytes.length > size) fail(`source changed while reading: ${path}`);
+          position += bytes.length;
+          yield bytes;
+        }
+        signal2.throwIfAborted();
+        const current = await (reading = this.operation(() => handle.stat({ signal: signal2 })));
+        if (!unchangedZipSource(expected, current)) fail(`source changed while reading: ${path}`);
+      } finally {
+        await close();
+      }
+      return;
+    }
+    const controller = new AbortController();
+    const signal = AbortSignal.any([this.context.signal, controller.signal]);
+    const capabilities = await this.operation(() => fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities);
+    if (fifo && (!fs.readStream || capabilities.streamingRead !== true)) fail("filesystem lacks explicit FIFO byte stream capability");
+    if (fs.readStream && capabilities.streamingRead !== false) {
+      const source = await this.operation(() => this.source(fs.readStream(path, { signal, chunkSize: this.limits.chunkSize }), controller));
+      yield* readBytes(source, signal);
+    } else {
+      const stat = await this.operation(() => fs.stat(path, { signal }));
+      if (stat.size > this.limits.maxBufferedFileBytes) fail("filesystem lacks streaming reads: buffered file limit exceeded");
+      const bytes = await this.operation(() => fs.readFile(path, { signal, ...Number.isFinite(this.limits.maxBufferedFileBytes) ? { maxBytes: this.limits.maxBufferedFileBytes } : {} }));
+      if (bytes.length > this.limits.maxBufferedFileBytes) fail("buffered file limit exceeded");
+      yield bytes;
+    }
+  }
+};
+async function stageZip(scope, prepared, consume) {
+  const { fs, signal } = scope.context;
+  const capabilities = await scope.operation(() => fs.capabilitiesFor?.(prepared.parent, { signal }) ?? fs.capabilities);
+  if (capabilities.atomicFileStaging !== true && capabilities.trustedOwnedStaging !== true || !fs.createStagedFile || !fs.removeStagedFile) fail("ZIP temporary path requires atomic owned file staging");
+  if (prepared.source && (capabilities.atomicFileMutation !== true && capabilities.trustedOwnedStaging !== true || !fs.writeFileConditional)) fail("ZIP temporary path requires atomic conditional writes");
+  let staging;
+  let failure;
+  const close = retainFileSystemCleanup(fs, async (cleanup) => {
+    if (staging) {
+      if (!cleanup.removeStagedFile) fail("ZIP atomic cleanup unavailable");
+      await cleanup.removeStagedFile(staging);
+    }
+  }, { maxOperations: 16 });
+  try {
+    for (let attempt = 0; attempt < scope.limits.maxMembers; attempt++) {
+      const path = `${prepared.parent === "/" ? "" : prepared.parent}/.${prepared.stagingPrefix ?? "zip"}-${attempt + 1}`;
+      checkPath(path, scope.limits);
+      checkPath(`${path}/archive.zip`, scope.limits);
+      if (path === prepared.reservedPath) continue;
+      try {
+        await scope.operation(async () => {
+          staging = await fs.createStagedFile(path, "archive.zip", { type: "file", data: prepared.bytes ?? new Uint8Array() }, {
+            signal,
+            parent: prepared.parentStat,
+            ...prepared.existing ? { mode: prepared.existing.mode & 4095 } : {},
+            ...prepared.mtimeMs === void 0 ? {} : { mtimeMs: prepared.mtimeMs, atimeMs: prepared.mtimeMs }
+          });
+        });
+        break;
+      } catch (error) {
+        signal.throwIfAborted();
+        if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EEXIST") throw error;
+      }
+    }
+    if (!staging) fail("ZIP temporary directory attempt limit exceeded");
+    if (prepared.source) {
+      for await (const chunk of readBytes(prepared.source, signal)) {
+        try {
+          await writeFileOutput(scope.context, chunk, (bytes) => scope.operation(async () => {
+            const stat = await fs.writeFileConditional(staging.file.path, bytes, {
+              signal,
+              parent: staging.directory.stat,
+              expected: staging.file.stat,
+              append: true
+            });
+            staging = { ...staging, file: { path: staging.file.path, stat } };
+          }));
+        } catch (error) {
+          void scope.closeInputs().catch(() => {
+          });
+          throw error;
+        }
+      }
+    }
+    if (prepared.mtimeMs !== void 0 && (staging.file.stat.mtimeMs !== prepared.mtimeMs || staging.file.stat.atimeMs !== prepared.mtimeMs)) fail("ZIP staging did not retain archive modification time");
+    await consume(staging);
+  } catch (error) {
+    failure = { reason: error };
+  }
+  try {
+    await close();
+  } catch (error) {
+    if (failure) throw new AggregateError([failure.reason, error], "ZIP publication and cleanup failed");
+    throw error;
+  }
+  if (failure) throw failure.reason;
+}
+async function publishZip(scope, prepared) {
+  const { fs, signal } = scope.context;
+  const capabilities = await scope.operation(() => fs.capabilitiesFor?.(prepared.output, { signal, create: true }) ?? fs.capabilities);
+  if (capabilities.atomicFilePublication === true && fs.publishFileConditional && !prepared.validate && prepared.stagingName === void 0) {
+    if (capabilities.readOnly === true || capabilities.write === false) fail("ZIP destination is not writable");
+    if (prepared.existing && (!hasZipIdentity(prepared.existing) || !hasZipVersion(prepared.existing))) fail("ZIP conditional publication requires an observed opaque version");
+    const parent = await scope.operation(() => fs.realpath(prepared.parentName, { signal }));
+    if (parent !== prepared.parent) fail("archive parent changed before publication");
+    let size = 0;
+    let completed = false;
+    let active = true;
+    const input = prepared.source ?? { async *[Symbol.asyncIterator]() {
+      yield prepared.bytes ?? new Uint8Array();
+    } };
+    const source = scope.source((async function* () {
+      for await (const chunk of readBytes(input, signal)) {
+        if (!active) fail("ZIP publication source is closed");
+        if (chunk.length > scope.limits.maxArchiveBytes - size) fail("archive byte limit exceeded");
+        size += chunk.length;
+        let owned = chunk;
+        if (prepared.source) await writeFileOutput(scope.context, chunk, async (bytes) => {
+          owned = Uint8Array.from(bytes);
+        });
+        yield owned;
+      }
+      completed = true;
+    })());
+    try {
+      const receipt = await scope.operation(() => fs.publishFileConditional(prepared.output, source, {
+        signal,
+        parent: prepared.parentStat,
+        expected: prepared.existing ?? null,
+        maxBytes: Number.isFinite(scope.limits.maxArchiveBytes) ? scope.limits.maxArchiveBytes : Number.MAX_SAFE_INTEGER,
+        ...prepared.existing && capabilities.permissions !== false ? { mode: prepared.existing.mode & 4095 } : {},
+        ...prepared.mtimeMs === void 0 ? {} : { mtimeMs: prepared.mtimeMs }
+      }));
+      if (!completed || receipt.type !== "file" || receipt.size !== size || !hasZipIdentity(receipt) || !hasZipVersion(receipt) || prepared.existing?.opaqueVersion === receipt.opaqueVersion) fail("Invalid ZIP conditional publication acknowledgement");
+    } finally {
+      active = false;
+      await scope.closeInputs();
+    }
+    return;
+  }
+  if (capabilities.atomicFileStaging !== true && capabilities.trustedOwnedStaging !== true || !fs.publishStagedFile) fail("ZIP publication requires atomic owned file staging");
+  await stageZip(scope, {
+    ...prepared,
+    reservedPath: prepared.output,
+    parent: prepared.stagingParent ?? prepared.parent,
+    parentStat: prepared.stagingParentStat ?? prepared.parentStat
+  }, async (staging) => {
+    if (prepared.validate) await prepared.validate(staging.file.path);
+    if (prepared.stagingName !== void 0) {
+      const current = await scope.operation(() => fs.realpath(prepared.stagingName, { signal }));
+      if (current !== prepared.stagingParent) fail("ZIP temporary path changed before publication");
+    }
+    const parent = await scope.operation(() => fs.realpath(prepared.parentName, { signal }));
+    if (parent !== prepared.parent) fail("archive parent changed before publication");
+    if (prepared.existing && (prepared.existing.nlink ?? 1) > 1) {
+      if (capabilities.atomicFileMutation !== true || !fs.writeFileConditional) fail("ZIP hardlinked archive update requires conditional in-place file mutation");
+      const stagedBytes = await scope.operation(() => fs.readFile(staging.file.path, { signal, ...Number.isFinite(scope.limits.maxArchiveBytes) ? { maxBytes: scope.limits.maxArchiveBytes } : {} }));
+      const receipt = await scope.operation(() => fs.writeFileConditional(prepared.output, stagedBytes, {
+        signal,
+        parent: prepared.parentStat,
+        expected: prepared.existing,
+        ...capabilities.permissions !== false ? { mode: prepared.existing.mode & 4095 } : {},
+        ...prepared.mtimeMs === void 0 ? {} : { mtimeMs: prepared.mtimeMs, atimeMs: prepared.mtimeMs }
+      }));
+      if (prepared.mtimeMs !== void 0 && (receipt.mtimeMs !== prepared.mtimeMs || receipt.atimeMs !== prepared.mtimeMs)) fail("ZIP publication did not retain archive modification time");
+      return;
+    }
+    await scope.operation(() => fs.publishStagedFile(staging, prepared.output, {
+      signal,
+      parent: prepared.parentStat,
+      destination: prepared.existing ?? null
+    }));
+  });
+}
+
+export {
+  hasZipIdentity,
+  sameZipIdentity,
+  unchangedZipSource,
+  safeZipFile,
+  ZipScope,
+  stageZip,
+  publishZip
+};

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

@@ -0,0 +1,22 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-quote.ts
+init_buffer();
+import { ProgramError } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+function quoteAwk(value, budget) {
+  let output = '"';
+  for (const character of value) {
+    budget.step();
+    const code = character.charCodeAt(0);
+    const escaped = character === '"' || character === "\\" ? `\\${character}` : character === "\n" ? "\\n" : character === "	" ? "\\t" : character === "\r" ? "\\r" : code < 32 || code === 127 ? `\\${code.toString(8).padStart(3, "0")}` : character;
+    if (output.length + escaped.length + 1 > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    output += escaped;
+  }
+  return budget.check(output + '"');
+}
+
+export {
+  quoteAwk
+};