brass-runtime 1.15.0 → 1.16.0

package/dist/chunk-GOV47PPB.mjs

@@ -0,0 +1,552 @@
+import {
+  sleep
+} from "./chunk-7V4KY4RL.mjs";
+import {
+  Scope
+} from "./chunk-CCKHV5BT.mjs";
+import {
+  unsafeGetCurrentRuntime
+} from "./chunk-G6IQOE4P.mjs";
+import {
+  Cause,
+  Exit,
+  asyncEffect,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncSucceed,
+  unit
+} from "./chunk-NOYZIMUJ.mjs";
+
+// src/core/runtime/resource.ts
+function bracket(acquire, use, release) {
+  return asyncEffect((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const scope = new Scope(runtime);
+    const acquireFiber = scope.fork(acquire);
+    acquireFiber.join((acquireExit) => {
+      if (acquireExit._tag === "Failure") {
+        scope.close(acquireExit);
+        cb(acquireExit);
+        return;
+      }
+      const resource2 = acquireExit.value;
+      const useFiber = scope.fork(use(resource2));
+      useFiber.join((useExit) => {
+        const releaseEffect = safeRelease(release, resource2, useExit);
+        const releaseFiber = runtime.fork(releaseEffect);
+        releaseFiber.join(() => {
+          scope.close(useExit);
+          cb(useExit);
+        });
+      });
+    });
+    return () => {
+      scope.close(Exit.failCause(Cause.interrupt()));
+    };
+  });
+}
+function safeRelease(release, resource2, exit) {
+  return asyncFold(
+    (() => {
+      try {
+        return release(resource2, exit);
+      } catch {
+        return unit();
+      }
+    })(),
+    () => unit(),
+    () => unit()
+  );
+}
+function ensuring(effect, finalizer) {
+  return asyncEffect((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      const fin = asyncFold(
+        (() => {
+          try {
+            return finalizer(exit);
+          } catch {
+            return unit();
+          }
+        })(),
+        () => unit(),
+        () => unit()
+      );
+      runtime.fork(fin).join(() => {
+        cb(exit);
+      });
+    });
+    return () => {
+      fiber.interrupt();
+    };
+  });
+}
+function resource(acquire, release) {
+  return makeResourceFromUse((body) => bracket(acquire, body, release));
+}
+var makeResource = resource;
+function resourceSucceed(value) {
+  return makeResourceFromUse((body) => body(value));
+}
+function resourceFromManaged(m) {
+  return makeResourceFromUse((body) => useManaged(m, body));
+}
+function useResource(res, body) {
+  return res.use(body);
+}
+function resourceAll(resources) {
+  const build = (index) => {
+    if (index >= resources.length) return resourceSucceed([]);
+    return resources[index].flatMap(
+      (head) => build(index + 1).map((tail) => [head, ...tail])
+    );
+  };
+  return build(0).map((values) => values);
+}
+var Resource = Object.freeze({
+  make: resource,
+  succeed: resourceSucceed,
+  fromManaged: resourceFromManaged,
+  all: resourceAll,
+  use: useResource
+});
+function makeResourceFromUse(use) {
+  const self = {
+    _tag: "Resource",
+    use,
+    map: (f) => makeResourceFromUse((body) => self.use((a) => body(f(a)))),
+    flatMap: (f) => makeResourceFromUse((body) => self.use((a) => f(a).use(body))),
+    zip: (that) => self.flatMap((a) => that.map((b) => [a, b]))
+  };
+  return self;
+}
+function managed(acquire, release) {
+  return {
+    _tag: "Managed",
+    acquire,
+    release: (resource2, exit) => release(resource2, exit)
+  };
+}
+function useManaged(m, body) {
+  return bracket(m.acquire, body, m.release);
+}
+function managedAll(manageds) {
+  const acquire = asyncEffect((env, cb) => {
+    const runtime = unsafeGetCurrentRuntime();
+    const resources = [];
+    let i = 0;
+    const acquireNext = () => {
+      if (i >= manageds.length) {
+        cb({ _tag: "Success", value: resources });
+        return;
+      }
+      const m = manageds[i];
+      const fiber = runtime.fork(m.acquire);
+      fiber.join((exit) => {
+        if (exit._tag === "Failure") {
+          releaseAcquired(runtime, manageds, resources, exit).then(() => {
+            cb(exit);
+          });
+          return;
+        }
+        resources.push(exit.value);
+        i++;
+        acquireNext();
+      });
+    };
+    acquireNext();
+  });
+  const release = (resources, exit) => {
+    return asyncEffect((_env, cb) => {
+      const runtime = unsafeGetCurrentRuntime();
+      releaseAcquired(runtime, manageds, resources, exit).then(() => {
+        cb({ _tag: "Success", value: void 0 });
+      });
+    });
+  };
+  return { _tag: "Managed", acquire, release };
+}
+async function releaseAcquired(runtime, manageds, resources, exit) {
+  for (let i = resources.length - 1; i >= 0; i--) {
+    try {
+      const m = manageds[i];
+      await new Promise((resolve) => {
+        const releaseEff = asyncFold(
+          m.release(resources[i], exit),
+          () => unit(),
+          () => unit()
+        );
+        runtime.fork(releaseEff).join(() => resolve());
+      });
+    } catch {
+    }
+  }
+}
+
+// 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 elapsed2 = Date.now() - openedAt;
+        if (elapsed2 >= 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
+  };
+}
+
+// src/core/runtime/schedule.ts
+function recurs(n) {
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count, _input) => {
+      const next = count + 1;
+      return [{ continue: next < n, delayMs: 0 }, next, next];
+    }
+  };
+}
+function fixed(delayMs) {
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count, _input) => {
+      return [{ continue: true, delayMs }, count + 1, count + 1];
+    }
+  };
+}
+function exponential(baseMs, maxMs = Infinity) {
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count, _input) => {
+      const delay = Math.min(baseMs * Math.pow(2, count), maxMs);
+      return [{ continue: true, delayMs: delay }, count + 1, count + 1];
+    }
+  };
+}
+function fibonacci(baseMs, maxMs = Infinity) {
+  const base = Math.max(0, baseMs);
+  const cap = Math.max(0, maxMs);
+  return {
+    _tag: "Schedule",
+    initial: () => ({ prev: 0, curr: 1, count: 0 }),
+    step: (state, _input) => {
+      const delay = Math.min(base * state.curr, cap);
+      const next = {
+        prev: state.curr,
+        curr: state.prev + state.curr,
+        count: state.count + 1
+      };
+      return [{ continue: true, delayMs: delay }, next, state.count + 1];
+    }
+  };
+}
+function jittered(baseMs, maxMs = Infinity) {
+  return jitteredSchedule(exponential(baseMs, maxMs), { factor: 1 });
+}
+function elapsed(maxMs) {
+  return {
+    _tag: "Schedule",
+    initial: () => performance.now(),
+    step: (startedAt, _input) => {
+      const el = performance.now() - startedAt;
+      return [{ continue: el < maxMs, delayMs: 0 }, startedAt, el];
+    }
+  };
+}
+function whileInput(pred) {
+  return {
+    _tag: "Schedule",
+    initial: () => void 0,
+    step: (_state, input) => {
+      return [{ continue: pred(input), delayMs: 0 }, void 0, input];
+    }
+  };
+}
+function take(schedule, n) {
+  return {
+    _tag: "Schedule",
+    initial: () => ({ inner: schedule.initial(), count: 0 }),
+    step: (state, input) => {
+      if (state.count >= n) return [{ continue: false, delayMs: 0 }, state, void 0];
+      const [decision, nextInner, output] = schedule.step(state.inner, input);
+      const nextState = { inner: nextInner, count: state.count + 1 };
+      return [{ continue: decision.continue && state.count + 1 < n, delayMs: decision.delayMs }, nextState, output];
+    }
+  };
+}
+function map(schedule, f) {
+  return {
+    _tag: "Schedule",
+    initial: schedule.initial,
+    step: (state, input) => {
+      const [decision, nextState, output] = schedule.step(state, input);
+      return [decision, nextState, f(output)];
+    }
+  };
+}
+function contramap(schedule, f) {
+  return {
+    _tag: "Schedule",
+    initial: schedule.initial,
+    step: (state, input) => schedule.step(state, f(input))
+  };
+}
+function jitteredSchedule(schedule, options = {}) {
+  const factor = typeof options === "number" ? options : options.factor ?? 1;
+  const random = typeof options === "number" ? Math.random : options.random ?? Math.random;
+  const spread = Math.max(0, factor);
+  return {
+    _tag: "Schedule",
+    initial: schedule.initial,
+    step: (state, input) => {
+      const [decision, nextState, output] = schedule.step(state, input);
+      if (!decision.continue || decision.delayMs <= 0 || spread === 0) {
+        return [decision, nextState, output];
+      }
+      const delay = spread >= 1 ? Math.floor(random() * decision.delayMs) : Math.floor(decision.delayMs * (1 - spread + random() * spread * 2));
+      return [{ ...decision, delayMs: Math.max(0, delay) }, nextState, output];
+    }
+  };
+}
+var jitter = jitteredSchedule;
+function windowed(schedule, windowMs, clock = defaultClock) {
+  const window = Math.max(0, windowMs);
+  return {
+    _tag: "Schedule",
+    initial: () => ({ inner: schedule.initial(), windowStartedAt: clock() }),
+    step: (state, input) => {
+      const now = clock();
+      const shouldReset = window > 0 && now - state.windowStartedAt > window;
+      const inner = shouldReset ? schedule.initial() : state.inner;
+      const windowStartedAt = shouldReset ? now : state.windowStartedAt;
+      const [decision, nextInner, output] = schedule.step(inner, input);
+      return [decision, { inner: nextInner, windowStartedAt }, output];
+    }
+  };
+}
+function defaultClock() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function andThen(first, second) {
+  return {
+    _tag: "Schedule",
+    initial: () => ({ phase: "first", inner: first.initial() }),
+    step: (state, input) => {
+      if (state.phase === "first") {
+        const [decision2, nextInner2, output2] = first.step(state.inner, input);
+        if (decision2.continue) {
+          return [decision2, { phase: "first", inner: nextInner2 }, output2];
+        }
+        return [{ continue: true, delayMs: decision2.delayMs }, { phase: "second", inner: second.initial() }, output2];
+      }
+      const [decision, nextInner, output] = second.step(state.inner, input);
+      return [decision, { phase: "second", inner: nextInner }, output];
+    }
+  };
+}
+function intersect(left, right) {
+  return {
+    _tag: "Schedule",
+    initial: () => ({ left: left.initial(), right: right.initial() }),
+    step: (state, input) => {
+      const [ld, ls, lo] = left.step(state.left, input);
+      const [rd, rs, ro] = right.step(state.right, input);
+      const cont = ld.continue && rd.continue;
+      const delay = Math.max(ld.delayMs, rd.delayMs);
+      return [{ continue: cont, delayMs: delay }, { left: ls, right: rs }, [lo, ro]];
+    }
+  };
+}
+function union(left, right) {
+  return {
+    _tag: "Schedule",
+    initial: () => ({ left: left.initial(), right: right.initial() }),
+    step: (state, input) => {
+      const [ld, ls, lo] = left.step(state.left, input);
+      const [rd, rs, ro] = right.step(state.right, input);
+      const cont = ld.continue || rd.continue;
+      const delay = Math.min(ld.delayMs, rd.delayMs);
+      return [{ continue: cont, delayMs: delay }, { left: ls, right: rs }, [lo, ro]];
+    }
+  };
+}
+function retryWithSchedule(effect, schedule) {
+  const loop = (state) => asyncFold(
+    effect,
+    (error) => {
+      const [decision, nextState, _output] = schedule.step(state, error);
+      if (!decision.continue) return asyncFail(error);
+      if (decision.delayMs <= 0) return loop(nextState);
+      return asyncFlatMap(sleep(decision.delayMs), () => loop(nextState));
+    },
+    (value) => asyncSucceed(value)
+  );
+  return loop(schedule.initial());
+}
+function repeatWithSchedule(effect, schedule) {
+  const loop = (state, lastValue) => {
+    const [decision, nextState, _output] = schedule.step(state, lastValue);
+    if (!decision.continue) return asyncSucceed(lastValue);
+    if (decision.delayMs <= 0) {
+      return asyncFold(
+        effect,
+        (error) => asyncFail(error),
+        (value) => loop(nextState, value)
+      );
+    }
+    return asyncFlatMap(
+      sleep(decision.delayMs),
+      () => asyncFold(
+        effect,
+        (error) => asyncFail(error),
+        (value) => loop(nextState, value)
+      )
+    );
+  };
+  return asyncFold(
+    effect,
+    (error) => asyncFail(error),
+    (value) => loop(schedule.initial(), value)
+  );
+}
+
+export {
+  bracket,
+  ensuring,
+  resource,
+  makeResource,
+  resourceSucceed,
+  resourceFromManaged,
+  useResource,
+  resourceAll,
+  Resource,
+  managed,
+  useManaged,
+  managedAll,
+  makeCircuitBreaker,
+  recurs,
+  fixed,
+  exponential,
+  fibonacci,
+  jittered,
+  elapsed,
+  whileInput,
+  take,
+  map,
+  contramap,
+  jitteredSchedule,
+  jitter,
+  windowed,
+  andThen,
+  intersect,
+  union,
+  retryWithSchedule,
+  repeatWithSchedule
+};

