brass-runtime 1.15.0 → 1.16.1

package/dist/chunk-BDYEENHT.js

@@ -1,224 +0,0 @@
-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
-};