brass-runtime 1.14.0 → 1.15.0

package/dist/{chunk-JT7D6M5H.js → chunk-BMH5AV44.js}

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/core/types/asyncEffect.ts
 var Async = {
   succeed: (value) => ({ _tag: "Succeed", value }),
@@ -6,21 +13,18 @@ var Async = {
   async: (register) => ({ _tag: "Async", register })
 };
 function asyncFold(fa, onFailure, onSuccess) {
-  return { _tag: "Fold", first: fa, onFailure, onSuccess };
+  return {
+    _tag: "Fold",
+    first: fa,
+    onFailure,
+    onSuccess
+  };
 }
 function asyncCatchAll(fa, handler) {
-  return asyncFold(
-    fa,
-    (e) => handler(e),
-    (a) => asyncSucceed(a)
-  );
+  return asyncFold(fa, handler, asyncSucceed);
 }
 function asyncMapError(fa, f) {
-  return asyncFold(
-    fa,
-    (e) => asyncFail(f(e)),
-    (a) => asyncSucceed(a)
-  );
+  return asyncFold(fa, (e) => asyncFail(f(e)), asyncSucceed);
 }
 var SUCCEED_UNDEFINED = { _tag: "Succeed", value: void 0 };
 var SUCCEED_TRUE = { _tag: "Succeed", value: true };
@@ -43,7 +47,7 @@ var asyncSync = (thunk) => ({
   thunk
 });
 var asyncTotal = (thunk) => asyncSync(() => thunk());
-var async = (register) => ({
+var asyncEffect = (register) => ({
   _tag: "Async",
   register
 });
@@ -64,7 +68,7 @@ function acquireRelease(acquire, release, scope) {
   });
 }
 function asyncInterruptible(register) {
-  return async(register);
+  return asyncEffect(register);
 }
 var withAsyncPromise = (run) => (eff) => {
   const anyEff = eff;
@@ -101,18 +105,14 @@ var succeed = (value) => asyncSucceed(value);
 var fail = (error) => asyncFail(error);
 var sync = (thunk) => asyncSync((env) => thunk(env));
 var map = (fa, f) => asyncMap(fa, f);
-var flatMap = (fa, f) => asyncFlatMap(fa, (a) => f(a));
+var flatMap = (fa, f) => asyncFlatMap(fa, f);
 var mapError = (fa, f) => asyncMapError(fa, f);
-var catchAll = (fa, handler) => asyncFold(
-  fa,
-  (e) => handler(e),
-  (a) => asyncSucceed(a)
-);
+var catchAll = (fa, handler) => asyncFold(fa, handler, asyncSucceed);
 function orElseOptional(fa, that) {
   return asyncFold(
     fa,
     (opt) => opt._tag === "Some" ? asyncFail(opt) : that(),
-    (a) => asyncSucceed(a)
+    asyncSucceed
   );
 }
 var end = () => fail(none);
@@ -2797,7 +2797,7 @@ var Runtime = class _Runtime {
     });
   }
   delay(ms, eff) {
-    return async((_env, cb) => {
+    return asyncEffect((_env, cb) => {
       const handle = setTimeout(() => {
         this.unsafeRunAsync(eff, cb);
       }, ms);
@@ -3517,7 +3517,7 @@ var JsFiberEngine = class {
 // src/core/runtime/scope.ts
 var nextScopeId = 1;
 function awaitAll(fibers) {
-  return async((_env, cb) => {
+  return asyncEffect((_env, cb) => {
     let remaining = fibers.length;
     if (remaining === 0) {
       cb({ _tag: "Success", value: void 0 });
@@ -3628,7 +3628,7 @@ var Scope = class _Scope {
   closeAsync(exit = { _tag: "Success", value: void 0 }, opts = { awaitChildren: true }) {
     return asyncFlatMap(
       unit(),
-      () => async((env, cb) => {
+      () => asyncEffect((env, cb) => {
         if (this.closed) {
           cb({ _tag: "Success", value: void 0 });
           return;
@@ -3663,7 +3663,7 @@ var Scope = class _Scope {
   }
 };
 function withScopeAsync(runtime, f) {
-  return async((_env, cb) => {
+  return asyncEffect((_env, cb) => {
     const scope = new Scope(runtime);
     let done = false;
     const completeAfterClose = (exit) => {
@@ -3690,128 +3690,8 @@ function withScope(runtime, f) {
   });
 }
 
-// src/core/stream/structuredConcurrency.ts
-function race(left, right, parentScope) {
-  return async((env, cb) => {
-    const scope = parentScope.subScope();
-    let done = false;
-    const onResult = (exit) => {
-      if (done) return;
-      done = true;
-      scope.close(exit);
-      cb(exit);
-    };
-    const fiberLeft = scope.fork(left);
-    const fiberRight = scope.fork(right);
-    fiberLeft.join(onResult);
-    fiberRight.join(onResult);
-  });
-}
-function zipPar(left, right, parentScope) {
-  return async((env, cb) => {
-    const scope = parentScope.subScope();
-    let leftExit = null;
-    let rightExit = null;
-    let done = false;
-    const checkDone = () => {
-      if (!leftExit || !rightExit || done) return;
-      done = true;
-      if (leftExit._tag === "Success" && rightExit._tag === "Success") {
-        scope.close({ _tag: "Success", value: void 0 });
-        cb({
-          _tag: "Success",
-          value: [leftExit.value, rightExit.value]
-        });
-        return;
-      }
-      let cause;
-      if (leftExit._tag === "Failure") {
-        cause = leftExit.cause;
-      } else if (rightExit._tag === "Failure") {
-        cause = rightExit.cause;
-      } else {
-        throw new Error("zipPar: unreachable state (no Failure exit)");
-      }
-      const errExit = {
-        _tag: "Failure",
-        cause
-      };
-      scope.close(errExit);
-      cb(errExit);
-    };
-    const f1 = scope.fork(left);
-    const f2 = scope.fork(right);
-    f1.join((exit) => {
-      leftExit = exit;
-      checkDone();
-    });
-    f2.join((exit) => {
-      rightExit = exit;
-      checkDone();
-    });
-  });
-}
-function collectAllPar(effects, parentScope) {
-  return async((env, cb) => {
-    const scope = parentScope.subScope();
-    const results = new Array(effects.length);
-    let completed = 0;
-    let done = false;
-    effects.forEach((eff, i) => {
-      const f = scope.fork(eff);
-      f.join((exit) => {
-        if (done) return;
-        if (exit._tag === "Failure") {
-          done = true;
-          const errExit = {
-            _tag: "Failure",
-            cause: exit.cause
-          };
-          scope.close(errExit);
-          cb(errExit);
-          return;
-        }
-        results[i] = exit.value;
-        completed++;
-        if (completed === effects.length) {
-          done = true;
-          const successExit = {
-            _tag: "Success",
-            value: results
-          };
-          scope.close({ _tag: "Success", value: void 0 });
-          cb(successExit);
-        }
-      });
-    });
-  });
-}
-function raceWith(left, right, parentScope, onLeft, onRight) {
-  return async((env, cb) => {
-    const scope = parentScope.subScope();
-    let done = false;
-    const fiberLeft = scope.fork(left);
-    const fiberRight = scope.fork(right);
-    const finish = (next) => {
-      scope.fork(next).join((exitNext) => {
-        scope.close(exitNext);
-        cb(exitNext);
-      });
-    };
-    fiberLeft.join((exitL) => {
-      if (done) return;
-      done = true;
-      finish(onLeft(exitL, fiberRight, scope));
-    });
-    fiberRight.join((exitR) => {
-      if (done) return;
-      done = true;
-      finish(onRight(exitR, fiberLeft, scope));
-    });
-  });
-}
-
 export {
+  __require,
   Async,
   asyncFold,
   asyncCatchAll,
@@ -3821,7 +3701,7 @@ export {
   asyncFail,
   asyncSync,
   asyncTotal,
-  async,
+  asyncEffect,
   asyncMap,
   asyncFlatMap,
   acquireRelease,
@@ -3889,9 +3769,5 @@ export {
   withCurrentFiber,
   Scope,
   withScopeAsync,
-  withScope,
-  race,
-  zipPar,
-  collectAllPar,
-  raceWith
+  withScope
 };

package/dist/chunk-ELOOF35R.mjs

@@ -0,0 +1,131 @@
+import {
+  asyncEffect
+} from "./chunk-BDF4AMWX.mjs";
+
+// src/core/stream/structuredConcurrency.ts
+function race(left, right, parentScope) {
+  return asyncEffect((env, cb) => {
+    const scope = parentScope.subScope();
+    let done = false;
+    const onResult = (exit) => {
+      if (done) return;
+      done = true;
+      scope.close(exit);
+      cb(exit);
+    };
+    const fiberLeft = scope.fork(left);
+    const fiberRight = scope.fork(right);
+    fiberLeft.join(onResult);
+    fiberRight.join(onResult);
+  });
+}
+function zipPar(left, right, parentScope) {
+  return asyncEffect((env, cb) => {
+    const scope = parentScope.subScope();
+    let leftExit = null;
+    let rightExit = null;
+    let done = false;
+    const checkDone = () => {
+      if (!leftExit || !rightExit || done) return;
+      done = true;
+      if (leftExit._tag === "Success" && rightExit._tag === "Success") {
+        scope.close({ _tag: "Success", value: void 0 });
+        cb({
+          _tag: "Success",
+          value: [leftExit.value, rightExit.value]
+        });
+        return;
+      }
+      let cause;
+      if (leftExit._tag === "Failure") {
+        cause = leftExit.cause;
+      } else if (rightExit._tag === "Failure") {
+        cause = rightExit.cause;
+      } else {
+        throw new Error("zipPar: unreachable state (no Failure exit)");
+      }
+      const errExit = {
+        _tag: "Failure",
+        cause
+      };
+      scope.close(errExit);
+      cb(errExit);
+    };
+    const f1 = scope.fork(left);
+    const f2 = scope.fork(right);
+    f1.join((exit) => {
+      leftExit = exit;
+      checkDone();
+    });
+    f2.join((exit) => {
+      rightExit = exit;
+      checkDone();
+    });
+  });
+}
+function collectAllPar(effects, parentScope) {
+  return asyncEffect((env, cb) => {
+    const scope = parentScope.subScope();
+    const results = new Array(effects.length);
+    let completed = 0;
+    let done = false;
+    effects.forEach((eff, i) => {
+      const f = scope.fork(eff);
+      f.join((exit) => {
+        if (done) return;
+        if (exit._tag === "Failure") {
+          done = true;
+          const errExit = {
+            _tag: "Failure",
+            cause: exit.cause
+          };
+          scope.close(errExit);
+          cb(errExit);
+          return;
+        }
+        results[i] = exit.value;
+        completed++;
+        if (completed === effects.length) {
+          done = true;
+          const successExit = {
+            _tag: "Success",
+            value: results
+          };
+          scope.close({ _tag: "Success", value: void 0 });
+          cb(successExit);
+        }
+      });
+    });
+  });
+}
+function raceWith(left, right, parentScope, onLeft, onRight) {
+  return asyncEffect((env, cb) => {
+    const scope = parentScope.subScope();
+    let done = false;
+    const fiberLeft = scope.fork(left);
+    const fiberRight = scope.fork(right);
+    const finish = (next) => {
+      scope.fork(next).join((exitNext) => {
+        scope.close(exitNext);
+        cb(exitNext);
+      });
+    };
+    fiberLeft.join((exitL) => {
+      if (done) return;
+      done = true;
+      finish(onLeft(exitL, fiberRight, scope));
+    });
+    fiberRight.join((exitR) => {
+      if (done) return;
+      done = true;
+      finish(onRight(exitR, fiberLeft, scope));
+    });
+  });
+}
+
+export {
+  race,
+  zipPar,
+  collectAllPar,
+  raceWith
+};