brass-runtime 1.15.0 → 1.16.1

package/dist/chunk-6IXXWIUM.js

@@ -0,0 +1,683 @@
+import {
+  liveClock,
+  runtimeClockFromEnv,
+  unsafeGetCurrentRuntime
+} from "./chunk-FH2X7BVP.js";
+import {
+  Async,
+  asyncEffect,
+  asyncFail,
+  asyncFlatMap,
+  asyncFold,
+  asyncSucceed
+} from "./chunk-UB4B6OFY.js";
+
+// src/core/runtime/combinators.ts
+function sleep(ms) {
+  return asyncEffect((env, cb) => {
+    const clock = runtimeClockFromEnv(env);
+    const id = clock.setTimeout(() => cb({ _tag: "Success", value: void 0 }), ms);
+    return () => clock.clearTimeout(id);
+  });
+}
+function timeout(effect, ms) {
+  return asyncEffect((env, cb) => {
+    const clock = runtimeClockFromEnv(env);
+    let done = false;
+    let timerId;
+    let fiber;
+    timerId = clock.setTimeout(() => {
+      if (done) return;
+      done = true;
+      fiber?.interrupt();
+      cb({
+        _tag: "Failure",
+        cause: { _tag: "Fail", error: { _tag: "TimeoutError", ms } }
+      });
+    }, ms);
+    const runtime = unsafeGetCurrentRuntime();
+    fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      if (done) return;
+      done = true;
+      clock.clearTimeout(timerId);
+      cb(exit);
+    });
+    return () => {
+      if (done) return;
+      done = true;
+      clock.clearTimeout(timerId);
+      fiber.interrupt();
+    };
+  });
+}
+function retry(effect, policy) {
+  const shouldRetry = policy.shouldRetry ?? (() => true);
+  const jitter2 = 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 (jitter2 === "none") return capped;
+    return Math.floor(Math.random() * capped);
+  };
+  const loop = (attempt, startedAt, clock) => asyncFold(
+    effect,
+    (error) => {
+      if (attempt >= policy.maxRetries) return asyncFail(error);
+      if (!shouldRetry(error, attempt)) return asyncFail(error);
+      if (maxElapsedMs !== void 0) {
+        const elapsed2 = clock.now() - startedAt;
+        if (elapsed2 >= maxElapsedMs) return asyncFail(error);
+      }
+      const delay = computeDelay(attempt);
+      return asyncFlatMap(sleep(delay), () => loop(attempt + 1, startedAt, clock));
+    },
+    (value) => asyncSucceed(value)
+  );
+  return asyncFlatMap(
+    { _tag: "Sync", thunk: (env) => {
+      const clock = runtimeClockFromEnv(env);
+      return { clock, startedAt: clock.now() };
+    } },
+    ({ clock, startedAt }) => loop(0, startedAt, clock)
+  );
+}
+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/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 forever() {
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count) => {
+      const next = count + 1;
+      return [{ continue: true, delayMs: 0 }, next, next];
+    }
+  };
+}
+function never() {
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count) => {
+      const next = count + 1;
+      return [{ continue: false, delayMs: 0 }, next, next];
+    }
+  };
+}
+function once() {
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count) => {
+      const next = count + 1;
+      return [{ continue: count === 0, delayMs: 0 }, next, next];
+    }
+  };
+}
+function fixed(delayMs) {
+  const delay = normalizeDelay(delayMs);
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count, _input) => {
+      return [{ continue: true, delayMs: delay }, count + 1, count + 1];
+    }
+  };
+}
+var spaced = fixed;
+function exponential(baseMs, maxMs = Infinity) {
+  const base = Math.max(0, baseMs);
+  const cap = normalizeCap(maxMs);
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count, _input) => {
+      const delay = Math.min(base * Math.pow(2, count), cap);
+      return [{ continue: true, delayMs: delay }, count + 1, count + 1];
+    }
+  };
+}
+function linear(baseMs, maxMs = Infinity) {
+  const base = Math.max(0, baseMs);
+  const cap = normalizeCap(maxMs);
+  return {
+    _tag: "Schedule",
+    initial: () => 0,
+    step: (count, _input) => {
+      const next = count + 1;
+      return [{ continue: true, delayMs: Math.min(base * next, cap) }, next, next];
+    }
+  };
+}
+function fibonacci(baseMs, maxMs = Infinity) {
+  const base = Math.max(0, baseMs);
+  const cap = normalizeCap(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) {
+  const max = Math.max(0, maxMs);
+  return {
+    _tag: "Schedule",
+    initial: (context) => nowFromContext(context),
+    step: (startedAt, _input, context) => {
+      const el = nowFromContext(context) - startedAt;
+      return [{ continue: el < max, 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 untilInput(pred) {
+  return {
+    _tag: "Schedule",
+    initial: () => void 0,
+    step: (_state, input) => {
+      return [{ continue: !pred(input), delayMs: 0 }, void 0, input];
+    }
+  };
+}
+function take(schedule, n) {
+  const limit = Math.max(0, Math.floor(n));
+  return {
+    _tag: "Schedule",
+    name: schedule.name,
+    initial: (context) => ({ inner: schedule.initial(context), count: 0 }),
+    step: (state, input, context) => {
+      if (state.count >= limit) return [{ continue: false, delayMs: 0 }, state, void 0];
+      const [decision, nextInner, output] = schedule.step(state.inner, input, context);
+      const nextState = { inner: nextInner, count: state.count + 1 };
+      return [{ continue: decision.continue && state.count + 1 < limit, delayMs: decision.delayMs }, nextState, output];
+    }
+  };
+}
+function map(schedule, f) {
+  return {
+    _tag: "Schedule",
+    name: schedule.name,
+    initial: schedule.initial,
+    step: (state, input, context) => {
+      const [decision, nextState, output] = schedule.step(state, input, context);
+      return [decision, nextState, f(output)];
+    }
+  };
+}
+function contramap(schedule, f) {
+  return {
+    _tag: "Schedule",
+    name: schedule.name,
+    initial: schedule.initial,
+    step: (state, input, context) => schedule.step(state, f(input), context)
+  };
+}
+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",
+    name: schedule.name,
+    initial: schedule.initial,
+    step: (state, input, context) => {
+      const [decision, nextState, output] = schedule.step(state, input, context);
+      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) {
+  const window = Math.max(0, windowMs);
+  return {
+    _tag: "Schedule",
+    name: schedule.name,
+    initial: (context) => ({ inner: schedule.initial(context), windowStartedAt: clockNow(clock, context) }),
+    step: (state, input, context) => {
+      const now = clockNow(clock, context);
+      const shouldReset = window > 0 && now - state.windowStartedAt > window;
+      const inner = shouldReset ? schedule.initial(context) : state.inner;
+      const windowStartedAt = shouldReset ? now : state.windowStartedAt;
+      const [decision, nextInner, output] = schedule.step(inner, input, context);
+      return [decision, { inner: nextInner, windowStartedAt }, output];
+    }
+  };
+}
+function maxDelay(schedule, maxMs) {
+  const cap = Math.max(0, maxMs);
+  return {
+    _tag: "Schedule",
+    name: schedule.name,
+    initial: schedule.initial,
+    step: (state, input, context) => {
+      const [decision, nextState, output] = schedule.step(state, input, context);
+      return [{ ...decision, delayMs: Math.min(decision.delayMs, cap) }, nextState, output];
+    }
+  };
+}
+function maxElapsed(schedule, maxMs) {
+  const max = Math.max(0, maxMs);
+  return {
+    _tag: "Schedule",
+    name: schedule.name,
+    initial: (context) => ({ inner: schedule.initial(context), startedAt: nowFromContext(context) }),
+    step: (state, input, context) => {
+      const now = nowFromContext(context);
+      const elapsedMs = Math.max(0, now - state.startedAt);
+      if (elapsedMs >= max) return [{ continue: false, delayMs: 0 }, state, void 0];
+      const [decision, nextInner, output] = schedule.step(state.inner, input, context);
+      const remaining = Math.max(0, max - elapsedMs);
+      return [
+        { ...decision, continue: decision.continue && remaining > 0, delayMs: Math.min(decision.delayMs, remaining) },
+        { inner: nextInner, startedAt: state.startedAt },
+        output
+      ];
+    }
+  };
+}
+var upTo = maxElapsed;
+function whileOutput(schedule, pred) {
+  return {
+    _tag: "Schedule",
+    name: schedule.name,
+    initial: schedule.initial,
+    step: (state, input, context) => {
+      const [decision, nextState, output] = schedule.step(state, input, context);
+      return [{ ...decision, continue: decision.continue && pred(output) }, nextState, output];
+    }
+  };
+}
+function untilOutput(schedule, pred) {
+  return whileOutput(schedule, (output) => !pred(output));
+}
+function named(name, schedule) {
+  return {
+    _tag: "Schedule",
+    name,
+    initial: schedule.initial,
+    step: schedule.step
+  };
+}
+function tapDecision(schedule, tap) {
+  return {
+    _tag: "Schedule",
+    name: schedule.name,
+    initial: schedule.initial,
+    step: (state, input, context) => {
+      const [decision, nextState, output] = schedule.step(state, input, context);
+      const enriched = enrichDecision(decision, context, schedule.name);
+      safeObserve(tap, {
+        name: enriched.name,
+        input,
+        output,
+        decision: enriched,
+        attempt: enriched.attempt ?? context?.attempt ?? 0,
+        elapsedMs: enriched.elapsedMs ?? elapsedFromContext(context),
+        state,
+        nextState,
+        timestamp: wallClockNow()
+      });
+      return [decision, nextState, output];
+    }
+  };
+}
+function andThen(first, second) {
+  return {
+    _tag: "Schedule",
+    name: first.name ?? second.name,
+    initial: (context) => ({ phase: "first", inner: first.initial(context) }),
+    step: (state, input, context) => {
+      if (state.phase === "first") {
+        const [decision2, nextInner2, output2] = first.step(state.inner, input, context);
+        if (decision2.continue) {
+          return [decision2, { phase: "first", inner: nextInner2 }, output2];
+        }
+        return [{ continue: true, delayMs: decision2.delayMs }, { phase: "second", inner: second.initial(context) }, output2];
+      }
+      const [decision, nextInner, output] = second.step(state.inner, input, context);
+      return [decision, { phase: "second", inner: nextInner }, output];
+    }
+  };
+}
+function intersect(left, right) {
+  return {
+    _tag: "Schedule",
+    name: left.name ?? right.name,
+    initial: (context) => ({ left: left.initial(context), right: right.initial(context) }),
+    step: (state, input, context) => {
+      const [ld, ls, lo] = left.step(state.left, input, context);
+      const [rd, rs, ro] = right.step(state.right, input, context);
+      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",
+    name: left.name ?? right.name,
+    initial: (context) => ({ left: left.initial(context), right: right.initial(context) }),
+    step: (state, input, context) => {
+      const [ld, ls, lo] = left.step(state.left, input, context);
+      const [rd, rs, ro] = right.step(state.right, input, context);
+      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 makeScheduleDriver(schedule, options = {}) {
+  const clock = options.clock ?? liveClock;
+  let startedAtMs = options.startedAtMs ?? clock.now();
+  let attempt = 0;
+  let lastDecision;
+  let state = schedule.initial(makeContext(clock, startedAtMs, attempt, options.name ?? schedule.name));
+  return {
+    next: (input) => {
+      const currentState = state;
+      const context = makeContext(clock, startedAtMs, attempt, options.name ?? schedule.name);
+      const [decision, nextState, output] = schedule.step(currentState, input, context);
+      const enriched = enrichDecision(decision, context, schedule.name);
+      state = nextState;
+      const result = {
+        continue: enriched.continue,
+        delayMs: enriched.delayMs,
+        output,
+        decision: enriched,
+        attempt: enriched.attempt ?? attempt,
+        elapsedMs: enriched.elapsedMs ?? elapsedFromContext(context),
+        state: nextState
+      };
+      lastDecision = result;
+      const event = {
+        name: enriched.name,
+        input,
+        output,
+        decision: enriched,
+        attempt: result.attempt,
+        elapsedMs: result.elapsedMs,
+        state: currentState,
+        nextState,
+        timestamp: wallClockNow()
+      };
+      observeDriverDecision(event, options);
+      attempt++;
+      return result;
+    },
+    reset: () => {
+      startedAtMs = clock.now();
+      attempt = 0;
+      lastDecision = void 0;
+      state = schedule.initial(makeContext(clock, startedAtMs, attempt, options.name ?? schedule.name));
+    },
+    snapshot: () => ({
+      name: options.name ?? schedule.name,
+      attempt,
+      elapsedMs: Math.max(0, clock.now() - startedAtMs),
+      state,
+      last: lastDecision
+    }),
+    state: () => state,
+    last: () => lastDecision
+  };
+}
+var scheduleDriver = makeScheduleDriver;
+function runSchedule(schedule, inputs, options = {}) {
+  const driver = makeScheduleDriver(schedule, options);
+  const decisions = [];
+  for (const input of inputs) {
+    const next = driver.next(input);
+    decisions.push(next);
+    if (!next.continue) break;
+  }
+  return decisions;
+}
+function driverFromRuntime(schedule, options = {}) {
+  return Async.sync((env) => makeScheduleDriver(schedule, {
+    ...options,
+    clock: options.clock ?? runtimeClockFromEnv(env)
+  }));
+}
+function retryWithSchedule(effect, schedule, options = {}) {
+  return asyncFlatMap(driverFromRuntime(schedule, options), (driver) => {
+    const loop = () => asyncFold(
+      effect,
+      (error) => {
+        const next = driver.next(error);
+        if (!next.continue) return asyncFail(error);
+        if (next.delayMs <= 0) return loop();
+        return asyncFlatMap(sleep(next.delayMs), () => loop());
+      },
+      (value) => asyncSucceed(value)
+    );
+    return loop();
+  });
+}
+var retry2 = retryWithSchedule;
+function repeatWithSchedule(effect, schedule, options = {}) {
+  return asyncFlatMap(driverFromRuntime(schedule, options), (driver) => {
+    const loop = (lastValue) => {
+      const next = driver.next(lastValue);
+      if (!next.continue) return asyncSucceed(lastValue);
+      if (next.delayMs <= 0) {
+        return asyncFold(
+          effect,
+          (error) => asyncFail(error),
+          (value) => loop(value)
+        );
+      }
+      return asyncFlatMap(
+        sleep(next.delayMs),
+        () => asyncFold(
+          effect,
+          (error) => asyncFail(error),
+          (value) => loop(value)
+        )
+      );
+    };
+    return asyncFold(
+      effect,
+      (error) => asyncFail(error),
+      (value) => loop(value)
+    );
+  });
+}
+var repeat = repeatWithSchedule;
+var poll = repeatWithSchedule;
+function normalizeDelay(ms) {
+  if (!Number.isFinite(ms)) return 0;
+  return Math.max(0, Math.floor(ms));
+}
+function normalizeCap(ms) {
+  if (ms === Infinity) return Infinity;
+  return normalizeDelay(ms);
+}
+function defaultClock() {
+  return liveClock.now();
+}
+function nowFromContext(context) {
+  return context?.clock.now() ?? defaultClock();
+}
+function clockNow(clock, context) {
+  return clock ? clock() : nowFromContext(context);
+}
+function elapsedFromContext(context) {
+  if (!context) return 0;
+  return Math.max(0, context.clock.now() - context.startedAtMs);
+}
+function makeContext(clock, startedAtMs, attempt, name) {
+  return { clock, startedAtMs, attempt, name };
+}
+function enrichDecision(decision, context, fallbackName) {
+  const delayMs = normalizeDelay(decision.delayMs);
+  return {
+    ...decision,
+    continue: decision.continue,
+    delayMs,
+    attempt: decision.attempt ?? context?.attempt,
+    elapsedMs: decision.elapsedMs ?? elapsedFromContext(context),
+    name: decision.name ?? context?.name ?? fallbackName
+  };
+}
+function wallClockNow() {
+  return Date.now();
+}
+function safeObserve(observer, event) {
+  try {
+    observer(event);
+  } catch {
+  }
+}
+function observeDriverDecision(event, options) {
+  if (options.onDecision) safeObserve(options.onDecision, event);
+  if (!options.hooks) return;
+  try {
+    options.hooks.emit({
+      type: "schedule.decision",
+      name: event.name,
+      attempt: event.attempt,
+      elapsedMs: event.elapsedMs,
+      delayMs: event.decision.delayMs,
+      continue: event.decision.continue,
+      reason: event.decision.reason,
+      ...options.captureInput ? { input: event.input } : {},
+      ...options.captureOutput ? { output: event.output } : {}
+    }, options.emitContext ?? {});
+  } catch {
+  }
+}
+var Schedule = Object.freeze({
+  driver: makeScheduleDriver,
+  run: runSchedule,
+  recurs,
+  forever,
+  never,
+  once,
+  fixed,
+  spaced,
+  linear,
+  exponential,
+  fibonacci,
+  jittered,
+  jitteredSchedule,
+  jitter,
+  elapsed,
+  whileInput,
+  untilInput,
+  whileOutput,
+  untilOutput,
+  take,
+  map,
+  contramap,
+  maxDelay,
+  maxElapsed,
+  upTo,
+  windowed,
+  named,
+  tapDecision,
+  andThen,
+  intersect,
+  union,
+  retry: retryWithSchedule,
+  repeat: repeatWithSchedule,
+  poll: repeatWithSchedule
+});
+
+export {
+  sleep,
+  timeout,
+  retry,
+  retryN,
+  retryWithBackoff,
+  recurs,
+  forever,
+  never,
+  once,
+  fixed,
+  spaced,
+  exponential,
+  linear,
+  fibonacci,
+  jittered,
+  elapsed,
+  whileInput,
+  untilInput,
+  take,
+  map,
+  contramap,
+  jitteredSchedule,
+  jitter,
+  windowed,
+  maxDelay,
+  maxElapsed,
+  upTo,
+  whileOutput,
+  untilOutput,
+  named,
+  tapDecision,
+  andThen,
+  intersect,
+  union,
+  makeScheduleDriver,
+  scheduleDriver,
+  runSchedule,
+  retryWithSchedule,
+  retry2,
+  repeatWithSchedule,
+  repeat,
+  poll,
+  Schedule
+};