@poe-platform/safe-bash 0.1.630 → 0.1.631

package/README.md

@@ -231,6 +231,7 @@ For SafeJS host integration, `makeSafeJsShellModule` exposes shell execution and
 | `new Shell(...)` option | Behavior |
 | --- | --- |
 | `fs` | Required filesystem; no implicit host access. |
+| `deviceView` | `"default"` (the default) adds synthetic `/dev/null` and shadows ordinary backing files there. `"provided"` uses the supplied filesystem's paths and capabilities, including an `exec` filesystem override, without adding devices. Nested commands retain the selected view. |
 | `cwd` | Initial virtual directory; defaults to `/`. |
 | `env` | Initial exported variables; defaults to an empty map, with `PWD` set from `cwd`. No host environment inheritance. Never pass host `process.env` or any secret-bearing object: everything in `env` is readable by executed scripts (`env`, `printenv`, `$VAR`), and on Cloudflare Workers with `nodejs_compat` `process.env` contains the Worker's secret bindings. The shell warns only for the identical host `process.env` object, not copies, and does not filter values. |
 | `commands` | Existing `CommandRegistry`; defaults to an empty registry. |

package/dist/office-package/compression.d.ts

@@ -0,0 +1,19 @@
+import { type CodecRuntime, type ByteSource } from "./runtime.js";
+export interface CodecInput {
+    chunk(): Promise<Uint8Array | undefined>;
+    restore(bytes: Uint8Array): void;
+}
+export interface CodecOptions {
+    readonly mode: "gzip" | "gunzip" | "inflate-raw" | "deflate-raw";
+    readonly chunkSize?: number;
+    readonly level?: number;
+    readonly onFailure?: (error: unknown) => void;
+}
+export interface CompressionReader extends CodecInput {
+    close(): Promise<void>;
+}
+export interface CompressionCodec {
+    CodecReader: new (source: ByteSource, signal: AbortSignal) => CompressionReader;
+    codec(input: CodecInput, options: CodecOptions, signal: AbortSignal): ByteSource;
+}
+export declare function createCompressionCodec(runtime?: CodecRuntime): CompressionCodec;

package/dist/office-package/compression.js

@@ -0,0 +1,186 @@
+import { ZStream, Z_OK, Z_STREAM_END, Z_BUF_ERROR, Z_DATA_ERROR, Z_NO_FLUSH, Z_FINISH, zlibDeflateInit2, zlibDeflate, zlibDeflateEnd, zlibInflateInit2, zlibInflate, zlibInflateReset, zlibInflateEnd } from "pako";
+import { CodecError, defaultRuntime } from "./runtime.js";
+export function createCompressionCodec(runtime = defaultRuntime) {
+    const { yieldTurn, readBytes, diagnostic } = runtime;
+    class CodecReader {
+        signal;
+        iterator;
+        pending = new Uint8Array();
+        pulls = 0;
+        closing;
+        constructor(source, signal) {
+            this.signal = signal;
+            this.iterator = readBytes(source, signal);
+        }
+        async chunk() {
+            this.signal.throwIfAborted();
+            if (this.closing)
+                return undefined;
+            if (this.pending.length) {
+                const bytes = this.pending;
+                this.pending = new Uint8Array();
+                return bytes;
+            }
+            for (;;) {
+                if (++this.pulls % 64 === 0)
+                    await yieldTurn(this.signal);
+                const next = await this.iterator.next();
+                if (next.done)
+                    return undefined;
+                if (next.value.length)
+                    return next.value;
+            }
+        }
+        restore(bytes) {
+            this.pending = bytes;
+        }
+        close() {
+            this.pending = new Uint8Array();
+            return (this.closing ??= this.iterator.return(undefined).then(() => { }));
+        }
+    }
+    function codecError(status, message) {
+        const error = new Error(message || "internal error");
+        Object.assign(error, {
+            code: status === Z_BUF_ERROR
+                ? "Z_BUF_ERROR"
+                : status === Z_DATA_ERROR
+                    ? "Z_DATA_ERROR"
+                    : "Z_STREAM_ERROR"
+        });
+        return diagnostic(error);
+    }
+    async function* codec(input, options, signal) {
+        signal.throwIfAborted();
+        const requestedSize = options.chunkSize ?? 64 * 1024;
+        if (!Number.isSafeInteger(requestedSize) || requestedSize <= 0)
+            throw new RangeError("invalid codec chunk size");
+        const chunkSize = Math.min(requestedSize, 64 * 1024);
+        let output = new Uint8Array(chunkSize);
+        const encoding = options.mode === "gzip" || options.mode === "deflate-raw";
+        const stream = new ZStream();
+        const initialized = encoding
+            ? zlibDeflateInit2(stream, options.level ?? 6, 8, options.mode === "deflate-raw" ? -15 : 31, 8, 0, true)
+            : zlibInflateInit2(stream, options.mode === "inflate-raw" ? -15 : 31);
+        if (initialized !== Z_OK) {
+            if (encoding)
+                zlibDeflateEnd(stream);
+            else
+                zlibInflateEnd(stream);
+            throw codecError(initialized, stream.msg);
+        }
+        let current = new Uint8Array();
+        let offset = 0;
+        let eof = false;
+        let needsInput = true;
+        let memberEnded = false;
+        let calls = 0;
+        let work = 0;
+        let filled = 0;
+        try {
+            for (;;) {
+                signal.throwIfAborted();
+                if (needsInput || memberEnded) {
+                    if (offset === current.length && !eof) {
+                        let ready = false;
+                        const pending = input.chunk().then((value) => {
+                            ready = true;
+                            return value;
+                        }, (error) => {
+                            options.onFailure?.(error);
+                            throw error;
+                        });
+                        if (filled) {
+                            const turn = new AbortController();
+                            try {
+                                await Promise.race([pending, yieldTurn(AbortSignal.any([signal, turn.signal]))]);
+                            }
+                            finally {
+                                turn.abort();
+                            }
+                            if (!ready) {
+                                yield output.subarray(0, filled);
+                                output = new Uint8Array(chunkSize);
+                                filled = 0;
+                                signal.throwIfAborted();
+                            }
+                        }
+                        current = (await pending) ?? new Uint8Array();
+                        offset = 0;
+                        eof = current.length === 0;
+                    }
+                    if (memberEnded) {
+                        if (eof)
+                            return;
+                        if (current[offset] === 0) {
+                            while ((await input.chunk()) !== undefined)
+                                await yieldTurn(signal);
+                            return;
+                        }
+                        const reset = zlibInflateReset(stream);
+                        if (reset !== Z_OK)
+                            throw codecError(reset, stream.msg);
+                        memberEnded = false;
+                    }
+                    stream.input = current;
+                    stream.next_in = offset;
+                    stream.avail_in = Math.min(current.length - offset, 64 * 1024);
+                }
+                stream.output = output;
+                stream.next_out = filled;
+                stream.avail_out = chunkSize - filled;
+                const before = stream.avail_in;
+                const status = encoding
+                    ? zlibDeflate(stream, eof ? Z_FINISH : Z_NO_FLUSH)
+                    : zlibInflate(stream, Z_NO_FLUSH);
+                offset = stream.next_in;
+                const consumed = before - stream.avail_in;
+                const produced = stream.next_out - filled;
+                filled = stream.next_out;
+                if (status !== Z_OK && status !== Z_STREAM_END && status !== Z_BUF_ERROR)
+                    throw codecError(status, stream.msg);
+                if (filled === chunkSize || (status === Z_STREAM_END && filled)) {
+                    yield output.subarray(0, filled);
+                    output = new Uint8Array(chunkSize);
+                    filled = 0;
+                }
+                signal.throwIfAborted();
+                work += consumed + produced;
+                if (++calls >= 64 || work >= 64 * 1024) {
+                    await yieldTurn(signal);
+                    calls = 0;
+                    work = 0;
+                }
+                if (status === Z_STREAM_END) {
+                    if (options.mode === "inflate-raw") {
+                        input.restore(current.subarray(offset));
+                        return;
+                    }
+                    if (encoding)
+                        return;
+                    memberEnded = true;
+                }
+                if (!consumed && !produced && status !== Z_STREAM_END) {
+                    if (eof)
+                        throw diagnostic(new CodecError("unexpected end of file"));
+                    if (stream.avail_in)
+                        throw codecError(status, stream.msg);
+                }
+                needsInput = stream.avail_in === 0 && stream.avail_out !== 0;
+            }
+        }
+        catch (error) {
+            options.onFailure?.(error);
+            throw error;
+        }
+        finally {
+            if (encoding)
+                zlibDeflateEnd(stream);
+            else
+                zlibInflateEnd(stream);
+            stream.input = new Uint8Array();
+            stream.output = new Uint8Array();
+        }
+    }
+    return { codec, CodecReader };
+}

