@poe-platform/safe-bash 0.1.630 → 0.1.631

package/dist/safe-bash/chunks/chunk-OFT77XIB.js

@@ -0,0 +1,389 @@
+import {
+  filesystemOutputBudgets,
+  openCommandFile
+} from "./chunk-2E4KBFO6.js";
+import {
+  createOutputOperation
+} from "./chunk-CDBQXRWL.js";
+import {
+  FsError,
+  createBytePipe,
+  outputFailure
+} from "./chunk-WPIOO4NX.js";
+import {
+  init_platform
+} from "./chunk-O2EVBRKF.js";
+
+// packages/safe-bash/src/contracts/filesystem-output.ts
+init_platform();
+async function writeFileOutput(context, bytes, write) {
+  context.signal.throwIfAborted();
+  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);
+  let pending;
+  const destination = { write(chunk) {
+    context.signal.throwIfAborted();
+    return pending = (async () => {
+      await write(chunk);
+    })();
+  } };
+  try {
+    await (budget?.sinkBudget(destination) ?? destination).write(bytes);
+  } catch (error) {
+    await pending?.catch(() => {
+    });
+    context.signal.throwIfAborted();
+    throw error;
+  }
+  context.signal.throwIfAborted();
+}
+async function openDescriptorOutput(context, path, options) {
+  const { flag, mode } = options;
+  const { cleanupFailurePrioritySignal } = context;
+  if (flag !== "w" && flag !== "a" && flag !== "wx") throw new TypeError("Invalid descriptor output flag");
+  const controller = new AbortController();
+  const signal = AbortSignal.any([context.signal, controller.signal]);
+  const cleanups = [];
+  let descriptor;
+  let accepting = true;
+  let completed = false;
+  let failure;
+  let retirementFailure;
+  let closeFailureAcknowledged = false;
+  let writes = Promise.resolve();
+  let closing;
+  let finishing;
+  let aborting;
+  let acquired;
+  const acquisition = new Promise((resolve) => {
+    acquired = resolve;
+  });
+  const check = () => {
+    context.signal.throwIfAborted();
+    if (failure) throw failure.reason;
+    signal.throwIfAborted();
+  };
+  const retire = () => {
+    accepting = false;
+    closing ??= (async () => {
+      await acquisition;
+      await writes;
+      try {
+        await descriptor?.close();
+      } catch (reason) {
+        retirementFailure = { reason };
+        throw reason;
+      } finally {
+        context.signal.removeEventListener("abort", interrupted);
+      }
+    })();
+    void closing.catch(() => {
+    });
+    return closing;
+  };
+  const interrupted = () => {
+    void retire().catch(() => {
+    });
+  };
+  const cleanup = async () => {
+    await retire().catch(() => {
+    });
+    let cleanupFailure;
+    for (const close of cleanups) {
+      try {
+        await close();
+      } catch (reason) {
+        cleanupFailure ??= { reason };
+      }
+    }
+    (cleanupFailurePrioritySignal ?? context.signal).throwIfAborted();
+    if (retirementFailure && !closeFailureAcknowledged && (!failure || cleanupFailurePrioritySignal !== void 0 && failure.cancellation)) throw retirementFailure.reason;
+    if (!failure && cleanupFailure && (cleanupFailurePrioritySignal === void 0 || !signal.aborted)) throw cleanupFailure.reason;
+  };
+  const registerCleanup = (close) => {
+    cleanups.push(close);
+  };
+  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);
+  if (budget) filesystemOutputBudgets.set(registerCleanup, budget);
+  try {
+    context.registerCleanup?.(cleanup);
+    context.signal.addEventListener("abort", interrupted, { once: true });
+    check();
+    const capabilities = await context.fs.capabilitiesFor?.(path, { signal }) ?? context.fs.capabilities;
+    check();
+    if (!accepting) throw new FsError("EBADF", { path, syscall: "open" });
+    if (capabilities.readOnly === true) throw new FsError("EROFS", { path, syscall: "open" });
+    if (flag === "a" ? capabilities.append === false : capabilities.write === false) throw new FsError("ENOTSUP", { path, syscall: "open" });
+    if (flag === "wx" && capabilities.exclusiveCreate !== true) throw new FsError("ENOTSUP", { path, syscall: "open" });
+    descriptor = await openCommandFile({ fs: context.fs, signal, registerCleanup, cleanupFailurePrioritySignal: cleanupFailurePrioritySignal ?? context.signal }, path, {
+      access: "write",
+      creation: flag === "wx" ? "exclusive" : "ifMissing",
+      truncate: flag === "w",
+      append: flag === "a",
+      ...mode === void 0 ? {} : { mode }
+    });
+    acquired();
+    check();
+    if (!accepting) throw new FsError("EBADF", { path, syscall: "open" });
+    const retained = descriptor;
+    const probeRead = retained.capabilities.readObservation === true ? retained.probeRead : void 0;
+    if (retained.capabilities.readObservation === true && typeof probeRead !== "function") throw new FsError("ENOTSUP", { path, syscall: "probeRead" });
+    const admit = (syscall, forwarded, action) => {
+      try {
+        const operationSignal = forwarded.signal;
+        context.signal.throwIfAborted();
+        signal.throwIfAborted();
+        operationSignal?.throwIfAborted();
+        if (!accepting) throw new FsError("EBADF", { path, syscall });
+        return action(operationSignal === void 0 ? {} : { signal: operationSignal });
+      } catch (reason) {
+        return Promise.reject(reason);
+      }
+    };
+    const exposed = {
+      capabilities: retained.capabilities,
+      ...probeRead === void 0 ? {} : { probeRead: (forwarded = {}) => admit("probeRead", forwarded, (supplied) => probeRead.call(retained, supplied)) },
+      ...retained.getPosition ? { getPosition: (forwarded = {}) => admit("getPosition", forwarded, (supplied) => retained.getPosition(supplied)) } : {},
+      stat: (forwarded = {}) => admit("fstat", forwarded, (supplied) => retained.stat(supplied)),
+      read: (buffer, position, forwarded = {}) => admit("read", forwarded, (supplied) => retained.read(buffer, position, supplied)),
+      write: (buffer, position, forwarded = {}) => admit("write", forwarded, (supplied) => retained.write(buffer, position, supplied)),
+      truncate: (length, forwarded = {}) => admit("ftruncate", forwarded, (supplied) => retained.truncate(length, supplied)),
+      sync: (dataOnly, forwarded = {}) => admit(dataOnly ? "fdatasync" : "fsync", forwarded, (supplied) => retained.sync(dataOnly, supplied)),
+      close: retire,
+      acknowledgeCloseFailure(reason) {
+        const acknowledged = retained.acknowledgeCloseFailure(reason);
+        if (acknowledged) closeFailureAcknowledged = true;
+        return acknowledged;
+      }
+    };
+    const write = (chunk) => {
+      try {
+        check();
+        if (!accepting) throw new FsError("EBADF", { path, syscall: "write" });
+        if (!(chunk instanceof Uint8Array)) throw new TypeError("Byte sinks require Uint8Array chunks");
+      } catch (reason) {
+        return Promise.reject(reason);
+      }
+      const writing = writes.then(async () => {
+        try {
+          check();
+          for (let offset = 0; offset < chunk.byteLength; ) {
+            const end = Math.min(offset + 64 * 1024, chunk.byteLength);
+            const count = await descriptor.write(chunk.subarray(offset, end), null);
+            check();
+            if (!count) throw new FsError("EIO", { path, syscall: "write", message: "descriptor write made no progress" });
+            offset += count;
+          }
+        } catch (reason) {
+          failure ??= { reason: context.signal.aborted ? context.signal.reason : reason, cancellation: context.signal.aborted };
+          controller.abort(failure.reason);
+          check();
+        }
+      });
+      writes = writing.then(() => {
+      }, () => {
+      });
+      return writing;
+    };
+    const abort = (reason) => {
+      if (!completed && !retirementFailure) {
+        failure ??= { reason, cancellation: context.signal.aborted };
+        controller.abort(failure.reason);
+      }
+      return aborting ??= cleanup();
+    };
+    return {
+      descriptor: exposed,
+      signal,
+      sink: { write, [outputFailure]: abort, ownedOutput: { consumerClosed: controller.signal, write } },
+      finish() {
+        const retired = retire();
+        finishing ??= (async () => {
+          let closeFailure;
+          try {
+            await retired;
+          } catch (reason) {
+            closeFailure = { reason };
+          }
+          check();
+          if (closeFailure) throw closeFailure.reason;
+          completed = true;
+        })();
+        return finishing;
+      },
+      abort
+    };
+  } catch (reason) {
+    failure ??= { reason, cancellation: context.signal.aborted };
+    acquired();
+    await cleanup().catch(() => {
+    });
+    context.signal.throwIfAborted();
+    throw failure.reason;
+  }
+}
+async function openFileOutput(context, path, options, incremental) {
+  if (typeof options !== "string") {
+    if (options.descriptor !== void 0 && typeof options.descriptor !== "boolean") throw new TypeError("Invalid descriptor output option");
+    if (options.descriptor === true) return openDescriptorOutput(context, path, options);
+  }
+  const { flag, mode } = typeof options === "string" ? { flag: options, mode: void 0 } : options;
+  let pipe;
+  let task;
+  let completed = false;
+  let ended = false;
+  let closing = false;
+  let failure;
+  const consumer = new AbortController();
+  let writes = Promise.resolve();
+  let acknowledge;
+  const acknowledgeWrite = () => {
+    const accepted = acknowledge;
+    acknowledge = void 0;
+    accepted?.();
+  };
+  let ready;
+  const opened = new Promise((resolve) => {
+    ready = resolve;
+  });
+  const destination = {
+    [outputFailure]: (reason) => operation.abort(reason),
+    async write(chunk) {
+      if (closing) throw new FsError("EBADF", { path, syscall: "write" });
+      const writing = writes.then(async () => {
+        for (let offset = 0; offset < chunk.byteLength; offset += 64 * 1024) {
+          const accepted = new Promise((resolve) => {
+            acknowledge = resolve;
+          });
+          await pipe.writable.write(chunk.subarray(offset, offset + 64 * 1024));
+          await accepted;
+          if (failure) throw failure.reason;
+          operation.signal.throwIfAborted();
+        }
+      });
+      writes = writing.catch(() => {
+      });
+      await writing;
+    }
+  };
+  const budget = context.outputBudget !== "independent" && context.registerCleanup ? filesystemOutputBudgets.get(context.registerCleanup) : void 0;
+  const operation = createOutputOperation(context, budget?.sinkBudget(destination) ?? destination);
+  operation.registerCleanup(async () => {
+    closing = true;
+    if (!completed) {
+      void operation.abort(operation.signal.aborted ? operation.signal.reason : new FsError("ECANCELED", { path, syscall: "write" }));
+      await pipe?.abort(operation.signal.reason);
+    }
+    await task?.catch(() => {
+    });
+    await writes;
+  });
+  try {
+    pipe = createBytePipe({ highWaterMark: 1, signal: operation.signal });
+    let reading = false;
+    const source = {
+      [Symbol.asyncIterator]() {
+        return (async function* () {
+          reading = true;
+          ready();
+          for await (const chunk of pipe.readable) {
+            yield chunk;
+            acknowledgeWrite();
+          }
+          operation.signal.throwIfAborted();
+          ended = true;
+        })();
+      }
+    };
+    task = (async () => {
+      const { fs } = context;
+      const signal = operation.signal;
+      signal.throwIfAborted();
+      const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;
+      if (capabilities.readOnly === true) throw new FsError("EROFS", { path, syscall: "write" });
+      if (incremental && (flag === "wx" || mode !== void 0)) throw new FsError("ENOTSUP", { path, syscall: "write", message: "incremental callback cannot honor exclusive creation or initial mode" });
+      if (flag === "wx") {
+        if (capabilities.exclusiveCreate !== true) throw new FsError("ENOTSUP", { path, syscall: "write", message: "exclusive creation is not supported" });
+      } else {
+        try {
+          await fs.access(path, 2, { signal });
+        } catch (error) {
+          signal.throwIfAborted();
+          if (!(error instanceof FsError) || error.code !== "ENOENT" && error.code !== "ENOTSUP") throw error;
+        }
+      }
+      signal.throwIfAborted();
+      const fsOptions = { signal, ...mode === void 0 ? {} : { mode } };
+      const streaming = flag === "a" ? capabilities.streamingAppend ?? capabilities.streamingWrite : capabilities.streamingWrite;
+      if ((!incremental || capabilities.descriptorWriteStream === true) && streaming !== false && fs.writeStream) {
+        try {
+          await fs.writeStream(path, source, { ...fsOptions, flag });
+          if (!ended) throw new FsError("EIO", { path, message: "Streaming writer returned before consuming output" });
+          return;
+        } catch (error) {
+          signal.throwIfAborted();
+          if (flag === "wx" || reading || !(error instanceof FsError) || error.code !== "ENOTSUP") throw error;
+        }
+      }
+      if (flag === "wx") throw new FsError("ENOTSUP", { path, syscall: "writeStream", message: "exclusive output requires streaming support" });
+      if (flag === "w" && capabilities.write === false) throw new FsError("ENOTSUP", { path, syscall: "writeFile" });
+      if ((!incremental || flag === "a") && capabilities.append === false) throw new FsError("ENOTSUP", { path, syscall: "appendFile" });
+      const sink = incremental ? await incremental() : await (async () => {
+        if (flag === "a") await fs.appendFile(path, new Uint8Array(), fsOptions);
+        else await fs.writeFile(path, new Uint8Array(), { ...fsOptions, flag });
+        return { write: (chunk) => fs.appendFile(path, chunk, fsOptions) };
+      })();
+      for await (const chunk of source) {
+        signal.throwIfAborted();
+        await sink.write(chunk);
+      }
+    })();
+    void task.then(acknowledgeWrite, (error) => {
+      failure = { reason: error };
+      acknowledgeWrite();
+      if (!operation.signal.aborted) consumer.abort(error);
+      void operation.abort(error).catch(() => {
+      });
+    });
+    await Promise.race([opened, task]);
+    operation.signal.throwIfAborted();
+    const write = async (chunk) => {
+      try {
+        await operation.output.write(chunk);
+      } catch (error) {
+        throw failure ? failure.reason : error;
+      }
+    };
+    return {
+      signal: operation.signal,
+      sink: {
+        [outputFailure]: destination[outputFailure],
+        ownedOutput: { consumerClosed: consumer.signal, write },
+        write
+      },
+      async finish() {
+        closing = true;
+        try {
+          await writes;
+          await pipe.close();
+          await task;
+          operation.signal.throwIfAborted();
+          completed = true;
+        } catch (error) {
+          throw failure ? failure.reason : error;
+        } finally {
+          await operation.close();
+        }
+      },
+      abort: (reason) => operation.abort(reason)
+    };
+  } catch (error) {
+    await operation.abort(error);
+    throw error;
+  }
+}
+
+export {
+  writeFileOutput,
+  openFileOutput
+};
+//# sourceMappingURL=chunk-OFT77XIB.js.map

