@poe-platform/safe-bash 0.1.435 → 0.1.436

package/dist/safe-bash/portable.js

@@ -9317,6 +9317,39 @@ function throwCleanupFailures(failures) {
 
 // packages/safe-bash/src/shell/getopts.ts
 init_platform();
+var ownedInputs = /* @__PURE__ */ new WeakMap();
+function getoptsInputAllocationSize(argumentsCount) {
+  return { bytes: 256 + argumentsCount * 8, slots: argumentsCount + 2 };
+}
+async function createGetoptsInput(args, allocation, controls2) {
+  const work = new ScanWork(controls2);
+  if (!Array.isArray(args)) throw new GetoptsError("INVALID_INPUT", "Getopts requires an argument array");
+  const length = args.length;
+  if (length > work.maxArguments) throw new GetoptsError("ARGUMENT_LIMIT", "Getopts argument limit exceeded");
+  const size = getoptsInputAllocationSize(length);
+  const reservation = allocation?.reserve(size.bytes, size.slots);
+  try {
+    const snapshot = [];
+    for (let index = 0; index < length; index++) {
+      const waiting = work.step();
+      if (waiting) await waiting;
+      snapshot.push(args[index]);
+    }
+    await work.flush();
+    if (args.length !== length) throw new GetoptsError("INVALID_INPUT", "Getopts argument extent changed during admission");
+    const input3 = Object.freeze({ args: Object.freeze(snapshot) });
+    reservation?.commit(input3);
+    ownedInputs.set(input3, {});
+    return input3;
+  } catch (error) {
+    try {
+      reservation?.release();
+    } catch (cleanup) {
+      throw new AggregateError([error, cleanup], "Getopts input allocation and release failed");
+    }
+    throw error;
+  }
+}
 var GetoptsError = class extends Error {
   constructor(code, message3) {
     super(message3);
@@ -9381,6 +9414,9 @@ var ScanWork = class {
   check() {
     this.signal?.throwIfAborted();
   }
+  get inputBytes() {
+    return this.bytes;
+  }
   step() {
     this.check();
     if (this.steps === this.maxSteps) throw new GetoptsError("STEP_LIMIT", "Getopts work step limit exceeded");
@@ -9437,19 +9473,25 @@ async function validateString(value2, work, optstring = false) {
     else work.addBytes(3);
   }
 }
-async function scanGetopts(state, optstring, args, options3) {
+async function scanGetopts(state, optstring, input3, options3) {
   if (!record2(options3) || typeof options3.reportErrors !== "boolean") throw new GetoptsError("INVALID_INPUT", "Getopts requires explicit diagnostic policy and work controls");
   const work = new ScanWork(options3.work);
   const original = cloneGetoptsState(state);
+  const owned = ownedInputs.get(input3);
+  const args = owned ? input3.args : input3;
   if (!Array.isArray(args)) throw new GetoptsError("INVALID_INPUT", "Getopts requires an argument array");
   if (args.length > work.maxArguments) throw new GetoptsError("ARGUMENT_LIMIT", "Getopts argument limit exceeded");
   const starting = work.step();
   if (starting) await starting;
   await validateString(optstring, work, true);
-  for (let argument2 = 0; argument2 < args.length; argument2++) {
-    const waiting = work.step();
-    if (waiting) await waiting;
-    await validateString(args[argument2], work);
+  const specificationBytes = work.inputBytes;
+  if (owned?.bytes !== void 0) work.addBytes(owned.bytes);
+  else {
+    for (let argument2 = 0; argument2 < args.length; argument2++) {
+      const waiting = work.step();
+      if (waiting) await waiting;
+      await validateString(args[argument2], work);
+    }
   }
   const silent = optstring.startsWith(":");
   const specification = new Int8Array(128).fill(-1);
@@ -9465,6 +9507,7 @@ async function scanGetopts(state, optstring, args, options3) {
     const waiting = work.step();
     if (waiting) await waiting;
     await work.flush();
+    if (owned) owned.bytes = work.inputBytes - specificationBytes;
     return { state: active === void 0 ? { index } : { index, active: { ...active } }, kind, status: kind === "end" ? 1 : 0, option: option2, optind: index, argument: argument2, diagnostic: diagnostic4 };
   };
   const end = () => {
@@ -10632,20 +10675,45 @@ var StateMonitor = class {
   #restorations;
   #overlays;
   #retireCleanup;
+  #positionalRevision = {};
+  #getoptsInput;
   closeValues() {
     this.values.close();
     this.positionals.close();
+    this.invalidateGetoptsInput();
     this.#retireCleanup?.();
     this.#retireCleanup = void 0;
   }
+  get positionalRevision() {
+    return this.#positionalRevision;
+  }
+  get getoptsInput() {
+    return this.#getoptsInput?.input;
+  }
+  retainGetoptsInput(revision, input3, allocation) {
+    this.session.scope.assertOpen();
+    if (revision !== this.#positionalRevision) return false;
+    this.#getoptsInput?.allocation.close();
+    this.#getoptsInput = { input: input3, allocation };
+    return true;
+  }
+  invalidateGetoptsInput() {
+    this.#getoptsInput?.allocation.close();
+    this.#getoptsInput = void 0;
+    this.#positionalRevision = {};
+  }
   changedValue(target, field, key) {
     if (field === "state") {
       if (key === "variables") this.values.invalidate();
-      if (key === "positional") this.positionals.invalidate();
+      if (key === "positional") {
+        this.positionals.invalidate();
+        this.invalidateGetoptsInput();
+      }
     } else if (field === "variables" && (this.raw.variables === target || this.raw.variables === this.#wrapped.get(target))) {
       this.values.invalidate(String(key));
     } else if (field === "positional" && (this.raw.positional === target || this.raw.positional === this.#wrapped.get(target))) {
       this.positionals.invalidate();
+      this.invalidateGetoptsInput();
     }
   }
   internalOwner() {
@@ -15520,26 +15588,49 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     }
     const optstring = context2.args[offset];
     const name2 = context2.args[offset + 1];
-    const args = context2.args.length > offset + 2 ? context2.args.slice(offset + 2) : state.positional;
-    if (args.length > fields2) this.budget.fail("maxExpansionFields");
-    for (let index = 0; index < args.length; index++) {
-      this.signal.throwIfAborted();
-      admit2(args[index]);
-      if ((index + 1) % 128 === 0) await checkpoint();
-    }
-    const maxBytes = saturatedProduct(bytes3, saturatedSum(args.length, 1));
-    const maxSteps = saturatedSum(saturatedProduct(maxBytes, 2), saturatedSum(args.length, 2));
-    state.getopts ??= cloneGetoptsBinding(state);
+    const explicit = context2.args.length > offset + 2;
+    const monitor = explicit ? void 0 : stateMonitor(state);
+    const revision = monitor?.positionalRevision;
+    const supplied = explicit ? context2.args.slice(offset + 2) : state.positional;
+    if (supplied.length > fields2) this.budget.fail("maxExpansionFields");
+    const maxBytes = saturatedProduct(bytes3, saturatedSum(supplied.length, 1));
+    const maxSteps = saturatedSum(saturatedProduct(maxBytes, 2), saturatedSum(supplied.length, 2));
+    const work = { maxArguments: fields2, maxBytes, maxSteps, yieldEvery: 128, signal: this.signal, checkpoint };
+    let input3 = monitor?.getoptsInput;
+    let allocation;
     let result2;
     try {
-      result2 = await scanGetopts(state.getopts.cursor, optstring, args, {
-        reportErrors: state.variables.OPTERR === void 0 || state.variables.OPTERR === "" || decimalIndex(state.variables.OPTERR) !== 0,
-        work: { maxArguments: fields2, maxBytes, maxSteps, yieldEvery: 128, signal: this.signal, checkpoint }
-      });
-    } catch (error) {
+      if (!input3 && monitor) {
+        const size = getoptsInputAllocationSize(supplied.length);
+        const arena = this.budget.values;
+        const usage2 = arena.usage;
+        if (size.bytes + 64 <= arena.maximumBytes - usage2.bytes && size.slots + 1 <= arena.maximumSlots - usage2.slots) {
+          allocation = arena.scope();
+          input3 = await createGetoptsInput(supplied, allocation, work);
+        }
+      }
+      const args = input3?.args ?? supplied;
+      if (!input3 || allocation) for (let index = 0; index < args.length; index++) {
+        this.signal.throwIfAborted();
+        admit2(args[index]);
+        if ((index + 1) % 128 === 0) await checkpoint();
+      }
+      state.getopts ??= cloneGetoptsBinding(state);
+      try {
+        result2 = await scanGetopts(state.getopts.cursor, optstring, input3 ?? args, {
+          reportErrors: state.variables.OPTERR === void 0 || state.variables.OPTERR === "" || decimalIndex(state.variables.OPTERR) !== 0,
+          work
+        });
+      } catch (error) {
+        this.signal.throwIfAborted();
+        if (error instanceof GetoptsError && (error.code === "NON_ASCII_OPTION" || error.code === "INVALID_INPUT")) throw new CommandFailure(`getopts: ${error.message}`, 2);
+        throw error;
+      }
       this.signal.throwIfAborted();
-      if (error instanceof GetoptsError && (error.code === "NON_ASCII_OPTION" || error.code === "INVALID_INPUT")) throw new CommandFailure(`getopts: ${error.message}`, 2);
-      throw error;
+      if (monitor && monitor.positionalRevision !== revision) throw new CommandFailure("getopts: positional arguments changed during validation", 2);
+      if (allocation && monitor.retainGetoptsInput(revision, input3, allocation)) allocation = void 0;
+    } finally {
+      allocation?.close();
     }
     this.signal.throwIfAborted();
     state.getopts.cursor = result2.state;