package/dist/office-package/runtime.d.ts

@@ -0,0 +1,11 @@
+export type ByteSource = AsyncIterable<Uint8Array>;
+export declare class CodecError extends Error {
+    readonly code: "invalid-package" | "resource-limit";
+    constructor(message: string);
+}
+export interface CodecRuntime {
+    yieldTurn(signal: AbortSignal): Promise<void>;
+    readBytes(source: ByteSource, signal: AbortSignal): AsyncGenerator<Uint8Array>;
+    diagnostic(error: unknown): unknown;
+}
+export declare const defaultRuntime: CodecRuntime;

package/dist/office-package/runtime.js

@@ -0,0 +1,28 @@
+export class CodecError extends Error {
+    code;
+    constructor(message) {
+        super(message);
+        this.name = "CodecError";
+        this.code = message.includes("limit") ? "resource-limit" : "invalid-package";
+    }
+}
+export const defaultRuntime = {
+    async yieldTurn(signal) {
+        signal.throwIfAborted();
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        signal.throwIfAborted();
+    },
+    async *readBytes(source, signal) {
+        signal.throwIfAborted();
+        for await (const bytes of source) {
+            signal.throwIfAborted();
+            if (!(bytes instanceof Uint8Array))
+                throw new TypeError("Expected byte chunks");
+            yield bytes;
+        }
+        signal.throwIfAborted();
+    },
+    diagnostic(error) {
+        return error instanceof Error ? new CodecError(error.message) : error;
+    }
+};

package/dist/safe-bash/chunks/{bz2-B2RXT4EX.js → bz2-ACU4EOVE.js}

@@ -1,6 +1,6 @@
 import {
   init_platform
-} from "./chunk-2KL6W6NB.js";
+} from "./chunk-O2EVBRKF.js";
 
 // packages/safe-bash/src/commands/bytes/compression/native/generated/bz2.mjs
 init_platform();
@@ -4833,4 +4833,4 @@ export {
   ke as default
 };
 /*! Native codec: bz2 bzip2-1.0.8. See ../LICENSES.txt and ../sources.json. */
-//# sourceMappingURL=bz2-B2RXT4EX.js.map
+//# sourceMappingURL=bz2-ACU4EOVE.js.map

package/dist/safe-bash/chunks/chunk-2E4KBFO6.js

