brass-runtime 1.16.0 → 1.17.0

package/dist/chunk-PNVFW245.js

@@ -1,144 +0,0 @@
-// src/core/types/asyncEffect.ts
-var Async = {
-  succeed: (value) => ({ _tag: "Succeed", value }),
-  fail: (error) => ({ _tag: "Fail", error }),
-  sync: (thunk) => ({ _tag: "Sync", thunk }),
-  async: (register) => ({ _tag: "Async", register })
-};
-function asyncFold(fa, onFailure, onSuccess) {
-  return {
-    _tag: "Fold",
-    first: fa,
-    onFailure,
-    onSuccess
-  };
-}
-function asyncCatchAll(fa, handler) {
-  return asyncFold(fa, handler, asyncSucceed);
-}
-function asyncMapError(fa, f) {
-  return asyncFold(fa, (e) => asyncFail(f(e)), asyncSucceed);
-}
-var SUCCEED_UNDEFINED = { _tag: "Succeed", value: void 0 };
-var SUCCEED_TRUE = { _tag: "Succeed", value: true };
-var SUCCEED_FALSE = { _tag: "Succeed", value: false };
-var SUCCEED_NULL = { _tag: "Succeed", value: null };
-var unit = () => SUCCEED_UNDEFINED;
-var asyncSucceed = (value) => {
-  if (value === void 0) return SUCCEED_UNDEFINED;
-  if (value === true) return SUCCEED_TRUE;
-  if (value === false) return SUCCEED_FALSE;
-  if (value === null) return SUCCEED_NULL;
-  return { _tag: "Succeed", value };
-};
-var asyncFail = (error) => ({
-  _tag: "Fail",
-  error
-});
-var asyncSync = (thunk) => ({
-  _tag: "Sync",
-  thunk
-});
-var asyncTotal = (thunk) => asyncSync(() => thunk());
-var asyncEffect = (register) => ({
-  _tag: "Async",
-  register
-});
-function asyncMap(fa, f) {
-  return asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
-}
-function asyncFlatMap(fa, f) {
-  return {
-    _tag: "FlatMap",
-    first: fa,
-    andThen: f
-  };
-}
-function acquireRelease(acquire, release, scope) {
-  return asyncFlatMap(acquire, (resource) => {
-    scope.addFinalizer((exit) => release(resource, exit));
-    return asyncSucceed(resource);
-  });
-}
-function asyncInterruptible(register) {
-  return asyncEffect(register);
-}
-var withAsyncPromise = (run) => (eff) => {
-  const anyEff = eff;
-  if (!anyEff.toPromise) {
-    anyEff.toPromise = (env) => run(eff, env);
-    anyEff.unsafeRunPromise = () => run(eff, {});
-  }
-  return anyEff;
-};
-var mapAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSucceed(f(a)));
-var mapTryAsync = (fa, f) => asyncFlatMap(fa, (a) => asyncSync(() => f(a)));
-
-// src/core/types/option.ts
-var none = { _tag: "None" };
-var some = (value) => ({ _tag: "Some", value });
-
-// src/core/types/effect.ts
-var Cause = {
-  fail: (error) => ({ _tag: "Fail", error }),
-  interrupt: () => ({ _tag: "Interrupt" }),
-  die: (defect) => ({ _tag: "Die", defect })
-};
-var Exit = {
-  succeed: (value) => ({
-    _tag: "Success",
-    value
-  }),
-  failCause: (cause) => ({
-    _tag: "Failure",
-    cause
-  })
-};
-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, f);
-var mapError = (fa, f) => asyncMapError(fa, f);
-var catchAll = (fa, handler) => asyncFold(fa, handler, asyncSucceed);
-function orElseOptional(fa, that) {
-  return asyncFold(
-    fa,
-    (opt) => opt._tag === "Some" ? asyncFail(opt) : that(),
-    asyncSucceed
-  );
-}
-var end = () => fail(none);
-
-export {
-  Async,
-  asyncFold,
-  asyncCatchAll,
-  asyncMapError,
-  unit,
-  asyncSucceed,
-  asyncFail,
-  asyncSync,
-  asyncTotal,
-  asyncEffect,
-  asyncMap,
-  asyncFlatMap,
-  acquireRelease,
-  asyncInterruptible,
-  withAsyncPromise,
-  mapAsync,
-  mapTryAsync,
-  none,
-  some,
-  Cause,
-  Exit,
-  succeed,
-  fail,
-  sync,
-  map,
-  flatMap,
-  mapError,
-  catchAll,
-  orElseOptional,
-  end
-};

package/dist/chunk-ROJC3NBJ.js

@@ -1,104 +0,0 @@
-import {
-  unsafeGetCurrentRuntime
-} from "./chunk-7LVI2GIN.js";
-import {
-  asyncEffect,
-  asyncFail,
-  asyncFlatMap,
-  asyncFold,
-  asyncSucceed
-} from "./chunk-PNVFW245.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();
-    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();
-    };
-  });
-}
-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"
-  });
-}
-
-export {
-  sleep,
-  timeout,
-  retry,
-  retryN,
-  retryWithBackoff
-};