package/dist/chunk-H55LI6WY.js

@@ -0,0 +1,93 @@
+import {
+  Cause
+} from "./chunk-PNVFW245.js";
+
+// src/http/effectRunner.ts
+function registerHttpEffect(effect, env, cb) {
+  let done = false;
+  let currentCancel;
+  const finish = (exit) => {
+    if (done) return;
+    done = true;
+    currentCancel = void 0;
+    cb(exit);
+  };
+  const run = (current, cont) => {
+    if (done) return;
+    switch (current._tag) {
+      case "Succeed":
+        cont({ _tag: "Success", value: current.value });
+        return;
+      case "Fail":
+        cont({ _tag: "Failure", cause: Cause.fail(current.error) });
+        return;
+      case "Sync":
+        try {
+          cont({ _tag: "Success", value: current.thunk(env) });
+        } catch (e) {
+          cont({ _tag: "Failure", cause: Cause.die(e) });
+        }
+        return;
+      case "Async": {
+        const cancel = current.register(env, (exit) => {
+          currentCancel = void 0;
+          if (done) return;
+          cont(exit);
+        });
+        currentCancel = typeof cancel === "function" ? cancel : void 0;
+        return;
+      }
+      case "FlatMap":
+        run(current.first, (exit) => {
+          if (done) return;
+          if (exit._tag === "Failure") {
+            cont(exit);
+            return;
+          }
+          try {
+            run(current.andThen(exit.value), cont);
+          } catch (e) {
+            cont({ _tag: "Failure", cause: Cause.die(e) });
+          }
+        });
+        return;
+      case "Fold":
+        run(current.first, (exit) => {
+          if (done) return;
+          try {
+            if (exit._tag === "Success") {
+              run(current.onSuccess(exit.value), cont);
+              return;
+            }
+            if (exit.cause._tag === "Fail") {
+              run(current.onFailure(exit.cause.error), cont);
+              return;
+            }
+            cont(exit);
+          } catch (e) {
+            cont({ _tag: "Failure", cause: Cause.die(e) });
+          }
+        });
+        return;
+      case "Fork":
+        cont({ _tag: "Success", value: void 0 });
+        return;
+    }
+  };
+  run(effect, finish);
+  return () => {
+    if (done) return;
+    const cancel = currentCancel;
+    currentCancel = void 0;
+    done = true;
+    try {
+      cancel?.();
+    } finally {
+      cb({ _tag: "Failure", cause: Cause.interrupt() });
+    }
+  };
+}
+
+export {
+  registerHttpEffect
+};