package/dist/safe-bash/chunks/chunk-OFT77XIB.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/contracts/filesystem-output.ts"],
+  "sourcesContent": ["import { FsError } from \"./errors.js\";\nimport type { CommandContext } from \"./command.js\";\nimport type { FsOptions } from \"./filesystem.js\";\nimport { createBytePipe, outputFailure, type BytePipe, type ByteSink, type ByteSource } from \"./io.js\";\nimport { createOutputOperation } from \"./output.js\";\n\nimport { filesystemOutputBudgets, type FileOutputContext } from \"./filesystem-output-budget.js\";\nimport { openCommandFile, type CommandFileDescriptor } from \"./filesystem-descriptor.js\";\nexport { bindFileOutputBudget, assertCountedFileOutput, writeFileOutputCounted } from \"./filesystem-output-budget.js\";\nexport type { CountedFileWrite, FileOutputContext } from \"./filesystem-output-budget.js\";\n\n\nexport async function writeFileOutput(context: Pick<CommandContext, \"signal\" | \"registerCleanup\">, bytes: Uint8Array, write: (bytes: Uint8Array) => Promise<void>): Promise<void> {\n  context.signal.throwIfAborted();\n  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);\n  let pending: Promise<void> | undefined;\n  const destination: ByteSink = { write(chunk) {\n    context.signal.throwIfAborted();\n    return pending = (async () => { await write(chunk); })();\n  } };\n  try { await (budget?.sinkBudget(destination) ?? destination).write(bytes); }\n  catch (error) {\n    // Shell sink cancellation may win its race before the direct host call.\n    // Keep the original awaited-write lifetime without a retained cleanup hook.\n    await pending?.catch(() => {});\n    context.signal.throwIfAborted();\n    throw error;\n  }\n  context.signal.throwIfAborted();\n}\n\nexport interface FileOutput {\n  readonly sink: ByteSink;\n  readonly signal: AbortSignal;\n  readonly descriptor?: CommandFileDescriptor;\n  finish(): Promise<void>;\n  abort(reason: unknown): Promise<void>;\n}\n\nexport interface FileOutputOpenOptions {\n  readonly flag: \"w\" | \"a\" | \"wx\";\n  readonly mode?: number;\n  readonly descriptor?: boolean;\n}\n\nasync function openDescriptorOutput(context: FileOutputContext, path: string, options: FileOutputOpenOptions): Promise<FileOutput> {\n  const { flag, mode } = options;\n  const { cleanupFailurePrioritySignal } = context;\n  if (flag !== \"w\" && flag !== \"a\" && flag !== \"wx\") throw new TypeError(\"Invalid descriptor output flag\");\n  const controller = new AbortController();\n  const signal = AbortSignal.any([context.signal, controller.signal]);\n  const cleanups: (() => void | Promise<void>)[] = [];\n  let descriptor: CommandFileDescriptor | undefined;\n  let accepting = true;\n  let completed = false;\n  let failure: { reason: unknown; cancellation: boolean } | undefined;\n  let retirementFailure: { reason: unknown } | undefined;\n  let closeFailureAcknowledged = false;\n  let writes: Promise<void> = Promise.resolve();\n  let closing: Promise<void> | undefined;\n  let finishing: Promise<void> | undefined;\n  let aborting: Promise<void> | undefined;\n  let acquired!: () => void;\n  const acquisition = new Promise<void>(resolve => { acquired = resolve; });\n  const check = (): void => {\n    context.signal.throwIfAborted();\n    if (failure) throw failure.reason;\n    signal.throwIfAborted();\n  };\n  const retire = (): Promise<void> => {\n    accepting = false;\n    closing ??= (async () => {\n      await acquisition;\n      await writes;\n      try { await descriptor?.close(); }\n      catch (reason) { retirementFailure = { reason }; throw reason; }\n      finally { context.signal.removeEventListener(\"abort\", interrupted); }\n    })();\n    void closing.catch(() => {});\n    return closing;\n  };\n  const interrupted = (): void => { void retire().catch(() => {}); };\n  const cleanup = async (): Promise<void> => {\n    await retire().catch(() => {});\n    let cleanupFailure: { reason: unknown } | undefined;\n    for (const close of cleanups) {\n      try { await close(); } catch (reason) { cleanupFailure ??= { reason }; }\n    }\n    (cleanupFailurePrioritySignal ?? context.signal).throwIfAborted();\n    if (retirementFailure && !closeFailureAcknowledged && (!failure || cleanupFailurePrioritySignal !== undefined && failure.cancellation)) throw retirementFailure.reason;\n    if (!failure && cleanupFailure && (cleanupFailurePrioritySignal === undefined || !signal.aborted)) throw cleanupFailure.reason;\n  };\n  const registerCleanup = (close: () => void | Promise<void>): void => { cleanups.push(close); };\n  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);\n  if (budget) filesystemOutputBudgets.set(registerCleanup, budget);\n  try {\n    context.registerCleanup?.(cleanup);\n    context.signal.addEventListener(\"abort\", interrupted, { once: true });\n    check();\n    const capabilities = await context.fs.capabilitiesFor?.(path, { signal }) ?? context.fs.capabilities;\n    check();\n    if (!accepting) throw new FsError(\"EBADF\", { path, syscall: \"open\" });\n    if (capabilities.readOnly === true) throw new FsError(\"EROFS\", { path, syscall: \"open\" });\n    if (flag === \"a\" ? capabilities.append === false : capabilities.write === false) throw new FsError(\"ENOTSUP\", { path, syscall: \"open\" });\n    if (flag === \"wx\" && capabilities.exclusiveCreate !== true) throw new FsError(\"ENOTSUP\", { path, syscall: \"open\" });\n    descriptor = await openCommandFile({ fs: context.fs, signal, registerCleanup, cleanupFailurePrioritySignal: cleanupFailurePrioritySignal ?? context.signal }, path, {\n      access: \"write\", creation: flag === \"wx\" ? \"exclusive\" : \"ifMissing\",\n      truncate: flag === \"w\", append: flag === \"a\", ...(mode === undefined ? {} : { mode }),\n    });\n    acquired();\n    check();\n    if (!accepting) throw new FsError(\"EBADF\", { path, syscall: \"open\" });\n    const retained = descriptor;\n    const probeRead = retained.capabilities.readObservation === true ? retained.probeRead : undefined;\n    if (retained.capabilities.readObservation === true && typeof probeRead !== \"function\") throw new FsError(\"ENOTSUP\", { path, syscall: \"probeRead\" });\n    const admit = <Result>(syscall: string, forwarded: FsOptions, action: (options: FsOptions) => Promise<Result>): Promise<Result> => {\n      try {\n        const operationSignal = forwarded.signal;\n        context.signal.throwIfAborted();\n        signal.throwIfAborted();\n        operationSignal?.throwIfAborted();\n        if (!accepting) throw new FsError(\"EBADF\", { path, syscall });\n        return action(operationSignal === undefined ? {} : { signal: operationSignal });\n      } catch (reason) { return Promise.reject(reason); }\n    };\n    const exposed: CommandFileDescriptor = {\n      capabilities: retained.capabilities,\n      ...(probeRead === undefined ? {} : { probeRead: (forwarded: FsOptions = {}) => admit(\"probeRead\", forwarded, supplied => probeRead.call(retained, supplied)) }),\n      ...(retained.getPosition ? { getPosition: (forwarded = {}) => admit(\"getPosition\", forwarded, supplied => retained.getPosition!(supplied)) } : {}),\n      stat: (forwarded = {}) => admit(\"fstat\", forwarded, supplied => retained.stat(supplied)),\n      read: (buffer, position, forwarded = {}) => admit(\"read\", forwarded, supplied => retained.read(buffer, position, supplied)),\n      write: (buffer, position, forwarded = {}) => admit(\"write\", forwarded, supplied => retained.write(buffer, position, supplied)),\n      truncate: (length, forwarded = {}) => admit(\"ftruncate\", forwarded, supplied => retained.truncate(length, supplied)),\n      sync: (dataOnly, forwarded = {}) => admit(dataOnly ? \"fdatasync\" : \"fsync\", forwarded, supplied => retained.sync(dataOnly, supplied)),\n      close: retire,\n      acknowledgeCloseFailure(reason) {\n        const acknowledged = retained.acknowledgeCloseFailure(reason);\n        if (acknowledged) closeFailureAcknowledged = true;\n        return acknowledged;\n      },\n    };\n    const write = (chunk: Uint8Array): Promise<void> => {\n      try {\n        check();\n        if (!accepting) throw new FsError(\"EBADF\", { path, syscall: \"write\" });\n        if (!(chunk instanceof Uint8Array)) throw new TypeError(\"Byte sinks require Uint8Array chunks\");\n      } catch (reason) { return Promise.reject(reason); }\n      const writing = writes.then(async () => {\n        try {\n          check();\n          for (let offset = 0; offset < chunk.byteLength;) {\n            const end = Math.min(offset + 64 * 1024, chunk.byteLength);\n            const count = await descriptor!.write(chunk.subarray(offset, end), null);\n            check();\n            if (!count) throw new FsError(\"EIO\", { path, syscall: \"write\", message: \"descriptor write made no progress\" });\n            offset += count;\n          }\n        } catch (reason) {\n          failure ??= { reason: context.signal.aborted ? context.signal.reason : reason, cancellation: context.signal.aborted };\n          controller.abort(failure.reason);\n          check();\n        }\n      });\n      writes = writing.then(() => {}, () => {});\n      return writing;\n    };\n    const abort = (reason: unknown): Promise<void> => {\n      if (!completed && !retirementFailure) {\n        failure ??= { reason, cancellation: context.signal.aborted };\n        controller.abort(failure.reason);\n      }\n      return aborting ??= cleanup();\n    };\n    return {\n      descriptor: exposed, signal,\n      sink: { write, [outputFailure]: abort, ownedOutput: { consumerClosed: controller.signal, write } },\n      finish() {\n        const retired = retire();\n        finishing ??= (async () => {\n          let closeFailure: { reason: unknown } | undefined;\n          try { await retired; } catch (reason) { closeFailure = { reason }; }\n          check();\n          if (closeFailure) throw closeFailure.reason;\n          completed = true;\n        })();\n        return finishing;\n      },\n      abort,\n    };\n  } catch (reason) {\n    failure ??= { reason, cancellation: context.signal.aborted };\n    acquired();\n    await cleanup().catch(() => {});\n    context.signal.throwIfAborted();\n    throw failure.reason;\n  }\n}\n\nexport async function openFileOutput(context: FileOutputContext, path: string, options: \"w\" | \"a\" | FileOutputOpenOptions, incremental?: () => Promise<ByteSink>): Promise<FileOutput> {\n  if (typeof options !== \"string\") {\n    if (options.descriptor !== undefined && typeof options.descriptor !== \"boolean\") throw new TypeError(\"Invalid descriptor output option\");\n    if (options.descriptor === true) return openDescriptorOutput(context, path, options);\n  }\n  const { flag, mode } = typeof options === \"string\" ? { flag: options, mode: undefined } : options;\n  let pipe: BytePipe | undefined;\n  let task: Promise<void> | undefined;\n  let completed = false;\n  let ended = false;\n  let closing = false;\n  let failure: { reason: unknown } | undefined;\n  const consumer = new AbortController();\n  let writes = Promise.resolve();\n  let acknowledge: (() => void) | undefined;\n  const acknowledgeWrite = (): void => {\n    const accepted = acknowledge;\n    acknowledge = undefined;\n    accepted?.();\n  };\n  let ready!: () => void;\n  const opened = new Promise<void>(resolve => { ready = resolve; });\n  const destination: ByteSink = {\n    [outputFailure]: reason => operation.abort(reason),\n    async write(chunk) {\n      if (closing) throw new FsError(\"EBADF\", { path, syscall: \"write\" });\n      const writing = writes.then(async () => {\n        for (let offset = 0; offset < chunk.byteLength; offset += 64 * 1024) {\n          const accepted = new Promise<void>(resolve => { acknowledge = resolve; });\n          await pipe!.writable.write(chunk.subarray(offset, offset + 64 * 1024));\n          await accepted;\n          if (failure) throw failure.reason;\n          operation.signal.throwIfAborted();\n        }\n      });\n      writes = writing.catch(() => {});\n      await writing;\n    },\n  };\n  const budget = context.outputBudget !== \"independent\" && context.registerCleanup\n    ? filesystemOutputBudgets.get(context.registerCleanup) : undefined;\n  const operation = createOutputOperation(context, budget?.sinkBudget(destination) ?? destination);\n  operation.registerCleanup(async () => {\n    closing = true;\n    if (!completed) {\n      void operation.abort(operation.signal.aborted ? operation.signal.reason : new FsError(\"ECANCELED\", { path, syscall: \"write\" }));\n      await pipe?.abort(operation.signal.reason);\n    }\n    await task?.catch(() => {});\n    await writes;\n  });\n  try {\n    pipe = createBytePipe({ highWaterMark: 1, signal: operation.signal });\n    let reading = false;\n    const source: ByteSource = {\n      [Symbol.asyncIterator]() {\n        return (async function* () {\n          reading = true;\n          ready();\n          for await (const chunk of pipe!.readable) {\n            yield chunk;\n            acknowledgeWrite();\n          }\n          operation.signal.throwIfAborted();\n          ended = true;\n        })();\n      },\n    };\n    task = (async () => {\n      const { fs } = context;\n      const signal = operation.signal;\n      signal.throwIfAborted();\n      const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;\n      if (capabilities.readOnly === true) throw new FsError(\"EROFS\", { path, syscall: \"write\" });\n      if (incremental && (flag === \"wx\" || mode !== undefined)) throw new FsError(\"ENOTSUP\", { path, syscall: \"write\", message: \"incremental callback cannot honor exclusive creation or initial mode\" });\n      if (flag === \"wx\") {\n        if (capabilities.exclusiveCreate !== true) throw new FsError(\"ENOTSUP\", { path, syscall: \"write\", message: \"exclusive creation is not supported\" });\n      } else {\n        try { await fs.access(path, 2, { signal }); }\n        catch (error) {\n          signal.throwIfAborted();\n          if (!(error instanceof FsError) || error.code !== \"ENOENT\" && error.code !== \"ENOTSUP\") throw error;\n        }\n      }\n      signal.throwIfAborted();\n      const fsOptions = { signal, ...(mode === undefined ? {} : { mode }) };\n      const streaming = flag === \"a\" ? capabilities.streamingAppend ?? capabilities.streamingWrite : capabilities.streamingWrite;\n      if ((!incremental || capabilities.descriptorWriteStream === true) && streaming !== false && fs.writeStream) {\n        try {\n          await fs.writeStream(path, source, { ...fsOptions, flag });\n          if (!ended) throw new FsError(\"EIO\", { path, message: \"Streaming writer returned before consuming output\" });\n          return;\n        } catch (error) {\n          signal.throwIfAborted();\n          if (flag === \"wx\" || reading || !(error instanceof FsError) || error.code !== \"ENOTSUP\") throw error;\n        }\n      }\n      if (flag === \"wx\") throw new FsError(\"ENOTSUP\", { path, syscall: \"writeStream\", message: \"exclusive output requires streaming support\" });\n      if (flag === \"w\" && capabilities.write === false) throw new FsError(\"ENOTSUP\", { path, syscall: \"writeFile\" });\n      if ((!incremental || flag === \"a\") && capabilities.append === false) throw new FsError(\"ENOTSUP\", { path, syscall: \"appendFile\" });\n      const sink = incremental ? await incremental() : await (async (): Promise<ByteSink> => {\n        if (flag === \"a\") await fs.appendFile(path, new Uint8Array(), fsOptions);\n        else await fs.writeFile(path, new Uint8Array(), { ...fsOptions, flag });\n        return { write: chunk => fs.appendFile(path, chunk, fsOptions) };\n      })();\n      for await (const chunk of source) {\n        signal.throwIfAborted();\n        await sink.write(chunk);\n      }\n    })();\n    void task.then(acknowledgeWrite, error => {\n      failure = { reason: error };\n      acknowledgeWrite();\n      if (!operation.signal.aborted) consumer.abort(error);\n      void operation.abort(error).catch(() => {});\n    });\n    await Promise.race([opened, task]);\n    operation.signal.throwIfAborted();\n    const write = async (chunk: Uint8Array): Promise<void> => {\n      try { await operation.output.write(chunk); }\n      catch (error) { throw failure ? failure.reason : error; }\n    };\n    return {\n      signal: operation.signal,\n      sink: {\n        [outputFailure]: destination[outputFailure]!,\n        ownedOutput: { consumerClosed: consumer.signal, write },\n        write,\n      },\n      async finish() {\n        closing = true;\n        try {\n          await writes;\n          await pipe!.close();\n          await task;\n          operation.signal.throwIfAborted();\n          completed = true;\n        } catch (error) { throw failure ? failure.reason : error; }\n        finally { await operation.close(); }\n      },\n      abort: reason => operation.abort(reason),\n    };\n  } catch (error) {\n    await operation.abort(error);\n    throw error;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/safe-bash/chunks/{chunk-PCLOK32J.js → chunk-PC6BEIAF.js}

@@ -1,23 +1,27 @@
 import {
   createOutputOperation
-} from "./chunk-RNKTWFEM.js";
+} from "./chunk-CDBQXRWL.js";
 import {
   PublicDiagnostic,
+  publicDiagnosticMessage
+} from "./chunk-3E5M2WEL.js";
+import {
+  yieldTurn
+} from "./chunk-THXJ6CLF.js";
+import {
   getCommandArguments,
-  publicDiagnosticMessage,
   shellValueByteLength,
-  shellValueBytes,
-  yieldTurn
-} from "./chunk-UYX72YHY.js";
+  shellValueBytes
+} from "./chunk-CHHAB5SS.js";
 import {
   resolvePath
-} from "./chunk-DPJWEGIX.js";
+} from "./chunk-JLBIUYT3.js";
 import {
   FsError
-} from "./chunk-CXMIIXJA.js";
+} from "./chunk-WPIOO4NX.js";
 import {
   init_platform
-} from "./chunk-2KL6W6NB.js";
+} from "./chunk-O2EVBRKF.js";
 
 // packages/safe-bash/src/commands/pr/index.ts
 init_platform();
@@ -1272,4 +1276,4 @@ export {
   createPrCommands,
   prCommands
 };
-//# sourceMappingURL=chunk-PCLOK32J.js.map
+//# sourceMappingURL=chunk-PC6BEIAF.js.map