brass-runtime 1.16.0 → 1.16.1

package/dist/chunk-AGR5B2BC.cjs

@@ -0,0 +1,683 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkGLE2WY7Zcjs = require('./chunk-GLE2WY7Z.cjs');
+
+
+
+
+
+
+
+var _chunkMVGUEJ5Zcjs = require('./chunk-MVGUEJ5Z.cjs');
+
+// src/core/runtime/combinators.ts
+function sleep(ms) {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const clock = _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, env);
+    const id = clock.setTimeout(() => cb({ _tag: "Success", value: void 0 }), ms);
+    return () => clock.clearTimeout(id);
+  });
+}
+function timeout(effect, ms) {
+  return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
+    const clock = _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, env);
+    let done = false;
+    let timerId;
+    let fiber;
+    timerId = clock.setTimeout(() => {
+      if (done) return;
+      done = true;
+      _optionalChain([fiber, 'optionalAccess', _ => _.interrupt, 'call', _2 => _2()]);
+      cb({
+        _tag: "Failure",
+        cause: { _tag: "Fail", error: { _tag: "TimeoutError", ms } }
+      });
+    }, ms);
+    const runtime = _chunkGLE2WY7Zcjs.unsafeGetCurrentRuntime.call(void 0, );
+    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 = _nullishCoalesce(policy.shouldRetry, () => ( (() => true)));
+  const jitter2 = _nullishCoalesce(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) => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+    effect,
+    (error) => {
+      if (attempt >= policy.maxRetries) return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
+      if (!shouldRetry(error, attempt)) return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
+      if (maxElapsedMs !== void 0) {
+        const elapsed2 = clock.now() - startedAt;
+        if (elapsed2 >= maxElapsedMs) return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
+      }
+      const delay = computeDelay(attempt);
+      return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, sleep(delay), () => loop(attempt + 1, startedAt, clock));
+    },
+    (value) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value)
+  );
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+    { _tag: "Sync", thunk: (env) => {
+      const clock = _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, 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: _nullishCoalesce(opts.maxRetries, () => ( 3)),
+    baseDelayMs: _nullishCoalesce(opts.baseDelayMs, () => ( 100)),
+    maxDelayMs: _nullishCoalesce(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 : _nullishCoalesce(options.factor, () => ( 1));
+  const random = typeof options === "number" ? Math.random : _nullishCoalesce(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: _nullishCoalesce(_nullishCoalesce(enriched.attempt, () => ( _optionalChain([context, 'optionalAccess', _3 => _3.attempt]))), () => ( 0)),
+        elapsedMs: _nullishCoalesce(enriched.elapsedMs, () => ( elapsedFromContext(context))),
+        state,
+        nextState,
+        timestamp: wallClockNow()
+      });
+      return [decision, nextState, output];
+    }
+  };
+}
+function andThen(first, second) {
+  return {
+    _tag: "Schedule",
+    name: _nullishCoalesce(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: _nullishCoalesce(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: _nullishCoalesce(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 = _nullishCoalesce(options.clock, () => ( _chunkGLE2WY7Zcjs.liveClock));
+  let startedAtMs = _nullishCoalesce(options.startedAtMs, () => ( clock.now()));
+  let attempt = 0;
+  let lastDecision;
+  let state = schedule.initial(makeContext(clock, startedAtMs, attempt, _nullishCoalesce(options.name, () => ( schedule.name))));
+  return {
+    next: (input) => {
+      const currentState = state;
+      const context = makeContext(clock, startedAtMs, attempt, _nullishCoalesce(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: _nullishCoalesce(enriched.attempt, () => ( attempt)),
+        elapsedMs: _nullishCoalesce(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, _nullishCoalesce(options.name, () => ( schedule.name))));
+    },
+    snapshot: () => ({
+      name: _nullishCoalesce(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 _chunkMVGUEJ5Zcjs.Async.sync((env) => makeScheduleDriver(schedule, {
+    ...options,
+    clock: _nullishCoalesce(options.clock, () => ( _chunkGLE2WY7Zcjs.runtimeClockFromEnv.call(void 0, env)))
+  }));
+}
+function retryWithSchedule(effect, schedule, options = {}) {
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, driverFromRuntime(schedule, options), (driver) => {
+    const loop = () => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+      effect,
+      (error) => {
+        const next = driver.next(error);
+        if (!next.continue) return _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error);
+        if (next.delayMs <= 0) return loop();
+        return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, sleep(next.delayMs), () => loop());
+      },
+      (value) => _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, value)
+    );
+    return loop();
+  });
+}
+var retry2 = retryWithSchedule;
+function repeatWithSchedule(effect, schedule, options = {}) {
+  return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, driverFromRuntime(schedule, options), (driver) => {
+    const loop = (lastValue) => {
+      const next = driver.next(lastValue);
+      if (!next.continue) return _chunkMVGUEJ5Zcjs.asyncSucceed.call(void 0, lastValue);
+      if (next.delayMs <= 0) {
+        return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+          effect,
+          (error) => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error),
+          (value) => loop(value)
+        );
+      }
+      return _chunkMVGUEJ5Zcjs.asyncFlatMap.call(void 0, 
+        sleep(next.delayMs),
+        () => _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+          effect,
+          (error) => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, error),
+          (value) => loop(value)
+        )
+      );
+    };
+    return _chunkMVGUEJ5Zcjs.asyncFold.call(void 0, 
+      effect,
+      (error) => _chunkMVGUEJ5Zcjs.asyncFail.call(void 0, 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 _chunkGLE2WY7Zcjs.liveClock.now();
+}
+function nowFromContext(context) {
+  return _nullishCoalesce(_optionalChain([context, 'optionalAccess', _4 => _4.clock, 'access', _5 => _5.now, 'call', _6 => _6()]), () => ( 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: _nullishCoalesce(decision.attempt, () => ( _optionalChain([context, 'optionalAccess', _7 => _7.attempt]))),
+    elapsedMs: _nullishCoalesce(decision.elapsedMs, () => ( elapsedFromContext(context))),
+    name: _nullishCoalesce(_nullishCoalesce(decision.name, () => ( _optionalChain([context, 'optionalAccess', _8 => _8.name]))), () => ( fallbackName))
+  };
+}
+function wallClockNow() {
+  return Date.now();
+}
+function safeObserve(observer, event) {
+  try {
+    observer(event);
+  } catch (e) {
+  }
+}
+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 } : {}
+    }, _nullishCoalesce(options.emitContext, () => ( {})));
+  } catch (e2) {
+  }
+}
+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
+});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.sleep = sleep; exports.timeout = timeout; exports.retry = retry; exports.retryN = retryN; exports.retryWithBackoff = retryWithBackoff; exports.recurs = recurs; exports.forever = forever; exports.never = never; exports.once = once; exports.fixed = fixed; exports.spaced = spaced; exports.exponential = exponential; exports.linear = linear; exports.fibonacci = fibonacci; exports.jittered = jittered; exports.elapsed = elapsed; exports.whileInput = whileInput; exports.untilInput = untilInput; exports.take = take; exports.map = map; exports.contramap = contramap; exports.jitteredSchedule = jitteredSchedule; exports.jitter = jitter; exports.windowed = windowed; exports.maxDelay = maxDelay; exports.maxElapsed = maxElapsed; exports.upTo = upTo; exports.whileOutput = whileOutput; exports.untilOutput = untilOutput; exports.named = named; exports.tapDecision = tapDecision; exports.andThen = andThen; exports.intersect = intersect; exports.union = union; exports.makeScheduleDriver = makeScheduleDriver; exports.scheduleDriver = scheduleDriver; exports.runSchedule = runSchedule; exports.retryWithSchedule = retryWithSchedule; exports.retry2 = retry2; exports.repeatWithSchedule = repeatWithSchedule; exports.repeat = repeat; exports.poll = poll; exports.Schedule = Schedule;