brass-runtime 1.14.0 → 1.15.0

package/dist/{chunk-4N2JEK4H.mjs → chunk-BDF4AMWX.mjs}

@@ -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-BDYEENHT.js

@@ -0,0 +1,224 @@
+import {
+  asyncEffect,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncSucceed,
+  unsafeGetCurrentRuntime
+} from "./chunk-BMH5AV44.js";
+
+// src/core/runtime/combinators.ts
+function sleep(ms) {
+  return asyncEffect((_env, cb) => {
+    const delay = Math.max(0, Math.floor(ms));
+    const id = setTimeout(() => cb({ _tag: "Success", value: void 0 }), delay);
+    return () => clearTimeout(id);
+  });
+}
+function timeout(effect, ms) {
+  return asyncEffect((env, cb) => {
+    let done = false;
+    let timerId;
+    let effectRunning = true;
+    timerId = setTimeout(() => {
+      if (done) return;
+      done = true;
+      effectRunning = false;
+      cb({
+        _tag: "Failure",
+        cause: { _tag: "Fail", error: { _tag: "TimeoutError", ms } }
+      });
+    }, Math.max(0, Math.floor(ms)));
+    const runtime = unsafeGetCurrentRuntime();
+    if (runtime) {
+      const fiber = runtime.fork(effect);
+      fiber.join((exit) => {
+        if (done) return;
+        done = true;
+        clearTimeout(timerId);
+        cb(exit);
+      });
+      return () => {
+        if (done) return;
+        done = true;
+        clearTimeout(timerId);
+        fiber.interrupt();
+      };
+    }
+    return () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timerId);
+    };
+  });
+}
+function retry(effect, policy) {
+  const shouldRetry = policy.shouldRetry ?? (() => true);
+  const jitter = policy.jitter ?? "full";
+  const maxElapsedMs = policy.maxElapsedMs;
+  const computeDelay = (attempt) => {
+    const exp = policy.baseDelayMs * Math.pow(2, attempt);
+    const capped = Math.min(exp, policy.maxDelayMs);
+    if (jitter === "none") return capped;
+    return Math.floor(Math.random() * capped);
+  };
+  const loop = (attempt, startedAt) => asyncFold(
+    effect,
+    (error) => {
+      if (attempt >= policy.maxRetries) return asyncFail(error);
+      if (!shouldRetry(error, attempt)) return asyncFail(error);
+      if (maxElapsedMs !== void 0) {
+        const elapsed = performance.now() - startedAt;
+        if (elapsed >= maxElapsedMs) return asyncFail(error);
+      }
+      const delay = computeDelay(attempt);
+      return asyncFlatMap(sleep(delay), () => loop(attempt + 1, startedAt));
+    },
+    (value) => asyncSucceed(value)
+  );
+  return asyncFlatMap(
+    { _tag: "Sync", thunk: () => performance.now() },
+    (startedAt) => loop(0, startedAt)
+  );
+}
+function retryN(effect, n) {
+  return retry(effect, {
+    maxRetries: n,
+    baseDelayMs: 0,
+    maxDelayMs: 0,
+    jitter: "none"
+  });
+}
+function retryWithBackoff(effect, opts = {}) {
+  return retry(effect, {
+    maxRetries: opts.maxRetries ?? 3,
+    baseDelayMs: opts.baseDelayMs ?? 100,
+    maxDelayMs: opts.maxDelayMs ?? 1e4,
+    maxElapsedMs: opts.maxElapsedMs,
+    shouldRetry: opts.shouldRetry,
+    jitter: "full"
+  });
+}
+
+// src/core/runtime/circuitBreaker.ts
+function makeCircuitBreaker(config = {}) {
+  const failureThreshold = config.failureThreshold ?? 5;
+  const resetTimeoutMs = config.resetTimeoutMs ?? 3e4;
+  const successThreshold = config.successThreshold ?? 1;
+  const isFailure = config.isFailure ?? (() => true);
+  const onStateChange = config.onStateChange;
+  let currentState = "closed";
+  let consecutiveFailures = 0;
+  let consecutiveSuccesses = 0;
+  let openedAt = 0;
+  let totalRequests = 0;
+  let totalFailures = 0;
+  let totalSuccesses = 0;
+  let totalRejected = 0;
+  let lastFailureTime = null;
+  let lastSuccessTime = null;
+  const transition = (to) => {
+    if (currentState === to) return;
+    const from = currentState;
+    currentState = to;
+    onStateChange?.(from, to);
+  };
+  const onSuccess = () => {
+    totalSuccesses++;
+    lastSuccessTime = Date.now();
+    consecutiveFailures = 0;
+    if (currentState === "half-open") {
+      consecutiveSuccesses++;
+      if (consecutiveSuccesses >= successThreshold) {
+        consecutiveSuccesses = 0;
+        transition("closed");
+      }
+    }
+  };
+  const onFailure = (error) => {
+    if (!isFailure(error)) {
+      onSuccess();
+      return;
+    }
+    totalFailures++;
+    lastFailureTime = Date.now();
+    consecutiveSuccesses = 0;
+    consecutiveFailures++;
+    if (currentState === "half-open") {
+      openedAt = Date.now();
+      transition("open");
+    } else if (currentState === "closed" && consecutiveFailures >= failureThreshold) {
+      openedAt = Date.now();
+      transition("open");
+    }
+  };
+  const shouldAllow = () => {
+    switch (currentState) {
+      case "closed":
+        return true;
+      case "open": {
+        const elapsed = Date.now() - openedAt;
+        if (elapsed >= resetTimeoutMs) {
+          transition("half-open");
+          return true;
+        }
+        return false;
+      }
+      case "half-open":
+        return true;
+    }
+  };
+  const protect = (effect) => {
+    totalRequests++;
+    if (!shouldAllow()) {
+      totalRejected++;
+      return asyncFail({
+        _tag: "CircuitBreakerOpen",
+        openSince: openedAt,
+        failures: consecutiveFailures
+      });
+    }
+    return asyncFold(
+      effect,
+      (error) => {
+        onFailure(error);
+        return asyncFail(error);
+      },
+      (value) => {
+        onSuccess();
+        return asyncSucceed(value);
+      }
+    );
+  };
+  const stats = () => ({
+    state: currentState,
+    failures: consecutiveFailures,
+    successes: consecutiveSuccesses,
+    totalRequests,
+    totalFailures,
+    totalSuccesses,
+    totalRejected,
+    lastFailureTime,
+    lastSuccessTime
+  });
+  const reset = () => {
+    consecutiveFailures = 0;
+    consecutiveSuccesses = 0;
+    transition("closed");
+  };
+  return {
+    state: () => currentState,
+    protect,
+    stats,
+    reset
+  };
+}
+
+export {
+  sleep,
+  timeout,
+  retry,
+  retryN,
+  retryWithBackoff,
+  makeCircuitBreaker
+};