brass-runtime 1.13.8 → 1.15.0

package/dist/chunk-TO7IKXYT.js

@@ -0,0 +1,131 @@
+import {
+  asyncEffect
+} from "./chunk-BMH5AV44.js";
+
+// 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
+};

package/dist/chunk-UMAZLXAB.mjs

@@ -0,0 +1,224 @@
+import {
+  asyncEffect,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncSucceed,
+  unsafeGetCurrentRuntime
+} from "./chunk-BDF4AMWX.mjs";
+
+// 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
+};