@@ -0,0 +1,239 @@
+import {
+  FsError
+} from "./chunk-WPIOO4NX.js";
+import {
+  init_platform
+} from "./chunk-O2EVBRKF.js";
+
+// packages/safe-bash/src/contracts/filesystem-descriptor.ts
+init_platform();
+import { FsError as FsError2 } from "@poe-platform/safe-fs/core";
+
+// packages/safe-bash/src/contracts/filesystem-output-budget.ts
+init_platform();
+var filesystemOutputBudgets = /* @__PURE__ */ new WeakMap();
+function bindFileOutputBudget(context, budget, countedWrite) {
+  if (!context.registerCleanup) throw new TypeError("Shell output budgets require invocation cleanup ownership");
+  filesystemOutputBudgets.set(context.registerCleanup, { sinkBudget: budget, ...countedWrite === void 0 ? {} : { countedWrite } });
+}
+function assertCountedFileOutput(context) {
+  context.signal.throwIfAborted();
+  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);
+  if (budget && !budget.countedWrite) throw new FsError("ENOTSUP", { syscall: "write", message: "counted filesystem output budget is not bound" });
+}
+async function writeFileOutputCounted(context, chunk, write) {
+  assertCountedFileOutput(context);
+  if (!(chunk instanceof Uint8Array)) throw new TypeError("Filesystem output must be Uint8Array");
+  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);
+  const requested = chunk.byteLength;
+  let called = false;
+  let accepting = true;
+  let accepted;
+  let active;
+  const guarded = () => {
+    try {
+      context.signal.throwIfAborted();
+      if (!accepting) throw new FsError("EBADF", { syscall: "write" });
+      if (called) throw new FsError("EIO", { syscall: "write", message: "counted writer invoked more than once" });
+      called = true;
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    active = (async () => {
+      const count = await write();
+      context.signal.throwIfAborted();
+      if (!Number.isSafeInteger(count) || count < 0 || count > requested) throw new FsError("EIO", { syscall: "write", message: "invalid byte count" });
+      accepted = count;
+      return count;
+    })();
+    void active.catch(() => {
+    });
+    return active;
+  };
+  let result;
+  let failure;
+  try {
+    result = await (budget?.countedWrite ? budget.countedWrite(chunk, guarded) : guarded());
+  } catch (reason) {
+    failure = { reason };
+  }
+  accepting = false;
+  try {
+    await active;
+  } catch (reason) {
+    failure ??= { reason };
+  }
+  context.signal.throwIfAborted();
+  if (failure) throw failure.reason;
+  if (accepted === void 0 || result !== accepted) throw new FsError("EIO", { syscall: "write", message: "counted writer changed the accepted byte count" });
+  return accepted;
+}
+
+// packages/safe-bash/src/contracts/filesystem-descriptor.ts
+async function openCommandFile(context, path, options) {
+  const { cleanupFailurePrioritySignal } = context;
+  let descriptor;
+  let accepting = true;
+  let closing;
+  let closeFailure;
+  let work = Promise.resolve();
+  let acquisitionSettled;
+  const acquired = new Promise((resolve) => {
+    acquisitionSettled = resolve;
+  });
+  let scope;
+  const close = () => {
+    accepting = false;
+    closing ??= (async () => {
+      await acquired;
+      await work;
+      const retained = descriptor;
+      descriptor = void 0;
+      try {
+        await retained?.close();
+      } catch (reason) {
+        closeFailure = { reason, acknowledged: false, drained: false };
+        throw reason;
+      } finally {
+        scope?.removeEventListener("abort", aborted);
+        if (closeFailure) closeFailure.drained = true;
+      }
+    })();
+    void closing.catch(() => {
+    });
+    return closing;
+  };
+  const aborted = () => {
+    void close().catch(() => {
+    });
+  };
+  const check = (signal) => {
+    context.signal.throwIfAborted();
+    scope?.throwIfAborted();
+    signal?.throwIfAborted();
+  };
+  const run = (syscall, forwarded, action) => {
+    const signal = forwarded.signal;
+    try {
+      check(signal);
+      if (!accepting) throw new FsError2("EBADF", { syscall, path });
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const operation = work.then(async () => {
+      check(signal);
+      const local = signal ? AbortSignal.any([scope, signal]) : scope;
+      try {
+        const result = await action(descriptor, { signal: local });
+        check(signal);
+        return result;
+      } catch (error) {
+        check(signal);
+        throw error;
+      }
+    });
+    work = operation.then(() => {
+    }, () => {
+    });
+    return operation;
+  };
+  try {
+    if (context.descriptorCleanup !== "caller") context.registerCleanup?.(async () => {
+      try {
+        await close();
+      } catch (reason) {
+        if (!closeFailure?.drained || !closeFailure.acknowledged || !Object.is(reason, closeFailure.reason)) {
+          if (cleanupFailurePrioritySignal === void 0) check();
+          else cleanupFailurePrioritySignal.throwIfAborted();
+          throw reason;
+        }
+      }
+      check();
+    });
+    const request = { ...options };
+    scope = request.signal ? AbortSignal.any([context.signal, request.signal]) : context.signal;
+    scope.addEventListener("abort", aborted, { once: true });
+    check();
+    if (!accepting) throw new FsError2("EBADF", { syscall: "open", path });
+    if (request.access !== "read") assertCountedFileOutput(context);
+    const fsOptions = { signal: scope };
+    const capabilities = request.creation === "exclusive" ? context.fs.capabilities : await context.fs.capabilitiesFor?.(path, { ...fsOptions, ...request.creation === "ifMissing" ? { create: true } : {} }) ?? context.fs.capabilities;
+    check();
+    if (!accepting) throw new FsError2("EBADF", { syscall: "open", path });
+    if (!context.fs.open || capabilities?.open === false) throw new FsError2("ENOTSUP", { syscall: "open", path });
+    descriptor = await context.fs.open(path, { ...request, signal: scope });
+    acquisitionSettled();
+    check();
+    if (!accepting) throw new FsError2("EBADF", { syscall: "open", path });
+    const { delegateZeroLengthWrite, ...retainedCapabilities } = descriptor.capabilities;
+    const position = retainedCapabilities.position === true && typeof descriptor.getPosition === "function";
+    const probeRead = retainedCapabilities.readObservation === true ? descriptor.probeRead : void 0;
+    if (retainedCapabilities.readObservation === true && typeof probeRead !== "function") throw new FsError2("ENOTSUP", { syscall: "probeRead", path });
+    const admitted = Object.freeze({
+      ...retainedCapabilities,
+      positionedRead: retainedCapabilities.positionedRead && request.access !== "write",
+      positionedWrite: retainedCapabilities.positionedWrite && request.access !== "read" && (!request.append || retainedCapabilities.positionedAppendWrite === true),
+      truncate: retainedCapabilities.truncate && request.access !== "read",
+      ...retainedCapabilities.position === void 0 ? {} : { position },
+      ...retainedCapabilities.positionedAppendWrite === void 0 ? {} : {
+        positionedAppendWrite: retainedCapabilities.positionedAppendWrite === true && retainedCapabilities.positionedWrite && request.access !== "read"
+      },
+      ...delegateZeroLengthWrite === void 0 ? {} : {
+        delegateZeroLengthWrite: delegateZeroLengthWrite === true && request.access !== "read"
+      }
+    });
+    check();
+    if (!accepting) throw new FsError2("EBADF", { syscall: "open", path });
+    return {
+      capabilities: admitted,
+      ...probeRead === void 0 ? {} : { probeRead: (forwarded = {}) => run("probeRead", forwarded, async (retained, supplied) => {
+        const readiness = await probeRead.call(retained, supplied);
+        if (readiness !== "ready" && readiness !== "blocked" && readiness !== "unknown") throw new FsError2("EIO", { syscall: "probeRead", path });
+        return readiness;
+      }) },
+      ...position ? { getPosition: (forwarded = {}) => run("getPosition", forwarded, async (retained, supplied) => {
+        if (retained.capabilities.position !== true || typeof retained.getPosition !== "function") throw new FsError2("ENOTSUP", { syscall: "getPosition", path });
+        const cursor = await retained.getPosition(supplied);
+        if (!Number.isSafeInteger(cursor) || cursor < 0) throw new FsError2("EIO", { syscall: "getPosition", path });
+        return cursor;
+      }) } : {},
+      stat: (forwarded = {}) => run("fstat", forwarded, (retained, supplied) => retained.stat(supplied)),
+      read: (buffer, position2, forwarded = {}) => run("read", forwarded, async (retained, supplied) => {
+        if (request.access === "write") throw new FsError2("EBADF", { syscall: "read", path });
+        return retained.read(buffer, position2, supplied);
+      }),
+      write: (buffer, position2, forwarded = {}) => run("write", forwarded, async (retained, supplied) => {
+        if (request.access === "read") throw new FsError2("EBADF", { syscall: "write", path });
+        return writeFileOutputCounted({ ...context, signal: supplied.signal }, buffer, () => retained.write(buffer, position2, supplied));
+      }),
+      truncate: (length, forwarded = {}) => run("ftruncate", forwarded, async (retained, supplied) => {
+        if (request.access === "read") throw new FsError2("EBADF", { syscall: "ftruncate", path });
+        await retained.truncate(length, supplied);
+      }),
+      sync: (dataOnly, forwarded = {}) => run(dataOnly ? "fdatasync" : "fsync", forwarded, (retained, supplied) => retained.sync(dataOnly, supplied)),
+      close,
+      acknowledgeCloseFailure: (reason) => {
+        if (!closeFailure || !Object.is(reason, closeFailure.reason)) return false;
+        if (closeFailure.acknowledged) return true;
+        if (context.signal.aborted || scope?.aborted) return false;
+        closeFailure.acknowledged = true;
+        return true;
+      }
+    };
+  } catch (error) {
+    acquisitionSettled();
+    try {
+      await close();
+    } catch {
+    }
+    check();
+    throw error;
+  }
+}
+
+export {
+  filesystemOutputBudgets,
+  bindFileOutputBudget,
+  openCommandFile
+};
+//# sourceMappingURL=chunk-2E4KBFO6.js.map

package/dist/safe-bash/chunks/chunk-2E4KBFO6.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/contracts/filesystem-descriptor.ts", "../../src/contracts/filesystem-output-budget.ts"],
+  "sourcesContent": ["import { FsError } from \"poe-code/safe-fs/core\";\nimport type { FileDescriptor, FsOptions, OpenFileOptions } from \"poe-code/safe-fs/core\";\nimport { assertCountedFileOutput, writeFileOutputCounted, type FileOutputContext } from \"./filesystem-output-budget.js\";\n\nexport interface CommandFileDescriptor extends FileDescriptor {\n  acknowledgeCloseFailure(reason: unknown): boolean;\n}\n\n/** descriptorCleanup: \"caller\" requires an already-enrolled owner that drains late\n * acquisitions and closes the returned descriptor; output accounting keeps the\n * original registerCleanup identity in either ownership mode. */\nexport async function openCommandFile(context: FileOutputContext & { readonly cleanupFailurePrioritySignal?: AbortSignal | undefined; readonly descriptorCleanup?: \"caller\" }, path: string, options: OpenFileOptions): Promise<CommandFileDescriptor> {\n  const { cleanupFailurePrioritySignal } = context;\n  let descriptor: FileDescriptor | undefined;\n  let accepting = true;\n  let closing: Promise<void> | undefined;\n  let closeFailure: { reason: unknown; acknowledged: boolean; drained: boolean } | undefined;\n  let work: Promise<void> = Promise.resolve();\n  let acquisitionSettled!: () => void;\n  const acquired = new Promise<void>(resolve => { acquisitionSettled = resolve; });\n  let scope: AbortSignal | undefined;\n  const close = (): Promise<void> => {\n    accepting = false;\n    closing ??= (async () => {\n      await acquired;\n      await work;\n      const retained = descriptor;\n      descriptor = undefined;\n      try { await retained?.close(); }\n      catch (reason) { closeFailure = { reason, acknowledged: false, drained: false }; throw reason; }\n      finally {\n        scope?.removeEventListener(\"abort\", aborted);\n        if (closeFailure) closeFailure.drained = true;\n      }\n    })();\n    void closing.catch(() => {});\n    return closing;\n  };\n  const aborted = (): void => { void close().catch(() => {}); };\n  const check = (signal?: AbortSignal): void => {\n    context.signal.throwIfAborted();\n    scope?.throwIfAborted();\n    signal?.throwIfAborted();\n  };\n  const run = <Result>(syscall: string, forwarded: FsOptions,\n    action: (retained: FileDescriptor, options: FsOptions) => Promise<Result>): Promise<Result> => {\n    const signal = forwarded.signal;\n    try {\n      check(signal);\n      if (!accepting) throw new FsError(\"EBADF\", { syscall, path });\n    } catch (error) { return Promise.reject(error); }\n    const operation = work.then(async () => {\n      check(signal);\n      const local = signal ? AbortSignal.any([scope!, signal]) : scope!;\n      try {\n        const result = await action(descriptor!, { signal: local });\n        check(signal);\n        return result;\n      } catch (error) {\n        check(signal);\n        throw error;\n      }\n    });\n    work = operation.then(() => {}, () => {});\n    return operation;\n  };\n  try {\n    if (context.descriptorCleanup !== \"caller\") context.registerCleanup?.(async () => {\n      try { await close(); }\n      catch (reason) {\n        if (!closeFailure?.drained || !closeFailure.acknowledged || !Object.is(reason, closeFailure.reason)) {\n          if (cleanupFailurePrioritySignal === undefined) check();\n          else cleanupFailurePrioritySignal.throwIfAborted();\n          throw reason;\n        }\n      }\n      check();\n    });\n    const request = { ...options };\n    scope = request.signal ? AbortSignal.any([context.signal, request.signal]) : context.signal;\n    scope.addEventListener(\"abort\", aborted, { once: true });\n    check();\n    if (!accepting) throw new FsError(\"EBADF\", { syscall: \"open\", path });\n    if (request.access !== \"read\") assertCountedFileOutput(context);\n    const fsOptions = { signal: scope };\n    // A following capability query cannot precede atomic exclusive acquisition:\n    // even a self-loop final symlink must be refused by open with EEXIST.\n    const capabilities = request.creation === \"exclusive\" ? context.fs.capabilities\n      : await context.fs.capabilitiesFor?.(path, { ...fsOptions, ...(request.creation === \"ifMissing\" ? { create: true } : {}) }) ?? context.fs.capabilities;\n    check();\n    if (!accepting) throw new FsError(\"EBADF\", { syscall: \"open\", path });\n    if (!context.fs.open || capabilities?.open === false) throw new FsError(\"ENOTSUP\", { syscall: \"open\", path });\n    descriptor = await context.fs.open(path, { ...request, signal: scope });\n    acquisitionSettled();\n    check();\n    if (!accepting) throw new FsError(\"EBADF\", { syscall: \"open\", path });\n    const { delegateZeroLengthWrite, ...retainedCapabilities } = descriptor.capabilities;\n    const position = retainedCapabilities.position === true && typeof descriptor.getPosition === \"function\";\n    const probeRead = retainedCapabilities.readObservation === true ? descriptor.probeRead : undefined;\n    if (retainedCapabilities.readObservation === true && typeof probeRead !== \"function\") throw new FsError(\"ENOTSUP\", { syscall: \"probeRead\", path });\n    const admitted = Object.freeze({ ...retainedCapabilities,\n      positionedRead: retainedCapabilities.positionedRead && request.access !== \"write\",\n      positionedWrite: retainedCapabilities.positionedWrite && request.access !== \"read\"\n        && (!request.append || retainedCapabilities.positionedAppendWrite === true),\n      truncate: retainedCapabilities.truncate && request.access !== \"read\",\n      ...(retainedCapabilities.position === undefined ? {} : { position }),\n      ...(retainedCapabilities.positionedAppendWrite === undefined ? {} : {\n        positionedAppendWrite: retainedCapabilities.positionedAppendWrite === true\n          && retainedCapabilities.positionedWrite && request.access !== \"read\",\n      }),\n      ...(delegateZeroLengthWrite === undefined ? {} : {\n        delegateZeroLengthWrite: delegateZeroLengthWrite === true && request.access !== \"read\",\n      }),\n    });\n    check();\n    if (!accepting) throw new FsError(\"EBADF\", { syscall: \"open\", path });\n    return {\n      capabilities: admitted,\n      ...(probeRead === undefined ? {} : { probeRead: (forwarded: FsOptions = {}) => run(\"probeRead\", forwarded, async (retained, supplied) => {\n        const readiness = await probeRead.call(retained, supplied);\n        if (readiness !== \"ready\" && readiness !== \"blocked\" && readiness !== \"unknown\") throw new FsError(\"EIO\", { syscall: \"probeRead\", path });\n        return readiness;\n      }) }),\n      ...(position ? { getPosition: (forwarded: FsOptions = {}) => run(\"getPosition\", forwarded, async (retained, supplied) => {\n        if (retained.capabilities.position !== true || typeof retained.getPosition !== \"function\") throw new FsError(\"ENOTSUP\", { syscall: \"getPosition\", path });\n        const cursor = await retained.getPosition(supplied);\n        if (!Number.isSafeInteger(cursor) || cursor < 0) throw new FsError(\"EIO\", { syscall: \"getPosition\", path });\n        return cursor;\n      }) } : {}),\n      stat: (forwarded = {}) => run(\"fstat\", forwarded, (retained, supplied) => retained.stat(supplied)),\n      read: (buffer, position, forwarded = {}) => run(\"read\", forwarded, async (retained, supplied) => {\n        if (request.access === \"write\") throw new FsError(\"EBADF\", { syscall: \"read\", path });\n        return retained.read(buffer, position, supplied);\n      }),\n      write: (buffer, position, forwarded = {}) => run(\"write\", forwarded, async (retained, supplied) => {\n        if (request.access === \"read\") throw new FsError(\"EBADF\", { syscall: \"write\", path });\n        return writeFileOutputCounted({ ...context, signal: supplied.signal! }, buffer, () => retained.write(buffer, position, supplied));\n      }),\n      truncate: (length, forwarded = {}) => run(\"ftruncate\", forwarded, async (retained, supplied) => {\n        if (request.access === \"read\") throw new FsError(\"EBADF\", { syscall: \"ftruncate\", path });\n        await retained.truncate(length, supplied);\n      }),\n      sync: (dataOnly, forwarded = {}) => run(dataOnly ? \"fdatasync\" : \"fsync\", forwarded, (retained, supplied) => retained.sync(dataOnly, supplied)),\n      close,\n      acknowledgeCloseFailure: (reason: unknown): boolean => {\n        if (!closeFailure || !Object.is(reason, closeFailure.reason)) return false;\n        if (closeFailure.acknowledged) return true;\n        if (context.signal.aborted || scope?.aborted) return false;\n        closeFailure.acknowledged = true;\n        return true;\n      },\n    };\n  } catch (error) {\n    acquisitionSettled();\n    try { await close(); } catch {}\n    check();\n    throw error;\n  }\n}\n", "import type { CommandContext } from \"./command.js\";\nimport { FsError } from \"./errors.js\";\nimport type { ByteSink } from \"./io.js\";\n\nexport type CountedFileWrite = (chunk: Uint8Array, write: () => Promise<number>) => Promise<number>;\n\nexport const filesystemOutputBudgets = new WeakMap<NonNullable<CommandContext[\"registerCleanup\"]>, {\n  readonly sinkBudget: (sink: ByteSink) => ByteSink;\n  readonly countedWrite?: CountedFileWrite;\n}>();\n\nexport type FileOutputContext = Pick<CommandContext, \"fs\" | \"signal\" | \"registerCleanup\"> & {\n  readonly cleanupFailurePrioritySignal?: AbortSignal | undefined;\n  readonly outputBudget?: \"shell\" | \"independent\";\n};\n\nexport function bindFileOutputBudget(context: Pick<CommandContext, \"registerCleanup\">, budget: (sink: ByteSink) => ByteSink, countedWrite?: CountedFileWrite): void {\n  if (!context.registerCleanup) throw new TypeError(\"Shell output budgets require invocation cleanup ownership\");\n  filesystemOutputBudgets.set(context.registerCleanup, { sinkBudget: budget, ...(countedWrite === undefined ? {} : { countedWrite }) });\n}\n\nexport function assertCountedFileOutput(context: Pick<CommandContext, \"registerCleanup\" | \"signal\">): void {\n  context.signal.throwIfAborted();\n  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);\n  if (budget && !budget.countedWrite) throw new FsError(\"ENOTSUP\", { syscall: \"write\", message: \"counted filesystem output budget is not bound\" });\n}\n\nexport async function writeFileOutputCounted(context: Pick<CommandContext, \"registerCleanup\" | \"signal\">,\n  chunk: Uint8Array, write: () => Promise<number>): Promise<number> {\n  assertCountedFileOutput(context);\n  if (!(chunk instanceof Uint8Array)) throw new TypeError(\"Filesystem output must be Uint8Array\");\n  const budget = context.registerCleanup && filesystemOutputBudgets.get(context.registerCleanup);\n  const requested = chunk.byteLength;\n  let called = false;\n  let accepting = true;\n  let accepted: number | undefined;\n  let active: Promise<number> | undefined;\n  const guarded = (): Promise<number> => {\n    try {\n      context.signal.throwIfAborted();\n      if (!accepting) throw new FsError(\"EBADF\", { syscall: \"write\" });\n      if (called) throw new FsError(\"EIO\", { syscall: \"write\", message: \"counted writer invoked more than once\" });\n      called = true;\n    } catch (error) { return Promise.reject(error); }\n    active = (async () => {\n      const count = await write();\n      context.signal.throwIfAborted();\n      if (!Number.isSafeInteger(count) || count < 0 || count > requested) throw new FsError(\"EIO\", { syscall: \"write\", message: \"invalid byte count\" });\n      accepted = count;\n      return count;\n    })();\n    void active.catch(() => {});\n    return active;\n  };\n  let result: number | undefined;\n  let failure: { reason: unknown } | undefined;\n  try {\n    result = await (budget?.countedWrite ? budget.countedWrite(chunk, guarded) : guarded());\n  } catch (reason) { failure = { reason }; }\n  accepting = false;\n  try { await active; } catch (reason) { failure ??= { reason }; }\n  context.signal.throwIfAborted();\n  if (failure) throw failure.reason;\n  if (accepted === undefined || result !== accepted) throw new FsError(\"EIO\", { syscall: \"write\", message: \"counted writer changed the accepted byte count\" });\n  return accepted;\n}\n"],
+  "mappings": ";;;;;;;;AAAA;AAAA,SAAS,WAAAA,gBAAe;;;ACAxB;AAMO,IAAM,0BAA0B,oBAAI,QAGxC;AAOI,SAAS,qBAAqB,SAAkD,QAAsC,cAAuC;AAClK,MAAI,CAAC,QAAQ,gBAAiB,OAAM,IAAI,UAAU,2DAA2D;AAC7G,0BAAwB,IAAI,QAAQ,iBAAiB,EAAE,YAAY,QAAQ,GAAI,iBAAiB,SAAY,CAAC,IAAI,EAAE,aAAa,EAAG,CAAC;AACtI;AAEO,SAAS,wBAAwB,SAAmE;AACzG,UAAQ,OAAO,eAAe;AAC9B,QAAM,SAAS,QAAQ,mBAAmB,wBAAwB,IAAI,QAAQ,eAAe;AAC7F,MAAI,UAAU,CAAC,OAAO,aAAc,OAAM,IAAI,QAAQ,WAAW,EAAE,SAAS,SAAS,SAAS,gDAAgD,CAAC;AACjJ;AAEA,eAAsB,uBAAuB,SAC3C,OAAmB,OAA+C;AAClE,0BAAwB,OAAO;AAC/B,MAAI,EAAE,iBAAiB,YAAa,OAAM,IAAI,UAAU,sCAAsC;AAC9F,QAAM,SAAS,QAAQ,mBAAmB,wBAAwB,IAAI,QAAQ,eAAe;AAC7F,QAAM,YAAY,MAAM;AACxB,MAAI,SAAS;AACb,MAAI,YAAY;AAChB,MAAI;AACJ,MAAI;AACJ,QAAM,UAAU,MAAuB;AACrC,QAAI;AACF,cAAQ,OAAO,eAAe;AAC9B,UAAI,CAAC,UAAW,OAAM,IAAI,QAAQ,SAAS,EAAE,SAAS,QAAQ,CAAC;AAC/D,UAAI,OAAQ,OAAM,IAAI,QAAQ,OAAO,EAAE,SAAS,SAAS,SAAS,wCAAwC,CAAC;AAC3G,eAAS;AAAA,IACX,SAAS,OAAO;AAAE,aAAO,QAAQ,OAAO,KAAK;AAAA,IAAG;AAChD,cAAU,YAAY;AACpB,YAAM,QAAQ,MAAM,MAAM;AAC1B,cAAQ,OAAO,eAAe;AAC9B,UAAI,CAAC,OAAO,cAAc,KAAK,KAAK,QAAQ,KAAK,QAAQ,UAAW,OAAM,IAAI,QAAQ,OAAO,EAAE,SAAS,SAAS,SAAS,qBAAqB,CAAC;AAChJ,iBAAW;AACX,aAAO;AAAA,IACT,GAAG;AACH,SAAK,OAAO,MAAM,MAAM;AAAA,IAAC,CAAC;AAC1B,WAAO;AAAA,EACT;AACA,MAAI;AACJ,MAAI;AACJ,MAAI;AACF,aAAS,OAAO,QAAQ,eAAe,OAAO,aAAa,OAAO,OAAO,IAAI,QAAQ;AAAA,EACvF,SAAS,QAAQ;AAAE,cAAU,EAAE,OAAO;AAAA,EAAG;AACzC,cAAY;AACZ,MAAI;AAAE,UAAM;AAAA,EAAQ,SAAS,QAAQ;AAAE,gBAAY,EAAE,OAAO;AAAA,EAAG;AAC/D,UAAQ,OAAO,eAAe;AAC9B,MAAI,QAAS,OAAM,QAAQ;AAC3B,MAAI,aAAa,UAAa,WAAW,SAAU,OAAM,IAAI,QAAQ,OAAO,EAAE,SAAS,SAAS,SAAS,iDAAiD,CAAC;AAC3J,SAAO;AACT;;;ADtDA,eAAsB,gBAAgB,SAAyI,MAAc,SAA0D;AACrP,QAAM,EAAE,6BAA6B,IAAI;AACzC,MAAI;AACJ,MAAI,YAAY;AAChB,MAAI;AACJ,MAAI;AACJ,MAAI,OAAsB,QAAQ,QAAQ;AAC1C,MAAI;AACJ,QAAM,WAAW,IAAI,QAAc,aAAW;AAAE,yBAAqB;AAAA,EAAS,CAAC;AAC/E,MAAI;AACJ,QAAM,QAAQ,MAAqB;AACjC,gBAAY;AACZ,iBAAa,YAAY;AACvB,YAAM;AACN,YAAM;AACN,YAAM,WAAW;AACjB,mBAAa;AACb,UAAI;AAAE,cAAM,UAAU,MAAM;AAAA,MAAG,SACxB,QAAQ;AAAE,uBAAe,EAAE,QAAQ,cAAc,OAAO,SAAS,MAAM;AAAG,cAAM;AAAA,MAAQ,UAC/F;AACE,eAAO,oBAAoB,SAAS,OAAO;AAC3C,YAAI,aAAc,cAAa,UAAU;AAAA,MAC3C;AAAA,IACF,GAAG;AACH,SAAK,QAAQ,MAAM,MAAM;AAAA,IAAC,CAAC;AAC3B,WAAO;AAAA,EACT;AACA,QAAM,UAAU,MAAY;AAAE,SAAK,MAAM,EAAE,MAAM,MAAM;AAAA,IAAC,CAAC;AAAA,EAAG;AAC5D,QAAM,QAAQ,CAAC,WAA+B;AAC5C,YAAQ,OAAO,eAAe;AAC9B,WAAO,eAAe;AACtB,YAAQ,eAAe;AAAA,EACzB;AACA,QAAM,MAAM,CAAS,SAAiB,WACpC,WAA+F;AAC/F,UAAM,SAAS,UAAU;AACzB,QAAI;AACF,YAAM,MAAM;AACZ,UAAI,CAAC,UAAW,OAAM,IAAIC,SAAQ,SAAS,EAAE,SAAS,KAAK,CAAC;AAAA,IAC9D,SAAS,OAAO;AAAE,aAAO,QAAQ,OAAO,KAAK;AAAA,IAAG;AAChD,UAAM,YAAY,KAAK,KAAK,YAAY;AACtC,YAAM,MAAM;AACZ,YAAM,QAAQ,SAAS,YAAY,IAAI,CAAC,OAAQ,MAAM,CAAC,IAAI;AAC3D,UAAI;AACF,cAAM,SAAS,MAAM,OAAO,YAAa,EAAE,QAAQ,MAAM,CAAC;AAC1D,cAAM,MAAM;AACZ,eAAO;AAAA,MACT,SAAS,OAAO;AACd,cAAM,MAAM;AACZ,cAAM;AAAA,MACR;AAAA,IACF,CAAC;AACD,WAAO,UAAU,KAAK,MAAM;AAAA,IAAC,GAAG,MAAM;AAAA,IAAC,CAAC;AACxC,WAAO;AAAA,EACT;AACA,MAAI;AACF,QAAI,QAAQ,sBAAsB,SAAU,SAAQ,kBAAkB,YAAY;AAChF,UAAI;AAAE,cAAM,MAAM;AAAA,MAAG,SACd,QAAQ;AACb,YAAI,CAAC,cAAc,WAAW,CAAC,aAAa,gBAAgB,CAAC,OAAO,GAAG,QAAQ,aAAa,MAAM,GAAG;AACnG,cAAI,iCAAiC,OAAW,OAAM;AAAA,cACjD,8BAA6B,eAAe;AACjD,gBAAM;AAAA,QACR;AAAA,MACF;AACA,YAAM;AAAA,IACR,CAAC;AACD,UAAM,UAAU,EAAE,GAAG,QAAQ;AAC7B,YAAQ,QAAQ,SAAS,YAAY,IAAI,CAAC,QAAQ,QAAQ,QAAQ,MAAM,CAAC,IAAI,QAAQ;AACrF,UAAM,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AACvD,UAAM;AACN,QAAI,CAAC,UAAW,OAAM,IAAIA,SAAQ,SAAS,EAAE,SAAS,QAAQ,KAAK,CAAC;AACpE,QAAI,QAAQ,WAAW,OAAQ,yBAAwB,OAAO;AAC9D,UAAM,YAAY,EAAE,QAAQ,MAAM;AAGlC,UAAM,eAAe,QAAQ,aAAa,cAAc,QAAQ,GAAG,eAC/D,MAAM,QAAQ,GAAG,kBAAkB,MAAM,EAAE,GAAG,WAAW,GAAI,QAAQ,aAAa,cAAc,EAAE,QAAQ,KAAK,IAAI,CAAC,EAAG,CAAC,KAAK,QAAQ,GAAG;AAC5I,UAAM;AACN,QAAI,CAAC,UAAW,OAAM,IAAIA,SAAQ,SAAS,EAAE,SAAS,QAAQ,KAAK,CAAC;AACpE,QAAI,CAAC,QAAQ,GAAG,QAAQ,cAAc,SAAS,MAAO,OAAM,IAAIA,SAAQ,WAAW,EAAE,SAAS,QAAQ,KAAK,CAAC;AAC5G,iBAAa,MAAM,QAAQ,GAAG,KAAK,MAAM,EAAE,GAAG,SAAS,QAAQ,MAAM,CAAC;AACtE,uBAAmB;AACnB,UAAM;AACN,QAAI,CAAC,UAAW,OAAM,IAAIA,SAAQ,SAAS,EAAE,SAAS,QAAQ,KAAK,CAAC;AACpE,UAAM,EAAE,yBAAyB,GAAG,qBAAqB,IAAI,WAAW;AACxE,UAAM,WAAW,qBAAqB,aAAa,QAAQ,OAAO,WAAW,gBAAgB;AAC7F,UAAM,YAAY,qBAAqB,oBAAoB,OAAO,WAAW,YAAY;AACzF,QAAI,qBAAqB,oBAAoB,QAAQ,OAAO,cAAc,WAAY,OAAM,IAAIA,SAAQ,WAAW,EAAE,SAAS,aAAa,KAAK,CAAC;AACjJ,UAAM,WAAW,OAAO,OAAO;AAAA,MAAE,GAAG;AAAA,MAClC,gBAAgB,qBAAqB,kBAAkB,QAAQ,WAAW;AAAA,MAC1E,iBAAiB,qBAAqB,mBAAmB,QAAQ,WAAW,WACtE,CAAC,QAAQ,UAAU,qBAAqB,0BAA0B;AAAA,MACxE,UAAU,qBAAqB,YAAY,QAAQ,WAAW;AAAA,MAC9D,GAAI,qBAAqB,aAAa,SAAY,CAAC,IAAI,EAAE,SAAS;AAAA,MAClE,GAAI,qBAAqB,0BAA0B,SAAY,CAAC,IAAI;AAAA,QAClE,uBAAuB,qBAAqB,0BAA0B,QACjE,qBAAqB,mBAAmB,QAAQ,WAAW;AAAA,MAClE;AAAA,MACA,GAAI,4BAA4B,SAAY,CAAC,IAAI;AAAA,QAC/C,yBAAyB,4BAA4B,QAAQ,QAAQ,WAAW;AAAA,MAClF;AAAA,IACF,CAAC;AACD,UAAM;AACN,QAAI,CAAC,UAAW,OAAM,IAAIA,SAAQ,SAAS,EAAE,SAAS,QAAQ,KAAK,CAAC;AACpE,WAAO;AAAA,MACL,cAAc;AAAA,MACd,GAAI,cAAc,SAAY,CAAC,IAAI,EAAE,WAAW,CAAC,YAAuB,CAAC,MAAM,IAAI,aAAa,WAAW,OAAO,UAAU,aAAa;AACvI,cAAM,YAAY,MAAM,UAAU,KAAK,UAAU,QAAQ;AACzD,YAAI,cAAc,WAAW,cAAc,aAAa,cAAc,UAAW,OAAM,IAAIA,SAAQ,OAAO,EAAE,SAAS,aAAa,KAAK,CAAC;AACxI,eAAO;AAAA,MACT,CAAC,EAAE;AAAA,MACH,GAAI,WAAW,EAAE,aAAa,CAAC,YAAuB,CAAC,MAAM,IAAI,eAAe,WAAW,OAAO,UAAU,aAAa;AACvH,YAAI,SAAS,aAAa,aAAa,QAAQ,OAAO,SAAS,gBAAgB,WAAY,OAAM,IAAIA,SAAQ,WAAW,EAAE,SAAS,eAAe,KAAK,CAAC;AACxJ,cAAM,SAAS,MAAM,SAAS,YAAY,QAAQ;AAClD,YAAI,CAAC,OAAO,cAAc,MAAM,KAAK,SAAS,EAAG,OAAM,IAAIA,SAAQ,OAAO,EAAE,SAAS,eAAe,KAAK,CAAC;AAC1G,eAAO;AAAA,MACT,CAAC,EAAE,IAAI,CAAC;AAAA,MACR,MAAM,CAAC,YAAY,CAAC,MAAM,IAAI,SAAS,WAAW,CAAC,UAAU,aAAa,SAAS,KAAK,QAAQ,CAAC;AAAA,MACjG,MAAM,CAAC,QAAQC,WAAU,YAAY,CAAC,MAAM,IAAI,QAAQ,WAAW,OAAO,UAAU,aAAa;AAC/F,YAAI,QAAQ,WAAW,QAAS,OAAM,IAAID,SAAQ,SAAS,EAAE,SAAS,QAAQ,KAAK,CAAC;AACpF,eAAO,SAAS,KAAK,QAAQC,WAAU,QAAQ;AAAA,MACjD,CAAC;AAAA,MACD,OAAO,CAAC,QAAQA,WAAU,YAAY,CAAC,MAAM,IAAI,SAAS,WAAW,OAAO,UAAU,aAAa;AACjG,YAAI,QAAQ,WAAW,OAAQ,OAAM,IAAID,SAAQ,SAAS,EAAE,SAAS,SAAS,KAAK,CAAC;AACpF,eAAO,uBAAuB,EAAE,GAAG,SAAS,QAAQ,SAAS,OAAQ,GAAG,QAAQ,MAAM,SAAS,MAAM,QAAQC,WAAU,QAAQ,CAAC;AAAA,MAClI,CAAC;AAAA,MACD,UAAU,CAAC,QAAQ,YAAY,CAAC,MAAM,IAAI,aAAa,WAAW,OAAO,UAAU,aAAa;AAC9F,YAAI,QAAQ,WAAW,OAAQ,OAAM,IAAID,SAAQ,SAAS,EAAE,SAAS,aAAa,KAAK,CAAC;AACxF,cAAM,SAAS,SAAS,QAAQ,QAAQ;AAAA,MAC1C,CAAC;AAAA,MACD,MAAM,CAAC,UAAU,YAAY,CAAC,MAAM,IAAI,WAAW,cAAc,SAAS,WAAW,CAAC,UAAU,aAAa,SAAS,KAAK,UAAU,QAAQ,CAAC;AAAA,MAC9I;AAAA,MACA,yBAAyB,CAAC,WAA6B;AACrD,YAAI,CAAC,gBAAgB,CAAC,OAAO,GAAG,QAAQ,aAAa,MAAM,EAAG,QAAO;AACrE,YAAI,aAAa,aAAc,QAAO;AACtC,YAAI,QAAQ,OAAO,WAAW,OAAO,QAAS,QAAO;AACrD,qBAAa,eAAe;AAC5B,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AACd,uBAAmB;AACnB,QAAI;AAAE,YAAM,MAAM;AAAA,IAAG,QAAQ;AAAA,IAAC;AAC9B,UAAM;AACN,UAAM;AAAA,EACR;AACF;",
+  "names": ["FsError", "FsError", "position"]
+}

