effect 2.0.0-next.5 → 2.0.0-next.50

package/internal/core-effect.esm.js

@@ -0,0 +1,884 @@
+import { append, toReadonlyArray, fromIterable as fromIterable$2, isNonEmpty, headNonEmpty, tailNonEmpty } from '../Chunk/dist/effect-Chunk.esm.js';
+import { clockWith as clockWith$1, sleep as sleep$1, currentTimeMillis, currentTimeNanos } from '../Clock/dist/effect-Clock.esm.js';
+import { add, unsafeGet, getOption, empty as empty$1 } from '../Context/dist/effect-Context.esm.js';
+import { nanos } from '../Duration/dist/effect-Duration.esm.js';
+import { right, left } from '../Either/dist/effect-Either.esm.js';
+import { none as none$1 } from '../FiberId/dist/effect-FiberId.esm.js';
+import { setAll, joinAs } from '../FiberRefs/dist/effect-FiberRefs.esm.js';
+import { dual, identity, constVoid, constTrue, constFalse, pipe } from '../Function/dist/effect-Function.esm.js';
+import { set, forEach } from '../HashMap/dist/effect-HashMap.esm.js';
+import { fromIterable as fromIterable$1, union, size } from '../HashSet/dist/effect-HashSet.esm.js';
+import { fail, find, isDieType, empty, failures, failureOrCause, keepDefects, flatten, NoSuchElementException, isNoSuchElementException, interruptors, IllegalArgumentException, isCause } from './cause.esm.js';
+import { fiberRefLocallyWith, currentLogAnnotations, isEffect, map, mapError, asyncEither, unit, sync, makeEffectError, catchAll, fail as fail$1, catchAllCause, unified, failCause, matchCauseEffect, succeed, catchIf, matchCause, zipRight, withFiberRuntime, flatMap, suspend, context, orElse, yieldNow, dieSync, dieMessage, failSync, flip, matchEffect, currentLogSpan, fiberRefGet, failCauseSync, intoDeferred, deferredAwait, as, zip, updateRuntimeFlags, deferredMake, asUnit, whenEffect, async, contextWithEffect, provideContext, currentMetricLabels, mapInputContext, currentTracerSpanAnnotations, currentTracerSpanLinks, acquireUseRelease, currentInterruptedCause, interrupt, runtimeFlags, fiberRefGetWith, currentTracerTimingEnabled, exitSucceed, exitDie } from './core.esm.js';
+import { randomWith } from './defaultServices.esm.js';
+import { diff, patch } from './fiberRefs/patch.esm.js';
+import { make as make$2 } from './metric/label.esm.js';
+import { diff as diff$1 } from './runtimeFlags.esm.js';
+import { SingleShotGen } from './singleShotGen.esm.js';
+import { spanTag } from './tracer.esm.js';
+import { prepend, empty as empty$2 } from '../List/dist/effect-List.esm.js';
+import { Trace, Debug, Info, Warning, Error, Fatal } from '../LogLevel/dist/effect-LogLevel.esm.js';
+import { make } from '../LogSpan/dist/effect-LogSpan.esm.js';
+import { some, none as none$2, match as match$1, fromNullable as fromNullable$1 } from '../Option/dist/effect-Option.esm.js';
+import { isTagged, isObject } from '../Predicate/dist/effect-Predicate.esm.js';
+import { fromIterable, reduce as reduce$1 } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
+import { make as make$1, getAndSet, get } from '../Ref/dist/effect-Ref.esm.js';
+import { tracerWith as tracerWith$1 } from '../Tracer/dist/effect-Tracer.esm.js';
+
+/* @internal */
+const annotateLogs = /*#__PURE__*/dual(args => isEffect(args[0]), function () {
+  const args = arguments;
+  return fiberRefLocallyWith(args[0], currentLogAnnotations, typeof args[1] === "string" ? set(args[1], args[2]) : annotations => Object.entries(args[1]).reduce((acc, [key, value]) => set(acc, key, value), annotations));
+});
+
+/* @internal */
+const asSome = self => map(self, some);
+
+/* @internal */
+const asSomeError = self => mapError(self, some);
+
+/* @internal */
+const asyncOption = (register, blockingOn = none$1) => asyncEither(cb => {
+  const option = register(cb);
+  switch (option._tag) {
+    case "None":
+      {
+        return left(unit);
+      }
+    case "Some":
+      {
+        return right(option.value);
+      }
+  }
+}, blockingOn);
+
+/* @internal */
+const try_ = arg => {
+  let evaluate;
+  let onFailure = undefined;
+  if (typeof arg === "function") {
+    evaluate = arg;
+  } else {
+    evaluate = arg.try;
+    onFailure = arg.catch;
+  }
+  return sync(() => {
+    try {
+      return evaluate();
+    } catch (error) {
+      throw makeEffectError(fail(onFailure ? onFailure(error) : error));
+    }
+  });
+};
+
+/* @internal */
+const _catch = /*#__PURE__*/dual(
+// @ts-expect-error
+3, (self, tag, options) => catchAll(self, e => {
+  if (typeof e === "object" && e != null && tag in e && e[tag] === options.failure) {
+    return options.onFailure(e);
+  }
+  return fail$1(e);
+}));
+
+/* @internal */
+const catchAllDefect = /*#__PURE__*/dual(2, (self, f) => catchAllCause(self, unified(cause => {
+  const option = find(cause, _ => isDieType(_) ? some(_) : none$2());
+  switch (option._tag) {
+    case "None":
+      {
+        return failCause(cause);
+      }
+    case "Some":
+      {
+        return f(option.value.defect);
+      }
+  }
+})));
+
+/* @internal */
+const catchSomeCause = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect(self, {
+  onFailure: cause => {
+    const option = f(cause);
+    switch (option._tag) {
+      case "None":
+        {
+          return failCause(cause);
+        }
+      case "Some":
+        {
+          return option.value;
+        }
+    }
+  },
+  onSuccess: succeed
+}));
+
+/* @internal */
+const catchSomeDefect = /*#__PURE__*/dual(2, (self, pf) => catchAllCause(self, unified(cause => {
+  const option = find(cause, _ => isDieType(_) ? some(_) : none$2());
+  switch (option._tag) {
+    case "None":
+      {
+        return failCause(cause);
+      }
+    case "Some":
+      {
+        const optionEffect = pf(option.value.defect);
+        return optionEffect._tag === "Some" ? optionEffect.value : failCause(cause);
+      }
+  }
+})));
+
+/* @internal */
+const catchTag = /*#__PURE__*/dual(3, (self, k, f) => catchIf(self, isTagged(k), f));
+
+/** @internal */
+const catchTags = /*#__PURE__*/dual(2, (self, cases) => {
+  let keys;
+  return catchIf(self, e => {
+    keys ??= Object.keys(cases);
+    return isObject(e) && "_tag" in e && keys.includes(e["_tag"]);
+  }, e => cases[e["_tag"]](e));
+});
+
+/* @internal */
+const cause = self => matchCause(self, {
+  onFailure: identity,
+  onSuccess: () => empty
+});
+
+/* @internal */
+const clockWith = clockWith$1;
+
+/* @internal */
+const clock = /*#__PURE__*/clockWith(succeed);
+
+/* @internal */
+const delay = /*#__PURE__*/dual(2, (self, duration) => zipRight(sleep$1(duration), self));
+
+/* @internal */
+const descriptorWith = f => withFiberRuntime((state, status) => f({
+  id: state.id(),
+  status,
+  interruptors: interruptors(state.getFiberRef(currentInterruptedCause))
+}));
+
+/* @internal */
+const allowInterrupt = /*#__PURE__*/descriptorWith(descriptor => size(descriptor.interruptors) > 0 ? interrupt : unit);
+
+/* @internal */
+const descriptor = /*#__PURE__*/descriptorWith(succeed);
+
+/* @internal */
+const diffFiberRefs = self => summarized(self, fiberRefs, diff);
+
+/* @internal */
+const diffFiberRefsAndRuntimeFlags = self => summarized(self, zip(fiberRefs, runtimeFlags), ([refs, flags], [refsNew, flagsNew]) => [diff(refs, refsNew), diff$1(flags, flagsNew)]);
+
+/* @internal */
+const Do = /*#__PURE__*/succeed({});
+
+/* @internal */
+const bind = /*#__PURE__*/dual(3, (self, tag, f) => flatMap(self, k => map(f(k), a => ({
+  ...k,
+  [tag]: a
+}))));
+
+/* @internal */
+const bindTo = /*#__PURE__*/dual(2, (self, tag) => map(self, a => ({
+  [tag]: a
+})));
+
+/* @internal */
+const bindValue = /*#__PURE__*/dual(3, (self, tag, f) => map(self, k => ({
+  ...k,
+  [tag]: f(k)
+})));
+
+/* @internal */
+const dropUntil = /*#__PURE__*/dual(2, (elements, predicate) => suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const builder = [];
+  let next;
+  let dropping = succeed(false);
+  let i = 0;
+  while ((next = iterator.next()) && !next.done) {
+    const a = next.value;
+    const index = i++;
+    dropping = flatMap(dropping, bool => {
+      if (bool) {
+        builder.push(a);
+        return succeed(true);
+      }
+      return predicate(a, index);
+    });
+  }
+  return map(dropping, () => builder);
+}));
+
+/* @internal */
+const dropWhile = /*#__PURE__*/dual(2, (elements, f) => suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const builder = [];
+  let next;
+  let dropping = succeed(true);
+  let i = 0;
+  while ((next = iterator.next()) && !next.done) {
+    const a = next.value;
+    const index = i++;
+    dropping = flatMap(dropping, d => map(d ? f(a, index) : succeed(false), b => {
+      if (!b) {
+        builder.push(a);
+      }
+      return b;
+    }));
+  }
+  return map(dropping, () => builder);
+}));
+
+/* @internal */
+const contextWith = f => map(context(), f);
+
+/* @internal */
+const eventually = self => orElse(self, () => flatMap(yieldNow(), () => eventually(self)));
+
+/* @internal */
+const filterOrDie = /*#__PURE__*/dual(3, (self, filter, orDieWith) => filterOrElse(self, filter, a => dieSync(() => orDieWith(a))));
+
+/* @internal */
+const filterOrDieMessage = /*#__PURE__*/dual(3, (self, filter, message) => filterOrElse(self, filter, () => dieMessage(message)));
+
+/* @internal */
+const filterOrElse = /*#__PURE__*/dual(3, (self, filter, orElse) => flatMap(self, a => filter(a) ? succeed(a) : orElse(a)));
+
+/* @internal */
+const filterOrFail = /*#__PURE__*/dual(3, (self, filter, orFailWith) => filterOrElse(self, filter, a => failSync(() => orFailWith(a))));
+
+/* @internal */
+const findFirst = /*#__PURE__*/dual(2, (elements, f) => suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const next = iterator.next();
+  if (!next.done) {
+    return findLoop(iterator, 0, f, next.value);
+  }
+  return succeed(none$2());
+}));
+const findLoop = (iterator, index, f, value) => flatMap(f(value, index), result => {
+  if (result) {
+    return succeed(some(value));
+  }
+  const next = iterator.next();
+  if (!next.done) {
+    return findLoop(iterator, index + 1, f, next.value);
+  }
+  return succeed(none$2());
+});
+
+/* @internal */
+const firstSuccessOf = effects => suspend(() => {
+  const list = fromIterable$2(effects);
+  if (!isNonEmpty(list)) {
+    return dieSync(() => IllegalArgumentException(`Received an empty collection of effects`));
+  }
+  return pipe(tailNonEmpty(list), reduce$1(headNonEmpty(list), (left, right) => orElse(left, () => right)));
+});
+
+/* @internal */
+const flipWith = /*#__PURE__*/dual(2, (self, f) => flip(f(flip(self))));
+
+/* @internal */
+const match = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => matchEffect(self, {
+  onFailure: e => succeed(onFailure(e)),
+  onSuccess: a => succeed(onSuccess(a))
+}));
+
+/* @internal */
+const every = /*#__PURE__*/dual(2, (elements, f) => suspend(() => forAllLoop(elements[Symbol.iterator](), 0, f)));
+const forAllLoop = (iterator, index, f) => {
+  const next = iterator.next();
+  return next.done ? succeed(true) : flatMap(f(next.value, index), b => b ? forAllLoop(iterator, index + 1, f) : succeed(b));
+};
+
+/* @internal */
+const forever = self => {
+  const loop = flatMap(flatMap(self, () => yieldNow()), () => loop);
+  return loop;
+};
+
+/** @internal */
+class EffectGen {
+  constructor(value) {
+    this.value = value;
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen(this);
+  }
+}
+const adapter = function () {
+  let x = arguments[0];
+  for (let i = 1; i < arguments.length; i++) {
+    x = arguments[i](x);
+  }
+  return new EffectGen(x);
+};
+
+/**
+ * Inspired by https://github.com/tusharmath/qio/pull/22 (revised)
+  @internal */
+const gen = function () {
+  let f;
+  if (arguments.length === 1) {
+    f = arguments[0];
+  } else {
+    f = arguments[1].bind(arguments[0]);
+  }
+  return suspend(() => {
+    const iterator = f(adapter);
+    const state = iterator.next();
+    const run = state => state.done ? succeed(state.value) : pipe(state.value.value, flatMap(val => run(iterator.next(val))));
+    return run(state);
+  });
+};
+
+/* @internal */
+const fiberRefs = /*#__PURE__*/withFiberRuntime(state => succeed(state.getFiberRefs()));
+
+/* @internal */
+const head = self => matchEffect(self, {
+  onFailure: e => fail$1(some(e)),
+  onSuccess: as => {
+    const iterator = as[Symbol.iterator]();
+    const next = iterator.next();
+    if (next.done) {
+      return fail$1(none$2());
+    }
+    return succeed(next.value);
+  }
+});
+
+/* @internal */
+const ignore = self => match(self, {
+  onFailure: constVoid,
+  onSuccess: constVoid
+});
+
+/* @internal */
+const ignoreLogged = self => matchCauseEffect(self, {
+  onFailure: cause => logDebug(cause, "An error was silently ignored because it is not anticipated to be useful"),
+  onSuccess: () => unit
+});
+
+/* @internal */
+const inheritFiberRefs = childFiberRefs => updateFiberRefs((parentFiberId, parentFiberRefs) => joinAs(parentFiberRefs, parentFiberId, childFiberRefs));
+
+/* @internal */
+const isFailure = self => match(self, {
+  onFailure: constTrue,
+  onSuccess: constFalse
+});
+
+/* @internal */
+const isSuccess = self => match(self, {
+  onFailure: constFalse,
+  onSuccess: constTrue
+});
+
+/* @internal */
+const iterate = (initial, options) => suspend(() => {
+  if (options.while(initial)) {
+    return flatMap(options.body(initial), z2 => iterate(z2, options));
+  }
+  return succeed(initial);
+});
+const logWithLevel = level => (messageOrCause, supplementary) => {
+  const levelOption = fromNullable$1(level);
+  let message;
+  let cause;
+  if (isCause(messageOrCause)) {
+    cause = messageOrCause;
+    message = supplementary ?? "";
+  } else {
+    message = messageOrCause;
+    cause = supplementary ?? empty;
+  }
+  return withFiberRuntime(fiberState => {
+    fiberState.log(message, cause, levelOption);
+    return unit;
+  });
+};
+
+/** @internal */
+const log = /*#__PURE__*/logWithLevel();
+
+/** @internal */
+const logTrace = /*#__PURE__*/logWithLevel(Trace);
+
+/** @internal */
+const logDebug = /*#__PURE__*/logWithLevel(Debug);
+
+/** @internal */
+const logInfo = /*#__PURE__*/logWithLevel(Info);
+
+/** @internal */
+const logWarning = /*#__PURE__*/logWithLevel(Warning);
+
+/** @internal */
+const logError = /*#__PURE__*/logWithLevel(Error);
+
+/** @internal */
+const logFatal = /*#__PURE__*/logWithLevel(Fatal);
+
+/* @internal */
+const withLogSpan = /*#__PURE__*/dual(2, (effect, label) => flatMap(currentTimeMillis, now => fiberRefLocallyWith(effect, currentLogSpan, prepend(make(label, now)))));
+
+/* @internal */
+const logAnnotations = /*#__PURE__*/fiberRefGet(currentLogAnnotations);
+
+/* @internal */
+// @ts-expect-error
+const loop = (initial, options) => options.discard ? loopDiscard(initial, options.while, options.step, options.body) : map(loopInternal(initial, options.while, options.step, options.body), x => Array.from(x));
+const loopInternal = (initial, cont, inc, body) => suspend(() => cont(initial) ? flatMap(body(initial), a => map(loopInternal(inc(initial), cont, inc, body), prepend(a))) : sync(() => empty$2()));
+const loopDiscard = (initial, cont, inc, body) => suspend(() => cont(initial) ? flatMap(body(initial), () => loopDiscard(inc(initial), cont, inc, body)) : unit);
+
+/* @internal */
+const mapAccum = /*#__PURE__*/dual(3, (elements, zero, f) => suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const builder = [];
+  let result = succeed(zero);
+  let next;
+  let i = 0;
+  while (!(next = iterator.next()).done) {
+    const index = i++;
+    result = flatMap(result, state => map(f(state, next.value, index), ([z, b]) => {
+      builder.push(b);
+      return z;
+    }));
+  }
+  return map(result, z => [z, builder]);
+}));
+
+/* @internal */
+const mapErrorCause = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect(self, {
+  onFailure: c => failCauseSync(() => f(c)),
+  onSuccess: succeed
+}));
+
+/* @internal */
+const memoize = self => pipe(deferredMake(), flatMap(deferred => pipe(diffFiberRefsAndRuntimeFlags(self), intoDeferred(deferred), once, map(complete => zipRight(complete, pipe(deferredAwait(deferred), flatMap(([patch, a]) => as(zip(patchFiberRefs(patch[0]), updateRuntimeFlags(patch[1])), a))))))));
+
+/* @internal */
+const merge = self => matchEffect(self, {
+  onFailure: e => succeed(e),
+  onSuccess: succeed
+});
+
+/* @internal */
+const negate = self => map(self, b => !b);
+
+/* @internal */
+const none = self => matchEffect(self, {
+  onFailure: e => fail$1(some(e)),
+  onSuccess: option => {
+    switch (option._tag) {
+      case "None":
+        {
+          return unit;
+        }
+      case "Some":
+        {
+          return fail$1(none$2());
+        }
+    }
+  }
+});
+
+/* @internal */
+const once = self => map(make$1(true), ref => asUnit(whenEffect(self, getAndSet(ref, false))));
+
+/* @internal */
+const option = self => matchEffect(self, {
+  onFailure: () => succeed(none$2()),
+  onSuccess: a => succeed(some(a))
+});
+
+/* @internal */
+const orElseFail = /*#__PURE__*/dual(2, (self, evaluate) => orElse(self, () => failSync(evaluate)));
+
+/* @internal */
+const orElseSucceed = /*#__PURE__*/dual(2, (self, evaluate) => orElse(self, () => sync(evaluate)));
+
+/* @internal */
+const parallelErrors = self => matchCauseEffect(self, {
+  onFailure: cause => {
+    const errors = Array.from(failures(cause));
+    return errors.length === 0 ? failCause(cause) : fail$1(errors);
+  },
+  onSuccess: succeed
+});
+
+/* @internal */
+const patchFiberRefs = patch$1 => updateFiberRefs((fiberId, fiberRefs) => pipe(patch$1, patch(fiberId, fiberRefs)));
+
+/* @internal */
+const promise = evaluate => evaluate.length >= 1 ? async((resolve, signal) => {
+  evaluate(signal).then(a => resolve(exitSucceed(a))).catch(e => resolve(exitDie(e)));
+}) : async(resolve => {
+  evaluate().then(a => resolve(exitSucceed(a))).catch(e => resolve(exitDie(e)));
+});
+
+/* @internal */
+const provideService = /*#__PURE__*/dual(3, (self, tag, service) => contextWithEffect(env => provideContext(self, add(env, tag, service))));
+
+/* @internal */
+const provideServiceEffect = /*#__PURE__*/dual(3, (self, tag, effect) => contextWithEffect(env => flatMap(effect, service => provideContext(self, pipe(env, add(tag, service))))));
+
+/* @internal */
+const random = /*#__PURE__*/randomWith(succeed);
+
+/* @internal */
+const reduce = /*#__PURE__*/dual(3, (elements, zero, f) => fromIterable(elements).reduce((acc, el, i) => flatMap(acc, a => f(a, el, i)), succeed(zero)));
+
+/* @internal */
+const reduceRight = /*#__PURE__*/dual(3, (elements, zero, f) => fromIterable(elements).reduceRight((acc, el, i) => flatMap(acc, a => f(el, a, i)), succeed(zero)));
+
+/* @internal */
+const reduceWhile = /*#__PURE__*/dual(3, (elements, zero, options) => flatMap(sync(() => elements[Symbol.iterator]()), iterator => reduceWhileLoop(iterator, 0, zero, options.while, options.body)));
+const reduceWhileLoop = (iterator, index, state, predicate, f) => {
+  const next = iterator.next();
+  if (!next.done && predicate(state)) {
+    return flatMap(f(state, next.value, index), nextState => reduceWhileLoop(iterator, index + 1, nextState, predicate, f));
+  }
+  return succeed(state);
+};
+
+/* @internal */
+const repeatN = /*#__PURE__*/dual(2, (self, n) => suspend(() => repeatNLoop(self, n)));
+
+/* @internal */
+const repeatNLoop = (self, n) => flatMap(self, a => n <= 0 ? succeed(a) : zipRight(yieldNow(), repeatNLoop(self, n - 1)));
+
+/* @internal */
+const sandbox = self => matchCauseEffect(self, {
+  onFailure: fail$1,
+  onSuccess: succeed
+});
+
+/* @internal */
+const setFiberRefs = fiberRefs => suspend(() => setAll(fiberRefs));
+
+/* @internal */
+const sleep = sleep$1;
+
+/* @internal */
+const succeedNone = /*#__PURE__*/succeed( /*#__PURE__*/none$2());
+
+/* @internal */
+const succeedSome = value => succeed(some(value));
+
+/* @internal */
+const summarized = /*#__PURE__*/dual(3, (self, summary, f) => flatMap(summary, start => flatMap(self, value => map(summary, end => [f(start, end), value]))));
+
+/* @internal */
+const tagMetrics = /*#__PURE__*/dual(args => isEffect(args[0]), function () {
+  return labelMetrics(arguments[0], typeof arguments[1] === "string" ? [make$2(arguments[1], arguments[2])] : Object.entries(arguments[1]).map(([k, v]) => make$2(k, v)));
+});
+
+/* @internal */
+const labelMetrics = /*#__PURE__*/dual(2, (self, labels) => labelMetricsSet(self, fromIterable$1(labels)));
+
+/* @internal */
+const labelMetricsSet = /*#__PURE__*/dual(2, (self, labels) => fiberRefLocallyWith(currentMetricLabels, set => pipe(set, union(labels)))(self));
+
+/* @internal */
+const takeUntil = /*#__PURE__*/dual(2, (elements, predicate) => suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const builder = [];
+  let next;
+  let effect = succeed(false);
+  let i = 0;
+  while ((next = iterator.next()) && !next.done) {
+    const a = next.value;
+    const index = i++;
+    effect = flatMap(effect, bool => {
+      if (bool) {
+        return succeed(true);
+      }
+      builder.push(a);
+      return predicate(a, index);
+    });
+  }
+  return map(effect, () => builder);
+}));
+
+/* @internal */
+const takeWhile = /*#__PURE__*/dual(2, (elements, predicate) => suspend(() => {
+  const iterator = elements[Symbol.iterator]();
+  const builder = [];
+  let next;
+  let taking = succeed(true);
+  let i = 0;
+  while ((next = iterator.next()) && !next.done) {
+    const a = next.value;
+    const index = i++;
+    taking = flatMap(taking, taking => pipe(taking ? predicate(a, index) : succeed(false), map(bool => {
+      if (bool) {
+        builder.push(a);
+      }
+      return bool;
+    })));
+  }
+  return map(taking, () => builder);
+}));
+
+/* @internal */
+const tapBoth = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => matchCauseEffect(self, {
+  onFailure: cause => {
+    const either = failureOrCause(cause);
+    switch (either._tag) {
+      case "Left":
+        {
+          return zipRight(onFailure(either.left), failCause(cause));
+        }
+      case "Right":
+        {
+          return failCause(cause);
+        }
+    }
+  },
+  onSuccess: a => as(onSuccess(a), a)
+}));
+
+/* @internal */
+const tapDefect = /*#__PURE__*/dual(2, (self, f) => catchAllCause(self, cause => match$1(keepDefects(cause), {
+  onNone: () => failCause(cause),
+  onSome: a => zipRight(f(a), failCause(cause))
+})));
+
+/* @internal */
+const tapError = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect(self, {
+  onFailure: cause => {
+    const either = failureOrCause(cause);
+    switch (either._tag) {
+      case "Left":
+        {
+          return zipRight(f(either.left), failCause(cause));
+        }
+      case "Right":
+        {
+          return failCause(cause);
+        }
+    }
+  },
+  onSuccess: succeed
+}));
+
+/* @internal */
+const tapErrorTag = /*#__PURE__*/dual(3, (self, k, f) => tapError(self, e => {
+  if (isTagged(e, k)) {
+    return f(e);
+  }
+  return unit;
+}));
+
+/* @internal */
+const tapErrorCause = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect(self, {
+  onFailure: cause => zipRight(f(cause), failCause(cause)),
+  onSuccess: succeed
+}));
+
+/* @internal */
+const timed = self => timedWith(self, currentTimeNanos);
+
+/* @internal */
+const timedWith = /*#__PURE__*/dual(2, (self, nanos$1) => summarized(self, nanos$1, (start, end) => nanos(end - start)));
+
+/* @internal */
+const tracerWith = tracerWith$1;
+
+/** @internal */
+const tracer = /*#__PURE__*/tracerWith(succeed);
+
+/* @internal */
+const tryPromise = arg => {
+  let evaluate;
+  let catcher = undefined;
+  if (typeof arg === "function") {
+    evaluate = arg;
+  } else {
+    evaluate = arg.try;
+    catcher = arg.catch;
+  }
+  if (evaluate.length >= 1) {
+    return suspend(() => {
+      const controller = new AbortController();
+      return flatMap(try_(() => evaluate(controller.signal)), promise => async(resolve => {
+        promise.then(a => resolve(exitSucceed(a))).catch(e => resolve(fail$1(catcher ? catcher(e) : e)));
+        return sync(() => controller.abort());
+      }));
+    });
+  }
+  return flatMap(try_(arg), promise => async(resolve => {
+    promise.then(a => resolve(exitSucceed(a))).catch(e => resolve(fail$1(catcher ? catcher(e) : e)));
+  }));
+};
+
+/* @internal */
+const tryMap = /*#__PURE__*/dual(2, (self, options) => flatMap(self, a => try_({
+  try: () => options.try(a),
+  catch: options.catch
+})));
+
+/* @internal */
+const tryMapPromise = /*#__PURE__*/dual(2, (self, options) => flatMap(self, a => tryPromise({
+  try: options.try.length >= 1 ? signal => options.try(a, signal) : () => options.try(a),
+  catch: options.catch
+})));
+
+/* @internal */
+const unless = /*#__PURE__*/dual(2, (self, predicate) => suspend(() => predicate() ? succeedNone : asSome(self)));
+
+/* @internal */
+const unlessEffect = /*#__PURE__*/dual(2, (self, predicate) => flatMap(predicate, b => b ? succeedNone : asSome(self)));
+
+/* @internal */
+const unsandbox = self => mapErrorCause(self, flatten);
+
+/* @internal */
+const updateFiberRefs = f => withFiberRuntime(state => {
+  state.setFiberRefs(f(state.id(), state.getFiberRefs()));
+  return unit;
+});
+
+/* @internal */
+const updateService = /*#__PURE__*/dual(3, (self, tag, f) => mapInputContext(self, context => add(context, tag, f(unsafeGet(context, tag)))));
+
+/* @internal */
+const when = /*#__PURE__*/dual(2, (self, predicate) => suspend(() => predicate() ? map(self, some) : succeed(none$2())));
+
+/* @internal */
+const whenFiberRef = /*#__PURE__*/dual(3, (self, fiberRef, predicate) => flatMap(fiberRefGet(fiberRef), s => predicate(s) ? map(self, a => [s, some(a)]) : succeed([s, none$2()])));
+
+/* @internal */
+const whenRef = /*#__PURE__*/dual(3, (self, ref, predicate) => flatMap(get(ref), s => predicate(s) ? map(self, a => [s, some(a)]) : succeed([s, none$2()])));
+
+/* @internal */
+const withMetric = /*#__PURE__*/dual(2, (self, metric) => metric(self));
+
+/** @internal */
+const serviceFunctionEffect = (service, f) => (...args) => flatMap(service, a => f(a)(...args));
+
+/** @internal */
+const serviceFunction = (service, f) => (...args) => map(service, a => f(a)(...args));
+
+/** @internal */
+const serviceFunctions = tag => new Proxy({}, {
+  get(_target, prop, _receiver) {
+    return (...args) => flatMap(tag, s => s[prop](...args));
+  }
+});
+
+/** @internal */
+const serviceConstants = tag => new Proxy({}, {
+  get(_target, prop, _receiver) {
+    return flatMap(tag, s => s[prop]);
+  }
+});
+
+/** @internal */
+const serviceMembers = tag => ({
+  functions: serviceFunctions(tag),
+  constants: serviceConstants(tag)
+});
+
+/** @internal */
+const serviceOption = tag => map(context(), getOption(tag));
+
+// -----------------------------------------------------------------------------
+// tracing
+// -----------------------------------------------------------------------------
+
+/* @internal */
+const annotateCurrentSpan = function () {
+  const args = arguments;
+  return flatMap(currentSpan, span => span._tag === "Some" ? sync(() => {
+    if (typeof args[0] === "string") {
+      span.value.attribute(args[0], args[1]);
+    } else {
+      for (const key in args[0]) {
+        span.value.attribute(key, args[0][key]);
+      }
+    }
+  }) : unit);
+};
+
+/* @internal */
+const annotateSpans = /*#__PURE__*/dual(args => isEffect(args[0]), function () {
+  const args = arguments;
+  return fiberRefLocallyWith(args[0], currentTracerSpanAnnotations, typeof args[1] === "string" ? set(args[1], args[2]) : annotations => Object.entries(args[1]).reduce((acc, [key, value]) => set(acc, key, value), annotations));
+});
+
+/** @internal */
+const currentParentSpan = /*#__PURE__*/serviceOption(spanTag);
+
+/** @internal */
+const currentSpan = /*#__PURE__*/map( /*#__PURE__*/context(), context => {
+  const span = context.unsafeMap.get(spanTag);
+  return span !== undefined && span._tag === "Span" ? some(span) : none$2();
+});
+const bigint0 = /*#__PURE__*/BigInt(0);
+/** @internal */
+const currentTimeNanosTracing = /*#__PURE__*/fiberRefGetWith(currentTracerTimingEnabled, enabled => enabled ? currentTimeNanos : succeed(bigint0));
+
+/* @internal */
+const linkSpans = /*#__PURE__*/dual(args => isEffect(args[0]), (self, span, attributes) => fiberRefLocallyWith(self, currentTracerSpanLinks, append({
+  _tag: "SpanLink",
+  span,
+  attributes: attributes ?? {}
+})));
+
+/** @internal */
+const makeSpan = (name, options) => tracerWith(tracer => flatMap(options?.parent ? succeedSome(options.parent) : options?.root ? succeedNone : currentParentSpan, parent => flatMap(fiberRefGet(currentTracerSpanAnnotations), annotations => flatMap(fiberRefGet(currentTracerSpanLinks), links => flatMap(currentTimeNanosTracing, startTime => sync(() => {
+  const linksArray = options?.links ? [...toReadonlyArray(links), ...options.links] : toReadonlyArray(links);
+  const span = tracer.span(name, parent, options?.context ?? empty$1(), linksArray, startTime);
+  forEach(annotations, (value, key) => span.attribute(key, value));
+  Object.entries(options?.attributes ?? {}).forEach(([k, v]) => span.attribute(k, v));
+  return span;
+}))))));
+
+/* @internal */
+const spanAnnotations = /*#__PURE__*/fiberRefGet(currentTracerSpanAnnotations);
+
+/* @internal */
+const spanLinks = /*#__PURE__*/fiberRefGet(currentTracerSpanLinks);
+
+/** @internal */
+const useSpan = (name, ...args) => {
+  const options = args.length === 1 ? undefined : args[0];
+  const evaluate = args[args.length - 1];
+  return acquireUseRelease(makeSpan(name, options), evaluate, (span, exit) => flatMap(currentTimeNanosTracing, endTime => sync(() => span.end(endTime, exit))));
+};
+
+/** @internal */
+const withParentSpan = /*#__PURE__*/dual(2, (self, span) => provideService(self, spanTag, span));
+
+/** @internal */
+const withSpan = /*#__PURE__*/dual(args => typeof args[0] !== "string", (self, name, options) => useSpan(name, options ?? {}, span => withParentSpan(self, span)));
+
+// -------------------------------------------------------------------------------------
+// optionality
+// -------------------------------------------------------------------------------------
+
+/* @internal */
+const fromNullable = value => value == null ? fail$1(NoSuchElementException()) : succeed(value);
+
+/* @internal */
+const optionFromOptional = self => catchAll(map(self, some), error => isNoSuchElementException(error) ? succeedNone : fail$1(error));
+
+export { Do, _catch, allowInterrupt, annotateCurrentSpan, annotateLogs, annotateSpans, asSome, asSomeError, asyncOption, bind, bindTo, bindValue, catchAllDefect, catchSomeCause, catchSomeDefect, catchTag, catchTags, cause, clock, clockWith, contextWith, currentParentSpan, currentSpan, currentTimeNanosTracing, delay, descriptor, descriptorWith, diffFiberRefs, diffFiberRefsAndRuntimeFlags, dropUntil, dropWhile, eventually, every, fiberRefs, filterOrDie, filterOrDieMessage, filterOrElse, filterOrFail, findFirst, firstSuccessOf, flipWith, forever, fromNullable, gen, head, ignore, ignoreLogged, inheritFiberRefs, isFailure, isSuccess, iterate, labelMetrics, labelMetricsSet, linkSpans, log, logAnnotations, logDebug, logError, logFatal, logInfo, logTrace, logWarning, loop, makeSpan, mapAccum, mapErrorCause, match, memoize, merge, negate, none, once, option, optionFromOptional, orElseFail, orElseSucceed, parallelErrors, patchFiberRefs, promise, provideService, provideServiceEffect, random, reduce, reduceRight, reduceWhile, repeatN, sandbox, serviceConstants, serviceFunction, serviceFunctionEffect, serviceFunctions, serviceMembers, serviceOption, setFiberRefs, sleep, spanAnnotations, spanLinks, succeedNone, succeedSome, summarized, tagMetrics, takeUntil, takeWhile, tapBoth, tapDefect, tapError, tapErrorCause, tapErrorTag, timed, timedWith, tracer, tracerWith, tryMap, tryMapPromise, tryPromise, try_, unless, unlessEffect, unsandbox, updateFiberRefs, updateService, useSpan, when, whenFiberRef, whenRef, withLogSpan, withMetric, withParentSpan, withSpan };