@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash/command-chunks/{chunk-Y2WBSJG6.js → chunk-X4QZQI5Q.js}

@@ -114,6 +114,7 @@ AbortSignal.any = function any(signals) {
     Array.from(signals, (s) => s instanceof ManagedControlSignalImpl ? s._ensureNativeSignal() : s)
   );
 };
+var combinedSignalWaiters = /* @__PURE__ */ new WeakMap();
 var CombinedSignalWaiter = class {
   constructor(primary, secondary, tertiary, combined) {
     this.primary = primary;
@@ -121,10 +122,14 @@ var CombinedSignalWaiter = class {
     this.tertiary = tertiary;
     this.combined = combined;
   }
-  onAbort(reason) {
+  dispose() {
+    combinedSignalWaiters.delete(this.combined.signal);
     removeAbortSignalWaiter(this.primary, this);
     removeAbortSignalWaiter(this.secondary, this);
     if (this.tertiary) removeAbortSignalWaiter(this.tertiary, this);
+  }
+  onAbort(reason) {
+    this.dispose();
     this.combined.abort(reason);
   }
 };
@@ -134,11 +139,15 @@ function combineManagedSignals(primary, secondary, tertiary) {
   if (tertiary?.aborted) return tertiary;
   const combined = new ManagedControlSignalImpl();
   const waiter = new CombinedSignalWaiter(primary, secondary, tertiary, combined);
+  combinedSignalWaiters.set(combined.signal, waiter);
   addAbortSignalWaiter(primary, waiter);
   addAbortSignalWaiter(secondary, waiter);
   if (tertiary) addAbortSignalWaiter(tertiary, waiter);
   return combined.signal;
 }
+function releaseCombinedSignal(signal) {
+  combinedSignalWaiters.get(signal)?.dispose();
+}
 function createManagedControlController() {
   return new ManagedControlSignalImpl();
 }
@@ -193,27 +202,33 @@ function abortManagedController(controller, reason) {
   controller.abort(reason);
   notifyAbortSignalWaiters(signal, signal.reason);
 }
+var externalWaiters = /* @__PURE__ */ new WeakMap();
 function addAbortSignalWaiter(signal, waiter) {
+  if (!isManagedAbortSignal(signal)) {
+    let entry = externalWaiters.get(signal);
+    if (!entry) {
+      const set = /* @__PURE__ */ new Set();
+      const listener = () => {
+        externalWaiters.delete(signal);
+        signal.removeEventListener("abort", listener);
+        const pending = [...set];
+        set.clear();
+        for (const waiter2 of pending) {
+          if (typeof waiter2 === "function") waiter2(signal.reason);
+          else waiter2.onAbort(signal.reason);
+        }
+      };
+      entry = { set, listener };
+      externalWaiters.set(signal, entry);
+      signal.addEventListener("abort", listener, { once: true });
+    }
+    entry.set.add(waiter);
+    return;
+  }
   const record = signal;
   const current = record[managedWaitersSymbol];
   if (!current) {
-    if (record[managedSignalSymbol]) {
-      record[managedWaitersSymbol] = waiter;
-      return;
-    }
-    const set = /* @__PURE__ */ new Set();
-    set.add(waiter);
-    record[managedWaitersSymbol] = set;
-    signal.addEventListener("abort", () => {
-      const reason = signal.reason;
-      const pending = [...set];
-      set.clear();
-      for (let i = 0; i < pending.length; i++) {
-        const w = pending[i];
-        if (typeof w === "function") w(reason);
-        else w.onAbort(reason);
-      }
-    }, { once: true });
+    record[managedWaitersSymbol] = waiter;
     return;
   }
   if (typeof current === "function" || "onAbort" in current) {
@@ -228,6 +243,14 @@ function addAbortSignalWaiter(signal, waiter) {
   current.add(waiter);
 }
 function removeAbortSignalWaiter(signal, waiter) {
+  if (!isManagedAbortSignal(signal)) {
+    const entry = externalWaiters.get(signal);
+    if (entry && entry.set.delete(waiter) && entry.set.size === 0) {
+      signal.removeEventListener("abort", entry.listener);
+      externalWaiters.delete(signal);
+    }
+    return;
+  }
   const record = signal;
   const current = record[managedWaitersSymbol];
   if (!current) return;
@@ -240,32 +263,22 @@ function removeAbortSignalWaiter(signal, waiter) {
 
 // packages/safe-bash-contracts/src/yield.ts
 var checkpointSymbol = /* @__PURE__ */ Symbol("safe-bash.yieldCheckpoint");
-var externalCheckpointSymbol = /* @__PURE__ */ Symbol("safe-bash.externalYieldCheckpoint");
 var signalYieldStateSymbol = /* @__PURE__ */ Symbol("safe-bash.signalYieldState");
 var checkpoints = /* @__PURE__ */ new WeakMap();
-var externalCheckpoints = /* @__PURE__ */ new WeakSet();
-var checkpointCount = 0;
-var externalCheckpointCount = 0;
 var signalYieldStates = /* @__PURE__ */ new WeakMap();
-function getCheckpoint(signal) {
+function getCheckpoints(signal) {
   return signal[checkpointSymbol] ?? checkpoints.get(signal);
 }
-function setCheckpoint(signal, fn) {
+function ensureCheckpoints(signal) {
+  const existing = getCheckpoints(signal);
+  if (existing) return existing;
+  const state = {};
   if (Object.isExtensible(signal)) {
-    signal[checkpointSymbol] = fn;
+    signal[checkpointSymbol] = state;
   } else {
-    checkpoints.set(signal, fn);
-  }
-}
-function isExternalCheckpoint(signal) {
-  return Boolean(signal[externalCheckpointSymbol]) || externalCheckpoints.has(signal);
-}
-function markExternalCheckpoint(signal) {
-  if (Object.isExtensible(signal)) {
-    signal[externalCheckpointSymbol] = true;
-  } else {
-    externalCheckpoints.add(signal);
+    checkpoints.set(signal, state);
   }
+  return state;
 }
 function getSignalYieldState(signal) {
   let state = signal[signalYieldStateSymbol] ?? signalYieldStates.get(signal);
@@ -298,45 +311,32 @@ function monotonicNow() {
   return globalThis.performance?.now() ?? Date.now();
 }
 function registerYieldCheckpoint(signal, checkpoint) {
-  setCheckpoint(signal, checkpoint);
-  markExternalCheckpoint(signal);
-  checkpointCount++;
-  externalCheckpointCount++;
+  ensureCheckpoints(signal).external = checkpoint;
 }
 function registerInternalYieldCheckpoint(signal, checkpoint) {
-  const existing = getCheckpoint(signal);
-  if (existing && isExternalCheckpoint(signal)) {
-    setCheckpoint(signal, () => {
-      checkpoint();
-      existing();
-    });
-  } else if (!existing) {
-    setCheckpoint(signal, checkpoint);
-    checkpointCount++;
-  }
+  ensureCheckpoints(signal).internal = checkpoint;
 }
 function runYieldCheckpoint(signal) {
   if (!signal) return;
   if (signal.aborted) throw signal.reason;
-  if (checkpointCount > 0) getCheckpoint(signal)?.();
+  const state = getCheckpoints(signal);
+  state?.internal?.();
+  state?.external?.();
 }
 function hasYieldCheckpoint(signal) {
-  return externalCheckpointCount > 0 && signal !== void 0 && isExternalCheckpoint(signal);
+  return signal !== void 0 && getCheckpoints(signal)?.external !== void 0;
 }
 function hasRegisteredYieldCheckpoint(signal) {
-  return checkpointCount > 0 && signal !== void 0 && getCheckpoint(signal) !== void 0;
+  return signal !== void 0 && getCheckpoints(signal) !== void 0;
 }
 function inheritYieldCheckpoint(parent, child) {
-  if (checkpointCount === 0) return;
-  const checkpoint = getCheckpoint(parent);
-  if (checkpoint && getCheckpoint(child) !== checkpoint) {
-    setCheckpoint(child, checkpoint);
-    checkpointCount++;
-  }
-  if (externalCheckpointCount > 0 && isExternalCheckpoint(parent)) {
-    markExternalCheckpoint(child);
-    externalCheckpointCount++;
-  }
+  const state = getCheckpoints(parent);
+  if (!state || parent === child) return;
+  const inherited = ensureCheckpoints(child);
+  if (state.internal) inherited.internal = state.internal;
+  else delete inherited.internal;
+  if (state.external) inherited.external = state.external;
+  else delete inherited.external;
 }
 function scheduleTurn(callback) {
   const host = globalThis;
@@ -348,7 +348,7 @@ function cancelTurn(handle) {
 }
 function yieldTurn(signal) {
   signal?.throwIfAborted();
-  if (signal) getCheckpoint(signal)?.();
+  runYieldCheckpoint(signal);
   return new Promise((resolve, reject) => {
     const host = globalThis;
     let immediateHandle;
@@ -412,6 +412,7 @@ export {
   yieldTurn,
   drainCooperativeSteps,
   combineManagedSignals,
+  releaseCombinedSignal,
   createManagedControlController,
   toNativeAbortSignal,
   isManagedControlSignal,

package/dist/safe-bash/command-chunks/{chunk-FPVUD6TH.js → chunk-XGI57GCN.js}

@@ -1,6 +1,6 @@
 import {
   pathOf
-} from "./chunk-XS72HTMA.js";
+} from "./chunk-BWGGLYEB.js";
 import {
   inputRequirements
 } from "./chunk-773DWG4H.js";
@@ -95,17 +95,19 @@ function createSyncSingleChunkByteSource(bytes, signal) {
 function requiredFileInput(context, requirements, mode, file, maxBytes) {
   if (maxBytes === Infinity && (context.inputBudget?.maxBytes ?? Infinity) === Infinity) {
     const fastMemFs = context._fastMemoryBackingFs;
-    if (fastMemFs !== void 0 && fastMemFs.capabilitiesFor === void 0 && context._cachedInputBudget === void 0 && !Object.prototype.hasOwnProperty.call(fastMemFs, "readStream") && !Object.prototype.hasOwnProperty.call(fastMemFs, "readFile")) {
+    if (fastMemFs !== void 0 && fastMemFs.capabilitiesFor === void 0 && !Object.prototype.hasOwnProperty.call(fastMemFs, "readStream") && !Object.prototype.hasOwnProperty.call(fastMemFs, "readFile")) {
       const path2 = pathOf(context, file);
       if (path2 !== "/dev" && !path2.startsWith("/dev/")) {
+        let bytes;
         try {
-          const bytes = tryReadMemoryFileViewSync(fastMemFs, path2, void 0, context.signal);
-          if (bytes !== void 0) {
-            context._chargeFastFsOp?.();
-            return createSyncSingleChunkByteSource(bytes, context.signal);
-          }
+          bytes = tryReadMemoryFileViewSync(fastMemFs, path2, void 0, context.signal);
         } catch {
         }
+        if (bytes !== void 0) {
+          context.inputBudget?.check(bytes.byteLength);
+          context._chargeFastFsOp?.();
+          return createSyncSingleChunkByteSource(bytes, context.signal);
+        }
       }
     }
     const path = pathOf(context, file);
@@ -135,9 +137,9 @@ async function* requiredFileInputSlow(context, requirements, mode, file, maxByte
     try {
       for await (const chunk of readBytes(context.fs.readStream(path, { signal: context.signal }), context.signal)) {
         reading = false;
+        context.inputBudget?.check(bytes + chunk.byteLength);
         if (chunk.byteLength > maxBytes - bytes) throw new FsError("EFBIG", { syscall: "read", path, message: "input file byte limit exceeded" });
         bytes += chunk.byteLength;
-        context.inputBudget?.check(bytes);
         if (chunk.byteLength) emitted = true;
         yield chunk;
         reading = true;