package/dist/safe-bash/chunks/chunk-3E5M2WEL.js

@@ -0,0 +1,33 @@
+import {
+  CommandArgumentIdentityError
+} from "./chunk-CHHAB5SS.js";
+import {
+  FsError
+} from "./chunk-WPIOO4NX.js";
+import {
+  init_platform
+} from "./chunk-O2EVBRKF.js";
+
+// packages/safe-bash/src/diagnostics.ts
+init_platform();
+var PublicDiagnostic = class extends Error {
+};
+function publicDiagnosticMessage(error, onInternalError) {
+  if (error instanceof FsError || error instanceof CommandArgumentIdentityError) return error.message;
+  if (error instanceof PublicDiagnostic && !Object.hasOwn(error, "cause")) return error.message;
+  const original = error instanceof PublicDiagnostic ? error.cause : error;
+  const detail = error instanceof PublicDiagnostic ? error.message : "internal error";
+  try {
+    const pending = onInternalError?.(original);
+    if (pending !== void 0) void Promise.resolve(pending).catch(() => void 0);
+  } catch {
+    return detail;
+  }
+  return detail;
+}
+
+export {
+  PublicDiagnostic,
+  publicDiagnosticMessage
+};
+//# sourceMappingURL=chunk-3E5M2WEL.js.map