package/dist/effectRunner-3ZHAD3LE.cjs

@@ -1,8 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkIJT6RRQ5cjs = require('./chunk-IJT6RRQ5.cjs');
-require('./chunk-DJQ7OMMB.cjs');
-require('./chunk-OBGZSXTJ.cjs');
-
-
-exports.registerHttpEffect = _chunkIJT6RRQ5cjs.registerHttpEffect;

package/dist/schedule-Fque9Abz.d.ts

@@ -1,70 +0,0 @@
-import { A as Async } from './effect-CGNl5Rqp.js';
-
-type ScheduleDecision = {
-    readonly continue: boolean;
-    readonly delayMs: number;
-};
-type ScheduleJitterOptions = {
-    /** 1 means full jitter in [0, delay], 0.2 means +/-20% around delay. */
-    readonly factor?: number;
-    /** Deterministic hook for tests. Defaults to Math.random. */
-    readonly random?: () => number;
-};
-/**
- * A Schedule<I, O> takes an input I (typically the error or output of an effect)
- * and decides whether to continue and with what delay.
- */
-type Schedule<I, O> = {
-    readonly _tag: "Schedule";
-    /** Initial state */
-    readonly initial: () => any;
-    /** Given current state and input, produce a decision and next state */
-    readonly step: (state: any, input: I) => [ScheduleDecision, any, O];
-};
-/** Retry/repeat up to N times with no delay. */
-declare function recurs(n: number): Schedule<unknown, number>;
-/** Fixed delay between each retry/repeat. */
-declare function fixed(delayMs: number): Schedule<unknown, number>;
-/** Exponential backoff: delay doubles each time, capped at maxDelayMs. */
-declare function exponential(baseMs: number, maxMs?: number): Schedule<unknown, number>;
-/** Fibonacci backoff: base, base, 2*base, 3*base, 5*base, capped at maxDelayMs. */
-declare function fibonacci(baseMs: number, maxMs?: number): Schedule<unknown, number>;
-/** Exponential backoff with full jitter (random in [0, delay]). */
-declare function jittered(baseMs: number, maxMs?: number): Schedule<unknown, number>;
-/** Stop after a total elapsed time. */
-declare function elapsed(maxMs: number): Schedule<unknown, number>;
-/** Only continue while a predicate holds on the input. */
-declare function whileInput<I>(pred: (input: I) => boolean): Schedule<I, I>;
-/** Limit a schedule to N repetitions. */
-declare function take<I, O>(schedule: Schedule<I, O>, n: number): Schedule<I, O>;
-/** Transform schedule output while preserving decisions and state. */
-declare function map<I, O, O2>(schedule: Schedule<I, O>, f: (output: O) => O2): Schedule<I, O2>;
-/** Transform schedule input before it reaches the wrapped schedule. */
-declare function contramap<I0, I, O>(schedule: Schedule<I, O>, f: (input: I0) => I): Schedule<I0, O>;
-/** Add jitter to any schedule's delay. */
-declare function jitteredSchedule<I, O>(schedule: Schedule<I, O>, options?: number | ScheduleJitterOptions): Schedule<I, O>;
-declare const jitter: typeof jitteredSchedule;
-/**
- * Reset a schedule's internal state after a rolling time window.
- * Useful for retry/polling policies that should forgive old bursts.
- */
-declare function windowed<I, O>(schedule: Schedule<I, O>, windowMs: number, clock?: () => number): Schedule<I, O>;
-/** Compose two schedules: use the first, then switch to the second. */
-declare function andThen<I, O1, O2>(first: Schedule<I, O1>, second: Schedule<I, O2>): Schedule<I, O1 | O2>;
-/** Run both schedules and continue while BOTH say continue. Use max delay. */
-declare function intersect<I, O1, O2>(left: Schedule<I, O1>, right: Schedule<I, O2>): Schedule<I, [O1, O2]>;
-/** Run both schedules and continue while EITHER says continue. Use min delay. */
-declare function union<I, O1, O2>(left: Schedule<I, O1>, right: Schedule<I, O2>): Schedule<I, [O1, O2]>;
-/**
- * Retry an effect according to a schedule.
- * The schedule receives the error as input on each failure.
- */
-declare function retryWithSchedule<R, E, A, O>(effect: Async<R, E, A>, schedule: Schedule<E, O>): Async<R, E, A>;
-/**
- * Repeat an effect according to a schedule.
- * The schedule receives the success value as input on each iteration.
- * Returns the last successful value.
- */
-declare function repeatWithSchedule<R, E, A, O>(effect: Async<R, E, A>, schedule: Schedule<A, O>): Async<R, E, A>;
-
-export { type Schedule as S, type ScheduleDecision as a, andThen as b, contramap as c, exponential as d, elapsed as e, fibonacci as f, fixed as g, jittered as h, intersect as i, jitter as j, jitteredSchedule as k, repeatWithSchedule as l, map as m, retryWithSchedule as n, windowed as o, recurs as r, take as t, union as u, whileInput as w };