@poe-platform/safe-bash 0.1.530 → 0.1.531

package/dist/safe-bash/chunks/{chunk-NYHAKXQ7.js → chunk-6MHYEBAJ.js}

@@ -1,16 +1,11 @@
 import {
   Budget,
   Decimal,
-  FsError,
   JqError,
   JqLimitError,
   compareNumbers,
   copyObject,
   decimalNumber,
-  escapeText,
-  getCommandArguments,
-  import_buffer,
-  init_platform,
   interruptible,
   isNumber,
   isObject,
@@ -21,148 +16,30 @@ import {
   objectKeyIterator,
   objectKeys,
   objectSize,
-  outputFailure,
-  pathOf,
   put,
-  readBytes,
   remove,
   scalarJson,
-  shellValueByteLength,
   truth,
-  wellFormed,
-  writeBytes,
+  wellFormed
+} from "./chunk-54Z5EUCW.js";
+import {
+  createOutputOperation
+} from "./chunk-2GV4WO7O.js";
+import {
+  FsError,
+  escapeText,
+  getCommandArguments,
+  import_buffer,
+  init_platform,
+  pathOf,
+  readBytes,
+  shellValueByteLength,
   yieldTurn
-} from "./chunk-5OCQTFXT.js";
+} from "./chunk-LUJYX5H5.js";
 
 // packages/safe-bash/src/commands/yq/index.ts
 init_platform();
 
-// packages/safe-bash/src/contracts/output.ts
-init_platform();
-function createOutputOperation(context, destination) {
-  const controller = new AbortController();
-  const signal = controller.signal;
-  const capability = destination.ownedOutput;
-  const callbacks = [];
-  const children = [];
-  const closedReason = new Error("Output operation is closed");
-  let accepting = true;
-  let drain;
-  const assertOpen = () => {
-    context.signal.throwIfAborted();
-    signal.throwIfAborted();
-    if (!accepting) throw closedReason;
-  };
-  const close = () => {
-    if (drain) return drain;
-    accepting = false;
-    drain = Promise.resolve().then(async () => {
-      try {
-        const results = await Promise.allSettled(callbacks.map(async (cleanup) => cleanup()));
-        const failures = results.filter((result) => result.status === "rejected").map((result) => result.reason);
-        if (failures.length === 1) throw failures[0];
-        if (failures.length) throw new AggregateError(failures, "Output operation cleanup failed");
-      } finally {
-        context.signal.removeEventListener("abort", callerAbort);
-        capability?.consumerClosed.removeEventListener("abort", outputAbort);
-      }
-    });
-    void drain.catch(() => {
-    });
-    for (const child of children) void child.close().catch(() => {
-    });
-    return drain;
-  };
-  const abort = (reason) => {
-    controller.abort(reason);
-    void close().catch(() => {
-    });
-  };
-  const callerAbort = () => abort(context.signal.reason);
-  const outputAbort = () => abort(capability?.consumerClosed.reason);
-  const registerCleanup = (cleanup) => {
-    assertOpen();
-    if (typeof cleanup !== "function") throw new TypeError("Cleanup must be callable");
-    callbacks.push(cleanup);
-  };
-  const wait = (pending) => new Promise((resolve, reject) => {
-    const aborted = () => reject(signal.reason);
-    if (signal.aborted) aborted();
-    else signal.addEventListener("abort", aborted, { once: true });
-    pending.then((value) => {
-      signal.removeEventListener("abort", aborted);
-      resolve(value);
-    }, (error) => {
-      signal.removeEventListener("abort", aborted);
-      reject(error);
-    });
-  });
-  context.registerCleanup?.(close);
-  if (context.signal.aborted) callerAbort();
-  else if (capability?.consumerClosed.aborted) outputAbort();
-  else {
-    context.signal.addEventListener("abort", callerAbort, { once: true });
-    capability?.consumerClosed.addEventListener("abort", outputAbort, { once: true });
-  }
-  return {
-    signal,
-    output: {
-      ...destination[outputFailure] ? { [outputFailure]: destination[outputFailure] } : {},
-      async write(chunk) {
-        assertOpen();
-        await writeBytes(capability ?? destination, chunk, signal);
-      }
-    },
-    registerCleanup,
-    child(destination2) {
-      assertOpen();
-      const child = createOutputOperation({ signal, registerCleanup }, destination2);
-      children.push(child);
-      return child;
-    },
-    async acquire(start, release) {
-      assertOpen();
-      let resource;
-      let settled;
-      const admitted = new Promise((resolve) => {
-        settled = resolve;
-      });
-      let released;
-      const dispose = () => {
-        released ??= admitted.then(async () => {
-          if (resource) await release(resource.value);
-        });
-        return released;
-      };
-      registerCleanup(dispose);
-      let acquisition;
-      try {
-        acquisition = Promise.resolve(start(signal));
-      } catch (error) {
-        acquisition = Promise.reject(error);
-      }
-      const pending = acquisition.then(async (value) => {
-        resource = { value };
-        settled();
-        if (!accepting) {
-          await dispose();
-          throw signal.aborted ? signal.reason : closedReason;
-        }
-        return value;
-      }, (error) => {
-        settled();
-        throw error;
-      });
-      return wait(pending);
-    },
-    close,
-    abort(reason) {
-      abort(reason);
-      return close();
-    }
-  };
-}
-
 // packages/safe-bash/src/commands/structured/query-core.ts
 init_platform();
 
@@ -5265,7 +5142,6 @@ function yqCommands(options = {}) {
 }
 
 export {
-  createOutputOperation,
   parseJson,
   jsonValues,
   rawValues,
@@ -5276,4 +5152,4 @@ export {
   createYqCommands,
   yqCommands
 };
-//# sourceMappingURL=chunk-NYHAKXQ7.js.map
+//# sourceMappingURL=chunk-6MHYEBAJ.js.map