effect 2.0.0-next.4 → 2.0.0-next.41

package/internal/core.esm.js

@@ -0,0 +1,1745 @@
+import { unsafeHead, make, empty as empty$6, fromIterable, isNonEmpty, reverse, headNonEmpty, of, prepend, tailNonEmpty } from '../Chunk/dist/effect-Chunk.esm.js';
+import { empty as empty$1, merge } from '../Context/dist/effect-Context.esm.js';
+import { update, hashSet, environment } from '../Differ/dist/effect-Differ.esm.js';
+import { isRight, left, right } from '../Either/dist/effect-Either.esm.js';
+import { symbol, equals } from '../Equal/dist/effect-Equal.esm.js';
+import { none } from '../FiberId/dist/effect-FiberId.esm.js';
+import { dual, pipe, identity } from '../Function/dist/effect-Function.esm.js';
+import { globalValue } from '../GlobalValue/dist/effect-GlobalValue.esm.js';
+import { symbol as symbol$1, random, hash } from '../Hash/dist/effect-Hash.esm.js';
+import { empty as empty$2 } from '../HashMap/dist/effect-HashMap.esm.js';
+import { empty as empty$4 } from '../HashSet/dist/effect-HashSet.esm.js';
+import { toJSON, toString, NodeInspectSymbol } from '../Inspectable/dist/effect-Inspectable.esm.js';
+import { reduce, empty, par, seq, single } from './blockedRequests.esm.js';
+import { failureOrCause, die as die$1, fail as fail$1, failures, defects, electFailures, interrupt as interrupt$1, isInterruptedOnly, interruptors, keepDefectsAndElectFailures, empty as empty$5, isInterrupted, parallel, sequential, map as map$1, RuntimeException } from './cause.esm.js';
+import { DeferredTypeId, deferredVariance, pending, done } from './deferred.esm.js';
+import { OP_STATE_PENDING, OP_STATE_DONE } from './opCodes/deferred.esm.js';
+import { OP_SUCCESS, OP_FAILURE, OP_WITH_RUNTIME, OP_ON_FAILURE, OP_ON_SUCCESS, OP_ON_SUCCESS_AND_FAILURE, OP_UPDATE_RUNTIME_FLAGS, OP_SYNC, OP_WHILE, OP_YIELD, OP_REVERT_FLAGS, OP_ASYNC } from './opCodes/effect.esm.js';
+import { Interruption, interruption, differ } from './runtimeFlags.esm.js';
+import { empty as empty$3, isCons } from '../List/dist/effect-List.esm.js';
+import { make as make$1, get, set } from '../MutableRef/dist/effect-MutableRef.esm.js';
+import { getOrElse, getOrThrow, some, none as none$1, match } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { reduce as reduce$1, fromIterable as fromIterable$1 } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
+import { enable, disable } from '../RuntimeFlagsPatch/dist/effect-RuntimeFlagsPatch.esm.js';
+
+// -----------------------------------------------------------------------------
+// Effect
+// -----------------------------------------------------------------------------
+/** @internal */
+const EffectErrorSymbolKey = "effect/EffectError";
+
+/** @internal */
+const EffectErrorTypeId = /*#__PURE__*/Symbol.for(EffectErrorSymbolKey);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const isEffectError = u => typeof u === "object" && u != null && EffectErrorTypeId in u;
+
+/** @internal */
+const makeEffectError = cause => ({
+  [EffectErrorTypeId]: EffectErrorTypeId,
+  _tag: "EffectError",
+  cause
+});
+
+/**
+ * @internal
+ */
+const blocked = (blockedRequests, _continue) => {
+  const effect = new EffectPrimitive("Blocked");
+  effect.i0 = blockedRequests;
+  effect.i1 = _continue;
+  return effect;
+};
+
+/**
+ * @internal
+ */
+const runRequestBlock = blockedRequests => {
+  const effect = new EffectPrimitive("RunBlocked");
+  effect.i0 = blockedRequests;
+  return effect;
+};
+
+/** @internal */
+const EffectTypeId = /*#__PURE__*/Symbol.for("effect/Effect");
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+class RevertFlags {
+  _op = OP_REVERT_FLAGS;
+  constructor(patch, op) {
+    this.patch = patch;
+    this.op = op;
+  }
+}
+
+/** @internal */
+class EffectPrimitive {
+  i0 = undefined;
+  i1 = undefined;
+  i2 = undefined;
+  trace = undefined;
+  [EffectTypeId] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+  }
+  [symbol](that) {
+    return this === that;
+  }
+  [symbol$1]() {
+    return random(this);
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Effect",
+      _op: this._op,
+      i0: toJSON(this.i0),
+      i1: toJSON(this.i1),
+      i2: toJSON(this.i2)
+    };
+  }
+  toString() {
+    return toString(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+}
+
+/** @internal */
+class EffectPrimitiveFailure {
+  i0 = undefined;
+  i1 = undefined;
+  i2 = undefined;
+  trace = undefined;
+  [EffectTypeId] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+    // @ts-expect-error
+    this._tag = _op;
+  }
+  [symbol](that) {
+    return this === that;
+  }
+  [symbol$1]() {
+    return random(this);
+  }
+  get cause() {
+    return this.i0;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Exit",
+      _tag: this._op,
+      cause: this.cause.toJSON()
+    };
+  }
+  toString() {
+    return toString(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+}
+
+/** @internal */
+class EffectPrimitiveSuccess {
+  i0 = undefined;
+  i1 = undefined;
+  i2 = undefined;
+  trace = undefined;
+  [EffectTypeId] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+    // @ts-expect-error
+    this._tag = _op;
+  }
+  [symbol](that) {
+    return this === that;
+  }
+  [symbol$1]() {
+    return random(this);
+  }
+  get value() {
+    return this.i0;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Exit",
+      _tag: this._op,
+      value: toJSON(this.value)
+    };
+  }
+  toString() {
+    return toString(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+}
+
+/** @internal */
+const effectVariance = {
+  _R: _ => _,
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const isEffect = u => typeof u === "object" && u != null && EffectTypeId in u;
+
+/* @internal */
+const withFiberRuntime = withRuntime => {
+  const effect = new EffectPrimitive(OP_WITH_RUNTIME);
+  effect.i0 = withRuntime;
+  return effect;
+};
+
+/* @internal */
+const acquireUseRelease = /*#__PURE__*/dual(3, (acquire, use, release) => uninterruptibleMask(restore => flatMap(acquire, a => flatMap(exit(suspend(() => restore(step(use(a))))), exit => {
+  if (exit._tag === "Success" && exit.value._op === "Blocked") {
+    const value = exit.value;
+    return blocked(value.i0, acquireUseRelease(succeed(a), () => value.i1, release));
+  }
+  const flat = exitFlatten(exit);
+  return suspend(() => release(a, flat)).pipe(matchCauseEffect({
+    onFailure: cause => {
+      switch (flat._tag) {
+        case OP_FAILURE:
+          {
+            return failCause(parallel(flat.i0, cause));
+          }
+        case OP_SUCCESS:
+          {
+            return failCause(cause);
+          }
+      }
+    },
+    onSuccess: () => flat
+  }));
+}))));
+
+/* @internal */
+const as = /*#__PURE__*/dual(2, (self, value) => flatMap(self, () => succeed(value)));
+
+/* @internal */
+const asUnit = self => as(self, void 0);
+
+/* @internal */
+const async = (register, blockingOn = none) => suspend(() => {
+  let cancelerRef = undefined;
+  let controllerRef = undefined;
+  const effect = new EffectPrimitive(OP_ASYNC);
+  if (register.length !== 1) {
+    const controller = new AbortController();
+    controllerRef = controller;
+    effect.i0 = resume => {
+      cancelerRef = register(resume, controller.signal);
+    };
+  } else {
+    effect.i0 = resume => {
+      // @ts-expect-error
+      cancelerRef = register(resume);
+    };
+  }
+  effect.i1 = blockingOn;
+  return onInterrupt(effect, () => {
+    if (controllerRef) {
+      controllerRef.abort();
+    }
+    return cancelerRef ?? unit;
+  });
+});
+
+/* @internal */
+const asyncEither = (register, blockingOn = none) => async(resume => {
+  const result = register(resume);
+  if (isRight(result)) {
+    resume(result.right);
+  } else {
+    return result.left;
+  }
+}, blockingOn);
+
+/* @internal */
+const catchAllCause = /*#__PURE__*/dual(2, (self, f) => {
+  const effect = new EffectPrimitive(OP_ON_FAILURE);
+  effect.i0 = self;
+  effect.i1 = f;
+  return effect;
+});
+
+/* @internal */
+const catchAll = /*#__PURE__*/dual(2, (self, f) => matchEffect(self, {
+  onFailure: f,
+  onSuccess: succeed
+}));
+
+/**
+ * @macro identity
+ * @internal
+ */
+const unified = f => (...args) => f(...args);
+
+/* @internal */
+const catchIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchAllCause(self, cause => {
+  const either = failureOrCause(cause);
+  switch (either._tag) {
+    case "Left":
+      {
+        return predicate(either.left) ? f(either.left) : failCause(cause);
+      }
+    case "Right":
+      {
+        return failCause(either.right);
+      }
+  }
+}));
+
+/* @internal */
+const catchSome = /*#__PURE__*/dual(2, (self, pf) => catchAllCause(self, cause => {
+  const either = failureOrCause(cause);
+  switch (either._tag) {
+    case "Left":
+      {
+        return pipe(pf(either.left), getOrElse(() => failCause(cause)));
+      }
+    case "Right":
+      {
+        return failCause(either.right);
+      }
+  }
+}));
+
+/* @internal */
+const checkInterruptible = f => withFiberRuntime((_, status) => f(interruption(status.runtimeFlags)));
+const spanSymbol = /*#__PURE__*/Symbol.for("effect/SpanAnnotation");
+const originalSymbol = /*#__PURE__*/Symbol.for("effect/OriginalAnnotation");
+
+/* @internal */
+const originalInstance = obj => {
+  if (typeof obj === "object" && obj !== null && originalSymbol in obj) {
+    // @ts-expect-error
+    return obj[originalSymbol];
+  }
+  return obj;
+};
+
+/* @internal */
+const capture = (obj, span) => {
+  if (isCons(span)) {
+    const head = span.head;
+    if (head._tag === "Span") {
+      return new Proxy(obj, {
+        has(target, p) {
+          return p === spanSymbol || p === originalSymbol || p in target;
+        },
+        get(target, p) {
+          if (p === spanSymbol) {
+            return head;
+          }
+          if (p === originalSymbol) {
+            return obj;
+          }
+          // @ts-expect-error
+          return target[p];
+        }
+      });
+    }
+  }
+  return obj;
+};
+
+/* @internal */
+const die = defect => typeof defect === "object" && defect !== null && !(spanSymbol in defect) ? withFiberRuntime(fiber => failCause(die$1(capture(defect, fiber.getFiberRef(currentTracerSpan))))) : failCause(die$1(defect));
+
+/* @internal */
+const dieMessage = message => failCauseSync(() => die$1(RuntimeException(message)));
+
+/* @internal */
+const dieSync = evaluate => flatMap(sync(evaluate), die);
+
+/* @internal */
+const either = self => matchEffect(self, {
+  onFailure: e => succeed(left(e)),
+  onSuccess: a => succeed(right(a))
+});
+
+/* @internal */
+const context = () => suspend(() => fiberRefGet(currentContext));
+
+/* @internal */
+const contextWithEffect = f => flatMap(context(), f);
+
+/* @internal */
+const exit = self => matchCause(self, {
+  onFailure: exitFailCause,
+  onSuccess: exitSucceed
+});
+
+/* @internal */
+const fail = error => typeof error === "object" && error !== null && !(spanSymbol in error) ? withFiberRuntime(fiber => failCause(fail$1(capture(error, fiber.getFiberRef(currentTracerSpan))))) : failCause(fail$1(error));
+
+/* @internal */
+const failSync = evaluate => flatMap(sync(evaluate), fail);
+
+/* @internal */
+const failCause = cause => {
+  const effect = new EffectPrimitiveFailure(OP_FAILURE);
+  effect.i0 = cause;
+  return effect;
+};
+
+/* @internal */
+const failCauseSync = evaluate => flatMap(sync(evaluate), failCause);
+
+/* @internal */
+const fiberId = /*#__PURE__*/withFiberRuntime(state => succeed(state.id()));
+
+/* @internal */
+const fiberIdWith = f => withFiberRuntime(state => f(state.id()));
+
+/* @internal */
+const flatMap = /*#__PURE__*/dual(2, (self, f) => {
+  const effect = new EffectPrimitive(OP_ON_SUCCESS);
+  effect.i0 = self;
+  effect.i1 = f;
+  return effect;
+});
+
+/* @internal */
+const step = self => {
+  const effect = new EffectPrimitive("OnStep");
+  effect.i0 = self;
+  effect.i1 = exitSucceed;
+  return effect;
+};
+
+/* @internal */
+const flatMapStep = (self, f) => {
+  const effect = new EffectPrimitive("OnStep");
+  effect.i0 = self;
+  effect.i1 = f;
+  return effect;
+};
+
+/* @internal */
+const flatten = self => flatMap(self, identity);
+
+/* @internal */
+const flip = self => matchEffect(self, {
+  onFailure: succeed,
+  onSuccess: fail
+});
+
+/* @internal */
+const matchCause = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => matchCauseEffect(self, {
+  onFailure: cause => succeed(onFailure(cause)),
+  onSuccess: a => succeed(onSuccess(a))
+}));
+
+/* @internal */
+const matchCauseEffect = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => {
+  const effect = new EffectPrimitive(OP_ON_SUCCESS_AND_FAILURE);
+  effect.i0 = self;
+  effect.i1 = onFailure;
+  effect.i2 = onSuccess;
+  return effect;
+});
+
+/* @internal */
+const matchEffect = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => matchCauseEffect(self, {
+  onFailure: cause => {
+    const failures$1 = failures(cause);
+    const defects$1 = defects(cause);
+    if (defects$1.length > 0) {
+      return failCause(electFailures(cause));
+    }
+    if (failures$1.length > 0) {
+      return onFailure(unsafeHead(failures$1));
+    }
+    return failCause(cause);
+  },
+  onSuccess
+}));
+
+/* @internal */
+const forEachSequential = /*#__PURE__*/dual(2, (self, f) => suspend(() => {
+  const arr = fromIterable$1(self);
+  const ret = new Array(arr.length);
+  let i = 0;
+  return as(whileLoop({
+    while: () => i < arr.length,
+    body: () => f(arr[i], i),
+    step: b => {
+      ret[i++] = b;
+    }
+  }), ret);
+}));
+
+/* @internal */
+const forEachSequentialDiscard = /*#__PURE__*/dual(2, (self, f) => suspend(() => {
+  const arr = fromIterable$1(self);
+  let i = 0;
+  return whileLoop({
+    while: () => i < arr.length,
+    body: () => f(arr[i], i),
+    step: () => {
+      i++;
+    }
+  });
+}));
+
+/* @internal */
+const if_ = /*#__PURE__*/dual(args => typeof args[0] === "boolean" || isEffect(args[0]), (self, {
+  onFalse,
+  onTrue
+}) => typeof self === "boolean" ? self ? onTrue : onFalse : flatMap(self, unified(b => b ? onTrue : onFalse)));
+
+/* @internal */
+const interrupt = /*#__PURE__*/flatMap(fiberId, fiberId => interruptWith(fiberId));
+
+/* @internal */
+const interruptWith = fiberId => failCause(interrupt$1(fiberId));
+
+/* @internal */
+const interruptible = self => {
+  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
+  effect.i0 = enable(Interruption);
+  const _continue = orBlock => {
+    if (orBlock._tag === "Blocked") {
+      return blocked(orBlock.i0, interruptible(orBlock.i1));
+    } else {
+      return orBlock;
+    }
+  };
+  effect.i1 = () => flatMapStep(self, _continue);
+  return effect;
+};
+
+/* @internal */
+const interruptibleMask = f => {
+  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
+  effect.i0 = enable(Interruption);
+  const _continue = step => {
+    if (step._op === "Blocked") {
+      return blocked(step.i0, interruptible(step.i1));
+    }
+    return step;
+  };
+  effect.i1 = oldFlags => interruption(oldFlags) ? step(f(interruptible)) : step(f(uninterruptible));
+  return flatMap(effect, _continue);
+};
+
+/* @internal */
+const intoDeferred = /*#__PURE__*/dual(2, (self, deferred) => uninterruptibleMask(restore => flatMap(exit(restore(self)), exit => deferredDone(deferred, exit))));
+
+/* @internal */
+const map = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => sync(() => f(a))));
+
+/* @internal */
+const mapBoth = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => matchEffect(self, {
+  onFailure: e => failSync(() => onFailure(e)),
+  onSuccess: a => sync(() => onSuccess(a))
+}));
+
+/* @internal */
+const mapError = /*#__PURE__*/dual(2, (self, f) => matchCauseEffect(self, {
+  onFailure: cause => {
+    const either = failureOrCause(cause);
+    switch (either._tag) {
+      case "Left":
+        {
+          return failSync(() => f(either.left));
+        }
+      case "Right":
+        {
+          return failCause(either.right);
+        }
+    }
+  },
+  onSuccess: succeed
+}));
+
+/* @internal */
+const onError = /*#__PURE__*/dual(2, (self, cleanup) => onExit(self, unified(exit => exitIsSuccess(exit) ? unit : cleanup(exit.i0))));
+
+/* @internal */
+const onExit = /*#__PURE__*/dual(2, (self, cleanup) => uninterruptibleMask(restore => matchCauseEffect(restore(self), {
+  onFailure: cause1 => {
+    const result = exitFailCause(cause1);
+    return matchCauseEffect(cleanup(result), {
+      onFailure: cause2 => exitFailCause(sequential(cause1, cause2)),
+      onSuccess: () => result
+    });
+  },
+  onSuccess: success => {
+    const result = exitSucceed(success);
+    return zipRight(cleanup(result), result);
+  }
+})));
+
+/* @internal */
+const onInterrupt = /*#__PURE__*/dual(2, (self, cleanup) => onExit(self, exitMatch({
+  onFailure: cause => isInterruptedOnly(cause) ? asUnit(cleanup(interruptors(cause))) : unit,
+  onSuccess: () => unit
+})));
+
+/* @internal */
+const orElse = /*#__PURE__*/dual(2, (self, that) => attemptOrElse(self, that, succeed));
+
+/* @internal */
+const orDie = self => orDieWith(self, identity);
+
+/* @internal */
+const orDieWith = /*#__PURE__*/dual(2, (self, f) => matchEffect(self, {
+  onFailure: e => die(f(e)),
+  onSuccess: succeed
+}));
+
+/* @internal */
+const partitionMap = (elements, f) => fromIterable$1(elements).reduceRight(([lefts, rights], current) => {
+  const either = f(current);
+  switch (either._tag) {
+    case "Left":
+      {
+        return [[either.left, ...lefts], rights];
+      }
+    case "Right":
+      {
+        return [lefts, [either.right, ...rights]];
+      }
+  }
+}, [new Array(), new Array()]);
+
+/* @internal */
+const provideContext = /*#__PURE__*/dual(2, (self, context) => fiberRefLocally(currentContext, context)(self));
+
+/* @internal */
+const provideSomeContext = /*#__PURE__*/dual(2, (self, context) => fiberRefLocallyWith(currentContext, parent => merge(parent, context))(self));
+
+/* @internal */
+const mapInputContext = /*#__PURE__*/dual(2, (self, f) => contextWithEffect(context => provideContext(self, f(context))));
+
+/* @internal */
+const runtimeFlags = /*#__PURE__*/withFiberRuntime((_, status) => succeed(status.runtimeFlags));
+
+/* @internal */
+const succeed = value => {
+  const effect = new EffectPrimitiveSuccess(OP_SUCCESS);
+  effect.i0 = value;
+  return effect;
+};
+
+/* @internal */
+const suspend = effect => flatMap(sync(effect), identity);
+
+/* @internal */
+const sync = evaluate => {
+  const effect = new EffectPrimitive(OP_SYNC);
+  effect.i0 = evaluate;
+  return effect;
+};
+
+/* @internal */
+const tap = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => as(f(a), a)));
+
+/* @internal */
+const transplant = f => withFiberRuntime(state => {
+  const scopeOverride = state.getFiberRef(currentForkScopeOverride);
+  const scope = pipe(scopeOverride, getOrElse(() => state.scope()));
+  return f(fiberRefLocally(currentForkScopeOverride, some(scope)));
+});
+
+/* @internal */
+const attemptOrElse = /*#__PURE__*/dual(3, (self, that, onSuccess) => matchCauseEffect(self, {
+  onFailure: cause => {
+    const defects$1 = defects(cause);
+    if (defects$1.length > 0) {
+      return failCause(getOrThrow(keepDefectsAndElectFailures(cause)));
+    }
+    return that();
+  },
+  onSuccess
+}));
+
+/* @internal */
+const uninterruptible = self => {
+  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
+  effect.i0 = disable(Interruption);
+  effect.i1 = () => flatMapStep(self, _continue);
+  const _continue = orBlock => {
+    if (orBlock._tag === "Blocked") {
+      return blocked(orBlock.i0, uninterruptible(orBlock.i1));
+    } else {
+      return orBlock;
+    }
+  };
+  return effect;
+};
+
+/* @internal */
+const uninterruptibleMask = f => {
+  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
+  effect.i0 = disable(Interruption);
+  const _continue = step => {
+    if (step._op === "Blocked") {
+      return blocked(step.i0, uninterruptible(step.i1));
+    }
+    return step;
+  };
+  effect.i1 = oldFlags => interruption(oldFlags) ? step(f(interruptible)) : step(f(uninterruptible));
+  return flatMap(effect, _continue);
+};
+
+/* @internal */
+const unit = /*#__PURE__*/succeed(void 0);
+
+/* @internal */
+const updateRuntimeFlags = patch => {
+  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
+  effect.i0 = patch;
+  effect.i1 = void 0;
+  return effect;
+};
+
+/* @internal */
+const whenEffect = /*#__PURE__*/dual(2, (self, predicate) => flatMap(predicate, b => {
+  if (b) {
+    return pipe(self, map(some));
+  }
+  return succeed(none$1());
+}));
+
+/* @internal */
+const whileLoop = options => {
+  const effect = new EffectPrimitive(OP_WHILE);
+  effect.i0 = options.while;
+  effect.i1 = options.body;
+  effect.i2 = options.step;
+  return effect;
+};
+
+/* @internal */
+const withConcurrency = /*#__PURE__*/dual(2, (self, concurrency) => fiberRefLocally(self, currentConcurrency, concurrency));
+
+/* @internal */
+const withRequestBatching = /*#__PURE__*/dual(2, (self, requestBatching) => fiberRefLocally(self, currentRequestBatching, requestBatching));
+
+/* @internal */
+const withRuntimeFlags = /*#__PURE__*/dual(2, (self, update) => {
+  const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
+  effect.i0 = update;
+  effect.i1 = () => self;
+  return effect;
+});
+
+/** @internal */
+const withTracerTiming = /*#__PURE__*/dual(2, (effect, enabled) => fiberRefLocally(effect, currentTracerTimingEnabled, enabled));
+
+/* @internal */
+const yieldNow = options => {
+  const effect = new EffectPrimitive(OP_YIELD);
+  return typeof options?.priority !== "undefined" ? withSchedulingPriority(options.priority)(effect) : effect;
+};
+
+/* @internal */
+const zip = /*#__PURE__*/dual(2, (self, that) => flatMap(self, a => map(that, b => [a, b])));
+
+/* @internal */
+const zipLeft = /*#__PURE__*/dual(2, (self, that) => flatMap(self, a => as(that, a)));
+
+/* @internal */
+const zipRight = /*#__PURE__*/dual(2, (self, that) => flatMap(self, () => that));
+
+/* @internal */
+const zipWith = /*#__PURE__*/dual(3, (self, that, f) => flatMap(self, a => map(that, b => f(a, b))));
+
+/* @internal */
+const never = /*#__PURE__*/asyncEither(() => {
+  const interval = setInterval(() => {
+    //
+  }, 2 ** 31 - 1);
+  return left(sync(() => clearInterval(interval)));
+});
+
+// -----------------------------------------------------------------------------
+// Fiber
+// -----------------------------------------------------------------------------
+
+/* @internal */
+const interruptFiber = self => flatMap(fiberId, fiberId => pipe(self, interruptAsFiber(fiberId)));
+
+/* @internal */
+const interruptAsFiber = /*#__PURE__*/dual(2, (self, fiberId) => flatMap(self.interruptAsFork(fiberId), () => self.await()));
+
+// -----------------------------------------------------------------------------
+// LogLevel
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const logLevelAll = {
+  _tag: "All",
+  syslog: 0,
+  label: "ALL",
+  ordinal: Number.MIN_SAFE_INTEGER,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/** @internal */
+const logLevelFatal = {
+  _tag: "Fatal",
+  syslog: 2,
+  label: "FATAL",
+  ordinal: 50000,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/** @internal */
+const logLevelError = {
+  _tag: "Error",
+  syslog: 3,
+  label: "ERROR",
+  ordinal: 40000,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/** @internal */
+const logLevelWarning = {
+  _tag: "Warning",
+  syslog: 4,
+  label: "WARN",
+  ordinal: 30000,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/** @internal */
+const logLevelInfo = {
+  _tag: "Info",
+  syslog: 6,
+  label: "INFO",
+  ordinal: 20000,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/** @internal */
+const logLevelDebug = {
+  _tag: "Debug",
+  syslog: 7,
+  label: "DEBUG",
+  ordinal: 10000,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/** @internal */
+const logLevelTrace = {
+  _tag: "Trace",
+  syslog: 7,
+  label: "TRACE",
+  ordinal: 0,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/** @internal */
+const logLevelNone = {
+  _tag: "None",
+  syslog: 7,
+  label: "OFF",
+  ordinal: Number.MAX_SAFE_INTEGER,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/** @internal */
+const allLogLevels = [logLevelAll, logLevelTrace, logLevelDebug, logLevelInfo, logLevelWarning, logLevelError, logLevelFatal, logLevelNone];
+
+// -----------------------------------------------------------------------------
+// FiberRef
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const FiberRefSymbolKey = "effect/FiberRef";
+
+/** @internal */
+const FiberRefTypeId = /*#__PURE__*/Symbol.for(FiberRefSymbolKey);
+
+/** @internal */
+const fiberRefVariance = {
+  _A: _ => _
+};
+
+/* @internal */
+const fiberRefGet = self => fiberRefModify(self, a => [a, a]);
+
+/* @internal */
+const fiberRefGetAndSet = /*#__PURE__*/dual(2, (self, value) => fiberRefModify(self, v => [v, value]));
+
+/* @internal */
+const fiberRefGetAndUpdate = /*#__PURE__*/dual(2, (self, f) => fiberRefModify(self, v => [v, f(v)]));
+
+/* @internal */
+const fiberRefGetAndUpdateSome = /*#__PURE__*/dual(2, (self, pf) => fiberRefModify(self, v => [v, getOrElse(pf(v), () => v)]));
+
+/* @internal */
+const fiberRefGetWith = /*#__PURE__*/dual(2, (self, f) => flatMap(fiberRefGet(self), f));
+
+/* @internal */
+const fiberRefSet = /*#__PURE__*/dual(2, (self, value) => fiberRefModify(self, () => [void 0, value]));
+
+/* @internal */
+const fiberRefDelete = self => withFiberRuntime(state => {
+  state.unsafeDeleteFiberRef(self);
+  return unit;
+});
+
+/* @internal */
+const fiberRefReset = self => fiberRefSet(self, self.initial);
+
+/* @internal */
+const fiberRefModify = /*#__PURE__*/dual(2, (self, f) => withFiberRuntime(state => {
+  const [b, a] = f(state.getFiberRef(self));
+  state.setFiberRef(self, a);
+  return succeed(b);
+}));
+
+/* @internal */
+const fiberRefModifySome = (self, def, f) => fiberRefModify(self, v => getOrElse(f(v), () => [def, v]));
+
+/* @internal */
+const fiberRefUpdate = /*#__PURE__*/dual(2, (self, f) => fiberRefModify(self, v => [void 0, f(v)]));
+
+/* @internal */
+const fiberRefUpdateSome = /*#__PURE__*/dual(2, (self, pf) => fiberRefModify(self, v => [void 0, getOrElse(pf(v), () => v)]));
+
+/* @internal */
+const fiberRefUpdateAndGet = /*#__PURE__*/dual(2, (self, f) => fiberRefModify(self, v => {
+  const result = f(v);
+  return [result, result];
+}));
+
+/* @internal */
+const fiberRefUpdateSomeAndGet = /*#__PURE__*/dual(2, (self, pf) => fiberRefModify(self, v => {
+  const result = getOrElse(pf(v), () => v);
+  return [result, result];
+}));
+
+// circular
+/** @internal */
+const RequestResolverSymbolKey = "effect/RequestResolver";
+
+/** @internal */
+const RequestResolverTypeId = /*#__PURE__*/Symbol.for(RequestResolverSymbolKey);
+const dataSourceVariance = {
+  _R: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+class RequestResolverImpl {
+  [RequestResolverTypeId] = dataSourceVariance;
+  constructor(runAll, target) {
+    this.runAll = runAll;
+    this.target = target;
+    this.runAll = runAll;
+  }
+  [symbol$1]() {
+    return this.target ? hash(this.target) : random(this);
+  }
+  [symbol](that) {
+    return this.target ? isRequestResolver(that) && equals(this.target, that.target) : this === that;
+  }
+  identified(...ids) {
+    return new RequestResolverImpl(this.runAll, fromIterable(ids));
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const isRequestResolver = u => typeof u === "object" && u != null && RequestResolverTypeId in u;
+
+// end
+
+/** @internal */
+const resolverLocally = /*#__PURE__*/dual(3, (use, self, value) => new RequestResolverImpl(requests => fiberRefLocally(use.runAll(requests), self, value), make("Locally", use, self, value)));
+
+/** @internal */
+const requestBlockLocally = (self, ref, value) => reduce(self, LocallyReducer(ref, value));
+const LocallyReducer = (ref, value) => ({
+  emptyCase: () => empty,
+  parCase: (left, right) => par(left, right),
+  seqCase: (left, right) => seq(left, right),
+  singleCase: (dataSource, blockedRequest) => single(resolverLocally(dataSource, ref, value), blockedRequest)
+});
+
+/* @internal */
+const fiberRefLocally = /*#__PURE__*/dual(3, (use, self, value) => flatMap(acquireUseRelease(zipLeft(fiberRefGet(self), fiberRefSet(self, value)), () => step(use), oldValue => fiberRefSet(self, oldValue)), res => {
+  if (res._op === "Blocked") {
+    return blocked(res.i0, fiberRefLocally(res.i1, self, value));
+  }
+  return res;
+}));
+
+/* @internal */
+const fiberRefLocallyWith = /*#__PURE__*/dual(3, (use, self, f) => fiberRefGetWith(self, a => fiberRefLocally(use, self, f(a))));
+
+/** @internal */
+const fiberRefUnsafeMake = (initial, options) => fiberRefUnsafeMakePatch(initial, {
+  differ: update(),
+  fork: options?.fork ?? identity,
+  join: options?.join
+});
+
+/** @internal */
+const fiberRefUnsafeMakeHashSet = initial => {
+  const differ = hashSet();
+  return fiberRefUnsafeMakePatch(initial, {
+    differ,
+    fork: differ.empty
+  });
+};
+
+/** @internal */
+const fiberRefUnsafeMakeContext = initial => {
+  const differ = environment();
+  return fiberRefUnsafeMakePatch(initial, {
+    differ,
+    fork: differ.empty
+  });
+};
+
+/** @internal */
+const fiberRefUnsafeMakePatch = (initial, options) => ({
+  [FiberRefTypeId]: fiberRefVariance,
+  initial,
+  diff: (oldValue, newValue) => options.differ.diff(oldValue, newValue),
+  combine: (first, second) => options.differ.combine(first, second),
+  patch: patch => oldValue => options.differ.patch(patch, oldValue),
+  fork: options.fork,
+  join: options.join ?? ((_, n) => n),
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+});
+
+/** @internal */
+const fiberRefUnsafeMakeRuntimeFlags = initial => fiberRefUnsafeMakePatch(initial, {
+  differ: differ,
+  fork: differ.empty
+});
+
+/** @internal */
+const currentContext = /*#__PURE__*/fiberRefUnsafeMakeContext( /*#__PURE__*/empty$1());
+
+/** @internal */
+const currentSchedulingPriority = /*#__PURE__*/fiberRefUnsafeMake(0);
+
+/** @internal */
+const currentMaxOpsBeforeYield = /*#__PURE__*/fiberRefUnsafeMake(2048);
+
+/** @internal */
+const currentLogAnnotations = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentLogAnnotation"), () => fiberRefUnsafeMake(empty$2()));
+
+/** @internal */
+const currentLogLevel = /*#__PURE__*/fiberRefUnsafeMake(logLevelInfo);
+
+/** @internal */
+const currentLogSpan = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentLogSpan"), () => fiberRefUnsafeMake(empty$3()));
+
+/** @internal */
+const withSchedulingPriority = /*#__PURE__*/dual(2, (self, scheduler) => fiberRefLocally(self, currentSchedulingPriority, scheduler));
+
+/** @internal */
+const withMaxOpsBeforeYield = /*#__PURE__*/dual(2, (self, scheduler) => fiberRefLocally(self, currentMaxOpsBeforeYield, scheduler));
+
+/** @internal */
+const currentConcurrency = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentConcurrency"), () => fiberRefUnsafeMake("unbounded"));
+
+/**
+ * @internal
+ */
+const currentRequestBatching = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentRequestBatching"), () => fiberRefUnsafeMake(true));
+
+/** @internal */
+const currentUnhandledErrorLogLevel = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentUnhandledErrorLogLevel"), () => fiberRefUnsafeMake(some(logLevelDebug)));
+
+/** @internal */
+const withUnhandledErrorLogLevel = /*#__PURE__*/dual(2, (self, level) => fiberRefLocally(self, currentUnhandledErrorLogLevel, level));
+
+/** @internal */
+const currentMetricLabels = /*#__PURE__*/fiberRefUnsafeMakeHashSet( /*#__PURE__*/empty$4());
+
+/* @internal */
+const metricLabels = /*#__PURE__*/fiberRefGet(currentMetricLabels);
+
+/** @internal */
+const currentForkScopeOverride = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentForkScopeOverride"), () => fiberRefUnsafeMake(none$1(), {
+  fork: () => none$1(),
+  join: (parent, _) => parent
+}));
+
+/** @internal */
+const currentInterruptedCause = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentInterruptedCause"), () => fiberRefUnsafeMake(empty$5, {
+  fork: () => empty$5,
+  join: (parent, _) => parent
+}));
+
+/** @internal */
+const currentTracerSpan = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentTracerSpan"), () => fiberRefUnsafeMake(empty$3()));
+
+/** @internal */
+const currentTracerTimingEnabled = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentTracerTiming"), () => fiberRefUnsafeMake(true));
+
+/** @internal */
+const currentTracerSpanAnnotations = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentTracerSpanAnnotations"), () => fiberRefUnsafeMake(empty$2()));
+
+/** @internal */
+const currentTracerSpanLinks = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentTracerSpanLinks"), () => fiberRefUnsafeMake(empty$6()));
+
+// -----------------------------------------------------------------------------
+// Scope
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const ScopeTypeId = /*#__PURE__*/Symbol.for("effect/Scope");
+
+/** @internal */
+const CloseableScopeTypeId = /*#__PURE__*/Symbol.for("effect/CloseableScope");
+
+/* @internal */
+const scopeAddFinalizer = (self, finalizer) => self.addFinalizer(() => asUnit(finalizer));
+
+/* @internal */
+const scopeAddFinalizerExit = (self, finalizer) => self.addFinalizer(finalizer);
+
+/* @internal */
+const scopeClose = (self, exit) => self.close(exit);
+
+/* @internal */
+const scopeFork = (self, strategy) => self.fork(strategy);
+
+// -----------------------------------------------------------------------------
+// ReleaseMap
+// -----------------------------------------------------------------------------
+
+/** @internal */
+/** @internal */
+/* @internal */
+const releaseMapAdd = /*#__PURE__*/dual(2, (self, finalizer) => map(releaseMapAddIfOpen(self, finalizer), match({
+  onNone: () => () => unit,
+  onSome: key => exit => releaseMapRelease(key, exit)(self)
+})));
+
+/* @internal */
+const releaseMapRelease = /*#__PURE__*/dual(3, (self, key, exit) => suspend(() => {
+  switch (self.state._tag) {
+    case "Exited":
+      {
+        return unit;
+      }
+    case "Running":
+      {
+        const finalizer = self.state.finalizers.get(key);
+        self.state.finalizers.delete(key);
+        if (finalizer != null) {
+          return self.state.update(finalizer)(exit);
+        }
+        return unit;
+      }
+  }
+}));
+
+/* @internal */
+const releaseMapAddIfOpen = /*#__PURE__*/dual(2, (self, finalizer) => suspend(() => {
+  switch (self.state._tag) {
+    case "Exited":
+      {
+        self.state.nextKey += 1;
+        return as(finalizer(self.state.exit), none$1());
+      }
+    case "Running":
+      {
+        const key = self.state.nextKey;
+        self.state.finalizers.set(key, finalizer);
+        self.state.nextKey += 1;
+        return succeed(some(key));
+      }
+  }
+}));
+
+/* @internal */
+const releaseMapMake = /*#__PURE__*/sync(() => ({
+  state: {
+    _tag: "Running",
+    nextKey: 0,
+    finalizers: new Map(),
+    update: identity
+  }
+}));
+
+// -----------------------------------------------------------------------------
+// Exit
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const exitIsExit = u => isEffect(u) && "_tag" in u && (u._tag === "Success" || u._tag === "Failure");
+
+/** @internal */
+const exitIsFailure = self => self._tag === "Failure";
+
+/** @internal */
+const exitIsSuccess = self => self._tag === "Success";
+
+/** @internal */
+const exitIsInterrupted = self => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return isInterrupted(self.i0);
+      }
+    case OP_SUCCESS:
+      {
+        return false;
+      }
+  }
+};
+
+/** @internal */
+const exitAs = /*#__PURE__*/dual(2, (self, value) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return exitFailCause(self.i0);
+      }
+    case OP_SUCCESS:
+      {
+        return exitSucceed(value);
+      }
+  }
+});
+
+/** @internal */
+const exitAsUnit = self => exitAs(self, void 0);
+
+/** @internal */
+const exitCauseOption = self => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return some(self.i0);
+      }
+    case OP_SUCCESS:
+      {
+        return none$1();
+      }
+  }
+};
+
+/** @internal */
+const exitCollectAll = (exits, options) => exitCollectAllInternal(exits, options?.parallel ? parallel : sequential);
+
+/** @internal */
+const exitDie = defect => exitFailCause(die$1(defect));
+
+/** @internal */
+const exitExists = /*#__PURE__*/dual(2, (self, predicate) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return false;
+      }
+    case OP_SUCCESS:
+      {
+        return predicate(self.i0);
+      }
+  }
+});
+
+/** @internal */
+const exitFail = error => exitFailCause(fail$1(error));
+
+/** @internal */
+const exitFailCause = cause => {
+  const effect = new EffectPrimitiveFailure(OP_FAILURE);
+  effect.i0 = cause;
+  return effect;
+};
+
+/** @internal */
+const exitFlatMap = /*#__PURE__*/dual(2, (self, f) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return exitFailCause(self.i0);
+      }
+    case OP_SUCCESS:
+      {
+        return f(self.i0);
+      }
+  }
+});
+
+/** @internal */
+const exitFlatMapEffect = /*#__PURE__*/dual(2, (self, f) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return succeed(exitFailCause(self.i0));
+      }
+    case OP_SUCCESS:
+      {
+        return f(self.i0);
+      }
+  }
+});
+
+/** @internal */
+const exitFlatten = self => pipe(self, exitFlatMap(identity));
+
+/** @internal */
+const exitForEachEffect = /*#__PURE__*/dual(2, (self, f) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return succeed(exitFailCause(self.i0));
+      }
+    case OP_SUCCESS:
+      {
+        return exit(f(self.i0));
+      }
+  }
+});
+
+/** @internal */
+const exitFromEither = either => {
+  switch (either._tag) {
+    case "Left":
+      {
+        return exitFail(either.left);
+      }
+    case "Right":
+      {
+        return exitSucceed(either.right);
+      }
+  }
+};
+
+/** @internal */
+const exitFromOption = option => {
+  switch (option._tag) {
+    case "None":
+      {
+        return exitFail(void 0);
+      }
+    case "Some":
+      {
+        return exitSucceed(option.value);
+      }
+  }
+};
+
+/** @internal */
+const exitGetOrElse = /*#__PURE__*/dual(2, (self, orElse) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return orElse(self.i0);
+      }
+    case OP_SUCCESS:
+      {
+        return self.i0;
+      }
+  }
+});
+
+/** @internal */
+const exitInterrupt = fiberId => exitFailCause(interrupt$1(fiberId));
+
+/** @internal */
+const exitMap = /*#__PURE__*/dual(2, (self, f) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return exitFailCause(self.i0);
+      }
+    case OP_SUCCESS:
+      {
+        return exitSucceed(f(self.i0));
+      }
+  }
+});
+
+/** @internal */
+const exitMapBoth = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return exitFailCause(pipe(self.i0, map$1(onFailure)));
+      }
+    case OP_SUCCESS:
+      {
+        return exitSucceed(onSuccess(self.i0));
+      }
+  }
+});
+
+/** @internal */
+const exitMapError = /*#__PURE__*/dual(2, (self, f) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return exitFailCause(pipe(self.i0, map$1(f)));
+      }
+    case OP_SUCCESS:
+      {
+        return exitSucceed(self.i0);
+      }
+  }
+});
+
+/** @internal */
+const exitMapErrorCause = /*#__PURE__*/dual(2, (self, f) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return exitFailCause(f(self.i0));
+      }
+    case OP_SUCCESS:
+      {
+        return exitSucceed(self.i0);
+      }
+  }
+});
+
+/** @internal */
+const exitMatch = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return onFailure(self.i0);
+      }
+    case OP_SUCCESS:
+      {
+        return onSuccess(self.i0);
+      }
+  }
+});
+
+/** @internal */
+const exitMatchEffect = /*#__PURE__*/dual(2, (self, {
+  onFailure,
+  onSuccess
+}) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        return onFailure(self.i0);
+      }
+    case OP_SUCCESS:
+      {
+        return onSuccess(self.i0);
+      }
+  }
+});
+
+/** @internal */
+const exitSucceed = value => {
+  const effect = new EffectPrimitiveSuccess(OP_SUCCESS);
+  effect.i0 = value;
+  return effect;
+};
+
+/** @internal */
+const exitUnit = /*#__PURE__*/exitSucceed(void 0);
+
+/** @internal */
+const exitZip = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
+  onSuccess: (a, a2) => [a, a2],
+  onFailure: sequential
+}));
+
+/** @internal */
+const exitZipLeft = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
+  onSuccess: (a, _) => a,
+  onFailure: sequential
+}));
+
+/** @internal */
+const exitZipRight = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
+  onSuccess: (_, a2) => a2,
+  onFailure: sequential
+}));
+
+/** @internal */
+const exitZipPar = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
+  onSuccess: (a, a2) => [a, a2],
+  onFailure: parallel
+}));
+
+/** @internal */
+const exitZipParLeft = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
+  onSuccess: (a, _) => a,
+  onFailure: parallel
+}));
+
+/** @internal */
+const exitZipParRight = /*#__PURE__*/dual(2, (self, that) => exitZipWith(self, that, {
+  onSuccess: (_, a2) => a2,
+  onFailure: parallel
+}));
+
+/** @internal */
+const exitZipWith = /*#__PURE__*/dual(3, (self, that, {
+  onFailure,
+  onSuccess
+}) => {
+  switch (self._tag) {
+    case OP_FAILURE:
+      {
+        switch (that._tag) {
+          case OP_SUCCESS:
+            {
+              return exitFailCause(self.i0);
+            }
+          case OP_FAILURE:
+            {
+              return exitFailCause(onFailure(self.i0, that.i0));
+            }
+        }
+      }
+    case OP_SUCCESS:
+      {
+        switch (that._tag) {
+          case OP_SUCCESS:
+            {
+              return exitSucceed(onSuccess(self.i0, that.i0));
+            }
+          case OP_FAILURE:
+            {
+              return exitFailCause(that.i0);
+            }
+        }
+      }
+  }
+});
+const exitCollectAllInternal = (exits, combineCauses) => {
+  const list = fromIterable(exits);
+  if (!isNonEmpty(list)) {
+    return none$1();
+  }
+  return pipe(tailNonEmpty(list), reduce$1(pipe(headNonEmpty(list), exitMap(of)), (accumulator, current) => pipe(accumulator, exitZipWith(current, {
+    onSuccess: (list, value) => pipe(list, prepend(value)),
+    onFailure: combineCauses
+  }))), exitMap(reverse), exitMap(chunk => Array.from(chunk)), some);
+};
+
+// -----------------------------------------------------------------------------
+// Deferred
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const deferredUnsafeMake = fiberId => ({
+  [DeferredTypeId]: deferredVariance,
+  state: make$1(pending([])),
+  blockingOn: fiberId,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+});
+
+/* @internal */
+const deferredMake = () => flatMap(fiberId, id => deferredMakeAs(id));
+
+/* @internal */
+const deferredMakeAs = fiberId => sync(() => deferredUnsafeMake(fiberId));
+
+/* @internal */
+const deferredAwait = self => asyncEither(k => {
+  const state = get(self.state);
+  switch (state._tag) {
+    case OP_STATE_DONE:
+      {
+        return right(state.effect);
+      }
+    case OP_STATE_PENDING:
+      {
+        pipe(self.state, set(pending([k, ...state.joiners])));
+        return left(deferredInterruptJoiner(self, k));
+      }
+  }
+}, self.blockingOn);
+
+/* @internal */
+const deferredComplete = /*#__PURE__*/dual(2, (self, effect) => intoDeferred(effect, self));
+
+/* @internal */
+const deferredCompleteWith = /*#__PURE__*/dual(2, (self, effect) => sync(() => {
+  const state = get(self.state);
+  switch (state._tag) {
+    case OP_STATE_DONE:
+      {
+        return false;
+      }
+    case OP_STATE_PENDING:
+      {
+        pipe(self.state, set(done(effect)));
+        for (let i = 0; i < state.joiners.length; i++) {
+          state.joiners[i](effect);
+        }
+        return true;
+      }
+  }
+}));
+
+/* @internal */
+const deferredDone = /*#__PURE__*/dual(2, (self, exit) => deferredCompleteWith(self, exit));
+
+/* @internal */
+const deferredFail = /*#__PURE__*/dual(2, (self, error) => deferredCompleteWith(self, fail(error)));
+
+/* @internal */
+const deferredFailSync = /*#__PURE__*/dual(2, (self, evaluate) => deferredCompleteWith(self, failSync(evaluate)));
+
+/* @internal */
+const deferredFailCause = /*#__PURE__*/dual(2, (self, cause) => deferredCompleteWith(self, failCause(cause)));
+
+/* @internal */
+const deferredFailCauseSync = /*#__PURE__*/dual(2, (self, evaluate) => deferredCompleteWith(self, failCauseSync(evaluate)));
+
+/* @internal */
+const deferredDie = /*#__PURE__*/dual(2, (self, defect) => deferredCompleteWith(self, die(defect)));
+
+/* @internal */
+const deferredDieSync = /*#__PURE__*/dual(2, (self, evaluate) => deferredCompleteWith(self, dieSync(evaluate)));
+
+/* @internal */
+const deferredInterrupt = self => flatMap(fiberId, fiberId => deferredCompleteWith(self, interruptWith(fiberId)));
+
+/* @internal */
+const deferredInterruptWith = /*#__PURE__*/dual(2, (self, fiberId) => deferredCompleteWith(self, interruptWith(fiberId)));
+
+/* @internal */
+const deferredIsDone = self => sync(() => get(self.state)._tag === OP_STATE_DONE);
+
+/* @internal */
+const deferredPoll = self => sync(() => {
+  const state = get(self.state);
+  switch (state._tag) {
+    case OP_STATE_DONE:
+      {
+        return some(state.effect);
+      }
+    case OP_STATE_PENDING:
+      {
+        return none$1();
+      }
+  }
+});
+
+/* @internal */
+const deferredSucceed = /*#__PURE__*/dual(2, (self, value) => deferredCompleteWith(self, succeed(value)));
+
+/* @internal */
+const deferredSync = /*#__PURE__*/dual(2, (self, evaluate) => deferredCompleteWith(self, sync(evaluate)));
+
+/** @internal */
+const deferredUnsafeDone = (self, effect) => {
+  const state = get(self.state);
+  if (state._tag === OP_STATE_PENDING) {
+    pipe(self.state, set(done(effect)));
+    for (let i = state.joiners.length - 1; i >= 0; i--) {
+      state.joiners[i](effect);
+    }
+  }
+};
+const deferredInterruptJoiner = (self, joiner) => sync(() => {
+  const state = get(self.state);
+  if (state._tag === OP_STATE_PENDING) {
+    pipe(self.state, set(pending(state.joiners.filter(j => j !== joiner))));
+  }
+});
+
+export { CloseableScopeTypeId, EffectErrorTypeId, EffectTypeId, FiberRefTypeId, RequestResolverImpl, RequestResolverTypeId, RevertFlags, ScopeTypeId, acquireUseRelease, allLogLevels, as, asUnit, async, asyncEither, attemptOrElse, blocked, catchAll, catchAllCause, catchIf, catchSome, checkInterruptible, context, contextWithEffect, currentConcurrency, currentContext, currentForkScopeOverride, currentInterruptedCause, currentLogAnnotations, currentLogLevel, currentLogSpan, currentMaxOpsBeforeYield, currentMetricLabels, currentRequestBatching, currentSchedulingPriority, currentTracerSpan, currentTracerSpanAnnotations, currentTracerSpanLinks, currentTracerTimingEnabled, currentUnhandledErrorLogLevel, deferredAwait, deferredComplete, deferredCompleteWith, deferredDie, deferredDieSync, deferredDone, deferredFail, deferredFailCause, deferredFailCauseSync, deferredFailSync, deferredInterrupt, deferredInterruptWith, deferredIsDone, deferredMake, deferredMakeAs, deferredPoll, deferredSucceed, deferredSync, deferredUnsafeDone, deferredUnsafeMake, die, dieMessage, dieSync, either, exit, exitAs, exitAsUnit, exitCauseOption, exitCollectAll, exitDie, exitExists, exitFail, exitFailCause, exitFlatMap, exitFlatMapEffect, exitFlatten, exitForEachEffect, exitFromEither, exitFromOption, exitGetOrElse, exitInterrupt, exitIsExit, exitIsFailure, exitIsInterrupted, exitIsSuccess, exitMap, exitMapBoth, exitMapError, exitMapErrorCause, exitMatch, exitMatchEffect, exitSucceed, exitUnit, exitZip, exitZipLeft, exitZipPar, exitZipParLeft, exitZipParRight, exitZipRight, exitZipWith, fail, failCause, failCauseSync, failSync, fiberId, fiberIdWith, fiberRefDelete, fiberRefGet, fiberRefGetAndSet, fiberRefGetAndUpdate, fiberRefGetAndUpdateSome, fiberRefGetWith, fiberRefLocally, fiberRefLocallyWith, fiberRefModify, fiberRefModifySome, fiberRefReset, fiberRefSet, fiberRefUnsafeMake, fiberRefUnsafeMakeContext, fiberRefUnsafeMakeHashSet, fiberRefUnsafeMakePatch, fiberRefUnsafeMakeRuntimeFlags, fiberRefUpdate, fiberRefUpdateAndGet, fiberRefUpdateSome, fiberRefUpdateSomeAndGet, flatMap, flatMapStep, flatten, flip, forEachSequential, forEachSequentialDiscard, if_, interrupt, interruptAsFiber, interruptFiber, interruptWith, interruptible, interruptibleMask, intoDeferred, isEffect, isEffectError, isRequestResolver, logLevelAll, logLevelDebug, logLevelError, logLevelFatal, logLevelInfo, logLevelNone, logLevelTrace, logLevelWarning, makeEffectError, map, mapBoth, mapError, mapInputContext, matchCause, matchCauseEffect, matchEffect, metricLabels, never, onError, onExit, onInterrupt, orDie, orDieWith, orElse, originalInstance, partitionMap, provideContext, provideSomeContext, releaseMapAdd, releaseMapAddIfOpen, releaseMapMake, releaseMapRelease, requestBlockLocally, resolverLocally, runRequestBlock, runtimeFlags, scopeAddFinalizer, scopeAddFinalizerExit, scopeClose, scopeFork, step, succeed, suspend, sync, tap, transplant, unified, uninterruptible, uninterruptibleMask, unit, updateRuntimeFlags, whenEffect, whileLoop, withConcurrency, withFiberRuntime, withMaxOpsBeforeYield, withRequestBatching, withRuntimeFlags, withSchedulingPriority, withTracerTiming, withUnhandledErrorLogLevel, yieldNow, zip, zipLeft, zipRight, zipWith };