package/dist/safe-bash/chunks/chunk-3E5M2WEL.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/diagnostics.ts"],
+  "sourcesContent": ["import { FsError } from \"./contracts/errors.js\";\nimport { CommandArgumentIdentityError, type InternalErrorHandler } from \"./contracts/command.js\";\n\nexport class PublicDiagnostic extends Error {}\n\nexport function publicDiagnosticMessage(error: unknown, onInternalError?: InternalErrorHandler): string {\n  if (error instanceof FsError || error instanceof CommandArgumentIdentityError) return error.message;\n  if (error instanceof PublicDiagnostic && !Object.hasOwn(error, \"cause\")) return error.message;\n  const original: unknown = error instanceof PublicDiagnostic ? error.cause : error;\n  const detail = error instanceof PublicDiagnostic ? error.message : \"internal error\";\n  try {\n    const pending = onInternalError?.(original);\n    if (pending !== undefined) void Promise.resolve(pending).catch(() => undefined);\n  } catch { return detail; }\n  return detail;\n}\n"],
+  "mappings": ";;;;;;;;;;;AAAA;AAGO,IAAM,mBAAN,cAA+B,MAAM;AAAC;AAEtC,SAAS,wBAAwB,OAAgB,iBAAgD;AACtG,MAAI,iBAAiB,WAAW,iBAAiB,6BAA8B,QAAO,MAAM;AAC5F,MAAI,iBAAiB,oBAAoB,CAAC,OAAO,OAAO,OAAO,OAAO,EAAG,QAAO,MAAM;AACtF,QAAM,WAAoB,iBAAiB,mBAAmB,MAAM,QAAQ;AAC5E,QAAM,SAAS,iBAAiB,mBAAmB,MAAM,UAAU;AACnE,MAAI;AACF,UAAM,UAAU,kBAAkB,QAAQ;AAC1C,QAAI,YAAY,OAAW,MAAK,QAAQ,QAAQ,OAAO,EAAE,MAAM,MAAM,MAAS;AAAA,EAChF,QAAQ;AAAE,WAAO;AAAA,EAAQ;AACzB,SAAO;AACT;",
+  "names": []
+}

package/dist/safe-bash/chunks/{chunk-KQ6J7JHQ.js → chunk-3LD67SER.js}

@@ -1,25 +1,27 @@
+import {
+  createOutputOperation
+} from "./chunk-CDBQXRWL.js";
 import {
   acceptsMimeType,
   sniffMimeType
-} from "./chunk-PVJJFCGA.js";
-import {
-  createOutputOperation
-} from "./chunk-RNKTWFEM.js";
+} from "./chunk-M3GPCYSP.js";
 import {
   pathOf,
   writeDiagnostic
-} from "./chunk-GFZKQIPL.js";
+} from "./chunk-LA6BX562.js";
 import {
-  getCommandArguments,
   inheritYieldCheckpoint,
   yieldTurn
-} from "./chunk-UYX72YHY.js";
+} from "./chunk-THXJ6CLF.js";
+import {
+  getCommandArguments
+} from "./chunk-CHHAB5SS.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/llm/index.ts
 init_platform();
@@ -283,4 +285,4 @@ export {
   createLlmCommands,
   llmCommands
 };
-//# sourceMappingURL=chunk-KQ6J7JHQ.js.map
+//# sourceMappingURL=chunk-3LD67SER.js.map