@poe-platform/safe-bash 0.1.539 → 0.1.540

package/dist/safe-bash/chunks/{chunk-4NMFAR4Z.js → chunk-2KL6W6NB.js}

@@ -1826,638 +1826,12 @@ var init_platform = __esm({
   }
 });
 
-// packages/safe-bash/src/contracts/value.ts
-init_platform();
-var byteValues = /* @__PURE__ */ new WeakMap();
-var encoder = new TextEncoder();
-var decoder = new TextDecoder("utf-8", { ignoreBOM: true });
-var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
-var viewBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
-var viewOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
-var viewLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
-function record(value) {
-  const result = byteValues.get(value);
-  if (!result) throw new TypeError("Expected an owned shell byte value");
-  return result;
-}
-function allocationSize(length, multiplier) {
-  const result = length * multiplier + 64;
-  if (!Number.isSafeInteger(result)) throw new RangeError("Shell value allocation is too large");
-  return result;
-}
-function allocate(bytes, allocation, create, slots = 1) {
-  allocation?.assertOpen();
-  const reservation = allocation?.reserve(bytes, slots);
-  try {
-    const result = create();
-    reservation?.commit(result);
-    return result;
-  } catch (error) {
-    try {
-      reservation?.release();
-    } catch (cleanup) {
-      throw new AggregateError([error, cleanup], "Shell value allocation and release failed");
-    }
-    throw error;
-  }
-}
-function ownedBytes(bytes) {
-  const value = Object.freeze({});
-  byteValues.set(value, { bytes, text: decoder.decode(bytes) });
-  return value;
-}
-function shellValueFromBytes(bytes, allocation) {
-  if (!(bytes instanceof Uint8Array)) throw new TypeError("Shell bytes must be Uint8Array");
-  const buffer = viewBuffer.call(bytes);
-  const offset = viewOffset.call(bytes);
-  const length = viewLength.call(bytes);
-  return allocate(allocationSize(length, 3), allocation, () => {
-    if (viewOffset.call(bytes) !== offset || viewLength.call(bytes) < length) throw new TypeError("Shell byte input extent changed during admission");
-    return ownedBytes(new Uint8Array(new Uint8Array(buffer, offset, length)));
-  });
-}
-function shellValueText(value) {
-  return typeof value === "string" ? value : record(value).text;
-}
-function shellValueByteLength(value) {
-  return typeof value === "string" ? import_buffer.Buffer.byteLength(value) : record(value).bytes.byteLength;
-}
-function shellValueRetainedBytes(value) {
-  const stored = record(value);
-  return stored.bytes.byteLength + stored.text.length * 2 + 64;
-}
-function shellValueBytes(value, allocation) {
-  const length = shellValueByteLength(value);
-  return allocate(allocationSize(length, 1), allocation, () => typeof value === "string" ? encoder.encode(value) : new Uint8Array(record(value).bytes));
-}
-function concatShellValues(values, allocation) {
-  allocation?.assertOpen();
-  if (!Array.isArray(values)) throw new TypeError("Shell value concatenation requires an array");
-  const count = values.length;
-  if (!Number.isSafeInteger(count) || count < 0 || count > 4294967295) throw new RangeError("Invalid shell value input extent");
-  if (!count) return "";
-  if (count === 1) {
-    const value = values[0];
-    if (typeof value !== "string") record(value);
-    if (values.length !== count) throw new TypeError("Shell value input extent changed");
-    return value;
-  }
-  let textOnly = true;
-  for (let index = 0; index < count; index++) {
-    if (typeof values[index] !== "string") {
-      textOnly = false;
-      break;
-    }
-  }
-  if (textOnly) {
-    let text = "";
-    for (let index = 0; index < count; index++) {
-      const value = values[index];
-      if (typeof value !== "string") throw new TypeError("Shell value input type changed during text concatenation");
-      text += value;
-    }
-    if (values.length !== count) throw new TypeError("Shell value input extent changed");
-    return text;
-  }
-  let reservation = allocation?.reserve(allocationSize(count, 16), count + 1);
-  const release = () => {
-    const pending = reservation;
-    reservation = void 0;
-    pending?.release();
-  };
-  try {
-    if (values.length !== count) throw new TypeError("Shell value input extent changed during metadata admission");
-    const snapshot = new Array(count);
-    for (let index = 0; index < count; index++) {
-      const value = values[index];
-      if (typeof value !== "string") record(value);
-      snapshot[index] = value;
-    }
-    if (values.length !== count) throw new TypeError("Shell value input extent changed during snapshot capture");
-    Object.freeze(snapshot);
-    reservation?.commit(snapshot);
-    if (snapshot.every((value) => typeof value === "string")) {
-      const result = snapshot.join("");
-      release();
-      return result;
-    }
-    const length = encodeValues(snapshot);
-    return allocate(allocationSize(length, 3), allocation, () => {
-      const bytes = new Uint8Array(length);
-      encodeValues(snapshot, bytes);
-      const result = ownedBytes(bytes);
-      release();
-      return result;
-    });
-  } catch (error) {
-    try {
-      release();
-    } catch (cleanup) {
-      throw new AggregateError([error, cleanup], "Shell value snapshot and release failed");
-    }
-    throw error;
-  }
-}
-function encodeValues(values, output) {
-  let offset = 0;
-  let high = 0;
-  const write = (byte) => {
-    if (output) output[offset] = byte;
-    offset++;
-  };
-  const point = (code) => {
-    if (code < 128) write(code);
-    else if (code < 2048) {
-      write(192 | code >> 6);
-      write(128 | code & 63);
-    } else if (code < 65536) {
-      write(224 | code >> 12);
-      write(128 | code >> 6 & 63);
-      write(128 | code & 63);
-    } else {
-      write(240 | code >> 18);
-      write(128 | code >> 12 & 63);
-      write(128 | code >> 6 & 63);
-      write(128 | code & 63);
-    }
-  };
-  for (const value of values) {
-    if (typeof value !== "string") {
-      if (high) {
-        point(65533);
-        high = 0;
-      }
-      const bytes = record(value).bytes;
-      output?.set(bytes, offset);
-      offset += bytes.byteLength;
-      continue;
-    }
-    for (let index = 0; index < value.length; index++) {
-      const code = value.charCodeAt(index);
-      if (high) {
-        const previous = high;
-        high = 0;
-        if (code >= 56320 && code <= 57343) {
-          point(65536 + (previous - 55296 << 10) + code - 56320);
-          continue;
-        }
-        point(65533);
-      }
-      if (code >= 55296 && code <= 56319) high = code;
-      else point(code >= 56320 && code <= 57343 ? 65533 : code);
-    }
-  }
-  if (high) point(65533);
-  if (!Number.isSafeInteger(offset)) throw new RangeError("Shell value allocation is too large");
-  return offset;
-}
-
-// packages/safe-bash/src/contracts/command.ts
-init_platform();
-var argumentCarriers = /* @__PURE__ */ new WeakSet();
-var CommandArgumentIdentityError = class extends TypeError {
-  constructor() {
-    super("Command argument identity does not match its carrier");
-  }
-};
-function argumentAllocation(allocation) {
-  const reservations = [];
-  const tracked = allocation && {
-    assertOpen() {
-      allocation.assertOpen();
-    },
-    reserve(bytes, slots) {
-      const reservation = allocation.reserve(bytes, slots);
-      let released = false;
-      const owned = {
-        commit(value) {
-          reservation.commit(value);
-        },
-        release() {
-          if (released) return;
-          released = true;
-          reservation.release();
-        }
-      };
-      reservations.push(owned);
-      return owned;
-    }
-  };
-  return {
-    allocation: tracked,
-    rollback(error) {
-      const failures = [error];
-      for (let index = reservations.length - 1; index >= 0; index--) {
-        try {
-          reservations[index].release();
-        } catch (cleanup) {
-          failures.push(cleanup);
-        }
-      }
-      if (failures.length > 1) throw new AggregateError(failures, "Command argument allocation and release failed");
-      throw error;
-    }
-  };
-}
-function ownedCommandArguments(size, valueAt, allocation, extent) {
-  allocation?.assertOpen();
-  const length = typeof size === "number" ? size : size();
-  const bytes = 128 + length * 40;
-  const slots = length * 4 + 1;
-  if (!Number.isSafeInteger(length) || length < 0 || !Number.isSafeInteger(bytes) || !Number.isSafeInteger(slots)) {
-    throw new RangeError("Command argument allocation is too large");
-  }
-  const transaction = argumentAllocation(allocation);
-  const reservation = transaction.allocation?.reserve(bytes, slots);
-  try {
-    if (extent && extent() !== length) throw new TypeError("Command argument extent changed during admission");
-    const snapshot = [];
-    for (let index = 0; index < length; index++) snapshot.push(valueAt(index));
-    if (extent && extent() !== length) throw new TypeError("Command argument extent changed during admission");
-    const values = [];
-    const args = [];
-    for (const incoming of snapshot) {
-      const value = incoming instanceof Uint8Array ? shellValueFromBytes(incoming, transaction.allocation) : incoming;
-      args.push(shellValueText(value));
-      values.push(value);
-    }
-    Object.freeze(values);
-    Object.freeze(args);
-    const carrier = Object.freeze({
-      args,
-      values,
-      bytes(index) {
-        return Number.isInteger(index) && index >= 0 && index < length ? shellValueBytes(values[index], allocation) : void 0;
-      },
-      slice(start = 0, end = length) {
-        const offset = (index) => {
-          const integral = Math.trunc(index) || 0;
-          return integral < 0 ? Math.max(0, length + integral) : Math.min(length, integral);
-        };
-        const first = offset(start);
-        return ownedCommandArguments(Math.max(0, offset(end) - first), (index) => values[first + index], allocation);
-      },
-      select(indices) {
-        return ownedCommandArguments(() => {
-          if (!Array.isArray(indices)) throw new TypeError("Command argument selection must be an array");
-          return indices.length;
-        }, (index) => {
-          const selected = indices[index];
-          if (!Number.isInteger(selected) || selected < 0 || selected >= length) throw new RangeError("Command argument index is out of range");
-          return values[selected];
-        }, allocation, () => indices.length);
-      },
-      concat(...others) {
-        let total = length;
-        for (const other of others) {
-          if (!argumentCarriers.has(other)) throw new TypeError("Expected owned command arguments");
-          total += other.values.length;
-        }
-        return ownedCommandArguments(total, (index) => {
-          if (index < length) return values[index];
-          let offset = index - length;
-          for (const other of others) {
-            if (offset < other.values.length) return other.values[offset];
-            offset -= other.values.length;
-          }
-          throw new RangeError("Command argument index is out of range");
-        }, allocation);
-      },
-      withValues(incoming) {
-        return ownedCommandArguments(() => {
-          if (!Array.isArray(incoming)) throw new TypeError("Command arguments must be an array");
-          return incoming.length;
-        }, (index) => incoming[index], allocation, () => incoming.length);
-      },
-      join(separator = "") {
-        allocation?.assertOpen();
-        const count = Math.max(0, length * 2 - 1);
-        const bytes2 = 128 + count * 16;
-        if (!Number.isSafeInteger(bytes2) || !Number.isSafeInteger(count + 1)) throw new RangeError("Command argument join allocation is too large");
-        const transaction2 = argumentAllocation(allocation);
-        const scratch = transaction2.allocation?.reserve(bytes2, count + 1);
-        try {
-          const parts = [];
-          for (let index = 0; index < length; index++) {
-            if (index) parts.push(separator);
-            parts.push(values[index]);
-          }
-          Object.freeze(parts);
-          scratch?.commit(parts);
-          const result = concatShellValues(parts, transaction2.allocation);
-          scratch?.release();
-          return result;
-        } catch (error) {
-          return transaction2.rollback(error);
-        }
-      }
-    });
-    reservation?.commit(carrier);
-    argumentCarriers.add(carrier);
-    return carrier;
-  } catch (error) {
-    return transaction.rollback(error);
-  }
-}
-function createCommandArguments(values, allocation) {
-  return ownedCommandArguments(() => {
-    if (!Array.isArray(values)) throw new TypeError("Command arguments must be an array");
-    return values.length;
-  }, (index) => values[index], allocation, () => values.length);
-}
-function getCommandArguments(context) {
-  const carrier = context.argumentValues;
-  if (carrier === void 0) return createCommandArguments(context.args);
-  if (!argumentCarriers.has(carrier)) throw new TypeError("Expected owned command arguments");
-  if (carrier.args !== context.args) throw new CommandArgumentIdentityError();
-  return carrier;
-}
-var CommandRegistry = class {
-  #commands = /* @__PURE__ */ new Map();
-  constructor(commands = []) {
-    for (const command of commands) this.register(command);
-  }
-  register(command, options = {}) {
-    const { name, execute } = command;
-    if (typeof name !== "string" || !name || /[\s/\0]/u.test(name)) {
-      throw new TypeError("Command names must be nonempty and contain no whitespace, slash, or NUL");
-    }
-    if (typeof execute !== "function") {
-      throw new TypeError("Command execute must be a function");
-    }
-    if (this.#commands.has(name) && !options.replace) {
-      throw new Error(`Command already registered: ${name}`);
-    }
-    this.#commands.set(name, Object.freeze({ ...command, name, execute }));
-    return this;
-  }
-  get(name) {
-    return this.#commands.get(name);
-  }
-  has(name) {
-    return this.#commands.has(name);
-  }
-  unregister(name) {
-    return this.#commands.delete(name);
-  }
-  list() {
-    return Array.from(this.#commands.values());
-  }
-};
-function validateExitCode(exitCode) {
-  if (!Number.isInteger(exitCode) || exitCode < 0 || exitCode > 255) {
-    throw new RangeError("Exit status must be an integer between 0 and 255");
-  }
-  return exitCode;
-}
-
-// packages/safe-bash/src/contracts/errors.ts
-init_platform();
-import { isErrnoCode, isFsError, toFsError, FsError } from "@poe-platform/safe-fs/core";
-
-// packages/safe-bash/src/contracts/io.ts
-init_platform();
-init_platform();
-import { collectBytes, readBytes } from "@poe-platform/safe-fs/core";
-import { collectBytes as collectBytes2, readBytes as readBytes2, toByteSource } from "@poe-platform/safe-fs/core";
-var outputFailure = /* @__PURE__ */ Symbol("output failure");
-function createBytePipe(options = {}) {
-  const highWaterMark = options.highWaterMark ?? 64 * 1024;
-  const signal = options.signal;
-  if (!Number.isSafeInteger(highWaterMark) || highWaterMark < 1) {
-    throw new RangeError("highWaterMark must be a positive safe integer");
-  }
-  const stream = new TransformStream(
-    void 0,
-    { highWaterMark: 1 },
-    { highWaterMark, size: (chunk) => chunk.byteLength }
-  );
-  const reader = stream.readable.getReader();
-  const writer = stream.writable.getWriter();
-  let ended = false;
-  let failed = false;
-  let failure;
-  let closePromise;
-  let abortPromise;
-  let finished = false;
-  const consumer = new AbortController();
-  const abort = (reason = new FsError("EPIPE", { syscall: "pipe" })) => {
-    if (abortPromise) return abortPromise;
-    if (finished) return Promise.resolve();
-    failed = true;
-    failure = reason;
-    ended = true;
-    consumer.abort(reason);
-    abortPromise = Promise.allSettled([reader.cancel(reason), writer.abort(reason)]).then(() => {
-    });
-    return abortPromise;
-  };
-  const onAbort = () => {
-    void abort(signal?.reason);
-  };
-  const cleanup = () => signal?.removeEventListener("abort", onAbort);
-  void writer.closed.catch(() => {
-  });
-  void reader.closed.then(cleanup, cleanup);
-  if (signal?.aborted) onAbort();
-  else signal?.addEventListener("abort", onAbort, { once: true });
-  const iterator = (async function* () {
-    try {
-      while (true) {
-        if (failed) throw failure;
-        const result = await reader.read();
-        if (failed) throw failure;
-        if (result.done) {
-          finished = true;
-          return;
-        }
-        yield result.value;
-      }
-    } finally {
-      if (!finished) await abort();
-      reader.releaseLock();
-    }
-  })();
-  const readable = {
-    [Symbol.asyncIterator]() {
-      return this;
-    },
-    next() {
-      return iterator.next();
-    },
-    async return() {
-      if (!finished) await abort();
-      try {
-        return await iterator.return(void 0);
-      } finally {
-        reader.releaseLock();
-      }
-    },
-    async throw(reason) {
-      await abort(reason);
-      try {
-        return await iterator.throw(reason);
-      } finally {
-        reader.releaseLock();
-      }
-    }
-  };
-  const write = async (chunk) => {
-    if (failed) throw failure;
-    if (ended) throw new FsError("EPIPE", { syscall: "write" });
-    if (!(chunk instanceof Uint8Array)) throw new TypeError("Byte sinks require Uint8Array chunks");
-    if (chunk.byteLength > 0) await writer.write(new Uint8Array(chunk));
-  };
-  return {
-    readable,
-    writable: {
-      write,
-      [outputFailure]: abort,
-      ownedOutput: { consumerClosed: consumer.signal, write }
-    },
-    close() {
-      if (failed) return Promise.reject(failure);
-      ended = true;
-      closePromise ??= writer.close();
-      return closePromise;
-    },
-    abort
-  };
-}
-async function writeText(sink, text) {
-  await sink.write(new TextEncoder().encode(text));
-}
-async function writeBytes(sink, chunk, signal) {
-  if (!(chunk instanceof Uint8Array)) throw new TypeError("Byte sinks require Uint8Array chunks");
-  await abortable(() => sink.write(chunk), signal);
-}
-async function pipeBytes(source, sink, signal) {
-  signal?.throwIfAborted();
-  for await (const chunk of readBytes(source, signal)) {
-    await writeBytes(sink, chunk, signal);
-  }
-  signal?.throwIfAborted();
-}
-async function collectText(source, options) {
-  return new TextDecoder().decode(await collectBytes(source, options));
-}
-async function abortable(operation, signal) {
-  signal?.throwIfAborted();
-  if (!signal) return operation();
-  return new Promise((resolve, reject) => {
-    const onAbort = () => {
-      signal.removeEventListener("abort", onAbort);
-      reject(signal.reason);
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    try {
-      Promise.resolve(operation()).then(
-        (result) => {
-          signal.removeEventListener("abort", onAbort);
-          resolve(result);
-        },
-        (error) => {
-          signal.removeEventListener("abort", onAbort);
-          reject(error);
-        }
-      );
-    } catch (error) {
-      signal.removeEventListener("abort", onAbort);
-      reject(error);
-    }
-  });
-}
-
-// 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;
-}
-
-// packages/safe-bash/src/contracts/yield.ts
-init_platform();
-var checkpoints = /* @__PURE__ */ new WeakMap();
-function monotonicNow() {
-  return globalThis.performance?.now() ?? Date.now();
-}
-function registerYieldCheckpoint(signal, checkpoint) {
-  checkpoints.set(signal, checkpoint);
-}
-function scheduleTurn(callback) {
-  const host = globalThis;
-  return host.setImmediate ? { kind: "immediate", value: host.setImmediate(callback) } : { kind: "timeout", value: setTimeout(callback, 0) };
-}
-function cancelTurn(handle) {
-  if (handle?.kind === "immediate") globalThis.clearImmediate?.(handle.value);
-  else if (handle) clearTimeout(handle.value);
-}
-function yieldTurn(signal) {
-  signal?.throwIfAborted();
-  if (signal) checkpoints.get(signal)?.();
-  return new Promise((resolve, reject) => {
-    let handle;
-    const finish = () => {
-      signal?.removeEventListener("abort", abort);
-      resolve();
-    };
-    const abort = () => {
-      cancelTurn(handle);
-      reject(signal.reason);
-    };
-    signal?.addEventListener("abort", abort, { once: true });
-    if (signal?.aborted) abort();
-    else handle = scheduleTurn(finish);
-  });
-}
-
 export {
   __toESM,
   require_buffer,
+  TransformStream,
   import_buffer,
-  init_platform,
-  shellValueFromBytes,
-  shellValueText,
-  shellValueByteLength,
-  shellValueRetainedBytes,
-  shellValueBytes,
-  concatShellValues,
-  CommandArgumentIdentityError,
-  createCommandArguments,
-  getCommandArguments,
-  CommandRegistry,
-  validateExitCode,
-  isErrnoCode,
-  isFsError,
-  toFsError,
-  FsError,
-  outputFailure,
-  createBytePipe,
-  writeText,
-  writeBytes,
-  pipeBytes,
-  collectText,
-  collectBytes2 as collectBytes,
-  readBytes2 as readBytes,
-  toByteSource,
-  PublicDiagnostic,
-  publicDiagnosticMessage,
-  monotonicNow,
-  registerYieldCheckpoint,
-  scheduleTurn,
-  cancelTurn,
-  yieldTurn
+  init_platform
 };
 /*! Bundled license information:
 
@@ -2472,4 +1846,4 @@ buffer/index.js:
    * @license  MIT
    *)
 */
-//# sourceMappingURL=chunk-4NMFAR4Z.js.map
+//# sourceMappingURL=chunk-2KL6W6NB.js.map