effect 2.0.0-next.35 → 2.0.0-next.37

package/dist/core-9f5f0dc2.esm.js

@@ -0,0 +1,3225 @@
+import { r as reverse, e as empty$2, p as prepend, o as of, h as isNonEmpty, b as appendAll, j as headNonEmpty, k as head, i as isEmpty$1, a as unsafeHead$1, m as make$2, f as fromIterable, t as tailNonEmpty } from './Chunk-98371336.esm.js';
+import { e as empty$6, m as merge$1 } from './Context-48179faa.esm.js';
+import { u as update, h as hashSet, e as environment } from './Differ-3be1df41.esm.js';
+import { l as left, r as right, i as isRight } from './Either-09270bbc.esm.js';
+import { e as equals, s as symbol$1 } from './Equal-7d4ae7e7.esm.js';
+import { i as ids, n as none$1 } from './FiberId-556ab9ef.esm.js';
+import { p as pipe, d as dual, i as identity, c as constTrue, a as constFalse } from './Function-52fb7d21.esm.js';
+import { g as globalValue } from './GlobalValue-c5f1e8e5.esm.js';
+import { s as symbol, c as combine, h as hash, r as random } from './Hash-039222d1.esm.js';
+import { e as empty$5, m as make$1, r as reduce$4, s as set, g as get, i as isEmpty$2, k as keys, a as map$4 } from './HashMap-e644e23b.esm.js';
+import { e as empty$3, a as add, m as make, f as flatMap$2, b as map$3, u as union, s as size$1 } from './HashSet-dff2542b.esm.js';
+import { a as toJSON, N as NodeInspectSymbol, t as toString } from './Inspectable-bda84223.esm.js';
+import { o as of$1, i as isCons, c as cons, r as reduce$3, e as empty$4, u as unsafeHead, a as unsafeTail, b as isNil, d as appendAll$1, f as reverse$1 } from './List-c066a506.esm.js';
+import { n as none, s as some, i as isSome, m as map$2, a as isNone, b as match$1, c as getOrUndefined, g as getOrElse, d as getOrThrow } from './Option-1d073850.esm.js';
+import { p as pipeArguments } from './Pipeable-fe51dc02.esm.js';
+import { A as reduce$2, f as fromIterable$1 } from './ReadonlyArray-199ff80e.esm.js';
+import { O as OP_SUCCESS, a as OP_FAILURE, b as OP_WITH_RUNTIME, c as OP_ON_FAILURE, d as OP_ON_SUCCESS, e as OP_ON_SUCCESS_AND_FAILURE, f as OP_UPDATE_RUNTIME_FLAGS, g as OP_SYNC, h as OP_WHILE, i as OP_YIELD, j as OP_REVERT_FLAGS, k as OP_ASYNC } from './Effectable-a76b6aa1.esm.js';
+import { e as enable, I as Interruption, i as interruption, d as disable, a as differ } from './RuntimeFlagsPatch-a1da6096.esm.js';
+import { m as make$3, g as get$1, s as set$1 } from './MutableRef-cb4d2fc0.esm.js';
+
+/** @internal */
+const OP_DIE = "Die";
+
+/** @internal */
+
+/** @internal */
+const OP_EMPTY = "Empty";
+
+/** @internal */
+
+/** @internal */
+const OP_FAIL = "Fail";
+
+/** @internal */
+
+/** @internal */
+const OP_INTERRUPT = "Interrupt";
+
+/** @internal */
+
+/** @internal */
+const OP_PARALLEL = "Parallel";
+
+/** @internal */
+
+/** @internal */
+const OP_SEQUENTIAL = "Sequential";
+
+/** @internal */
+
+// -----------------------------------------------------------------------------
+// Models
+// -----------------------------------------------------------------------------
+/** @internal */
+const CauseSymbolKey = "effect/Cause";
+
+/** @internal */
+const CauseTypeId = /*#__PURE__*/Symbol.for(CauseSymbolKey);
+
+/** @internal */
+const variance = {
+  _E: _ => _
+};
+
+/** @internal */
+const proto = {
+  [CauseTypeId]: variance,
+  [symbol]() {
+    return pipe(hash(CauseSymbolKey), combine(hash(flattenCause(this))));
+  },
+  [symbol$1](that) {
+    return isCause(that) && causeEquals(this, that);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  toJSON() {
+    switch (this._tag) {
+      case "Empty":
+        return {
+          _id: "Cause",
+          _tag: this._tag
+        };
+      case "Die":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          defect: toJSON(this.defect)
+        };
+      case "Interrupt":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          fiberId: this.fiberId.toJSON()
+        };
+      case "Fail":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          failure: toJSON(this.error)
+        };
+      case "Sequential":
+      case "Parallel":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          errors: toJSON(prettyErrors(this))
+        };
+    }
+  },
+  toString() {
+    return pretty(this);
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+
+// -----------------------------------------------------------------------------
+// Constructors
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const empty$1 = /*#__PURE__*/(() => {
+  const o = /*#__PURE__*/Object.create(proto);
+  o._tag = OP_EMPTY;
+  return o;
+})();
+
+/** @internal */
+const fail$1 = error => {
+  const o = Object.create(proto);
+  o._tag = OP_FAIL;
+  o.error = error;
+  return o;
+};
+
+/** @internal */
+const die$1 = defect => {
+  const o = Object.create(proto);
+  o._tag = OP_DIE;
+  o.defect = defect;
+  return o;
+};
+
+/** @internal */
+const interrupt$1 = fiberId => {
+  const o = Object.create(proto);
+  o._tag = OP_INTERRUPT;
+  o.fiberId = fiberId;
+  return o;
+};
+
+/** @internal */
+const parallel = (left, right) => {
+  const o = Object.create(proto);
+  o._tag = OP_PARALLEL;
+  o.left = left;
+  o.right = right;
+  return o;
+};
+
+/** @internal */
+const sequential = (left, right) => {
+  const o = Object.create(proto);
+  o._tag = OP_SEQUENTIAL;
+  o.left = left;
+  o.right = right;
+  return o;
+};
+
+// -----------------------------------------------------------------------------
+// Refinements
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const isCause = u => typeof u === "object" && u != null && CauseTypeId in u;
+
+/** @internal */
+const isEmptyType = self => self._tag === OP_EMPTY;
+
+/** @internal */
+const isFailType = self => self._tag === OP_FAIL;
+
+/** @internal */
+const isDieType = self => self._tag === OP_DIE;
+
+/** @internal */
+const isInterruptType = self => self._tag === OP_INTERRUPT;
+
+/** @internal */
+const isSequentialType = self => self._tag === OP_SEQUENTIAL;
+
+/** @internal */
+const isParallelType = self => self._tag === OP_PARALLEL;
+
+// -----------------------------------------------------------------------------
+// Getters
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const size = self => reduceWithContext(self, void 0, SizeCauseReducer);
+
+/** @internal */
+const isEmpty = self => {
+  if (self._tag === OP_EMPTY) {
+    return true;
+  }
+  return reduce$1(self, true, (acc, cause) => {
+    switch (cause._tag) {
+      case OP_EMPTY:
+        {
+          return some(acc);
+        }
+      case OP_DIE:
+      case OP_FAIL:
+      case OP_INTERRUPT:
+        {
+          return some(false);
+        }
+      default:
+        {
+          return none();
+        }
+    }
+  });
+};
+
+/** @internal */
+const isFailure = self => isSome(failureOption(self));
+
+/** @internal */
+const isDie = self => isSome(dieOption(self));
+
+/** @internal */
+const isInterrupted = self => isSome(interruptOption(self));
+
+/** @internal */
+const isInterruptedOnly = self => reduceWithContext(undefined, IsInterruptedOnlyCauseReducer)(self);
+
+/** @internal */
+const failures = self => reverse(reduce$1(self, empty$2(), (list, cause) => cause._tag === OP_FAIL ? some(pipe(list, prepend(cause.error))) : none()));
+
+/** @internal */
+const defects = self => reverse(reduce$1(self, empty$2(), (list, cause) => cause._tag === OP_DIE ? some(pipe(list, prepend(cause.defect))) : none()));
+
+/** @internal */
+const interruptors = self => reduce$1(self, empty$3(), (set, cause) => cause._tag === OP_INTERRUPT ? some(pipe(set, add(cause.fiberId))) : none());
+
+/** @internal */
+const failureOption = self => find(self, cause => cause._tag === OP_FAIL ? some(cause.error) : none());
+
+/** @internal */
+const failureOrCause = self => {
+  const option = failureOption(self);
+  switch (option._tag) {
+    case "None":
+      {
+        // no `E` inside this `Cause`, so it can be safely cast to `never`
+        return right(self);
+      }
+    case "Some":
+      {
+        return left(option.value);
+      }
+  }
+};
+
+/** @internal */
+const dieOption = self => find(self, cause => cause._tag === OP_DIE ? some(cause.defect) : none());
+
+/** @internal */
+const flipCauseOption = self => match(self, {
+  onEmpty: some(empty$1),
+  onFail: failureOption => pipe(failureOption, map$2(fail$1)),
+  onDie: defect => some(die$1(defect)),
+  onInterrupt: fiberId => some(interrupt$1(fiberId)),
+  onSequential: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(sequential(left.value, right.value));
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    return none();
+  },
+  onParallel: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(parallel(left.value, right.value));
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    return none();
+  }
+});
+
+/** @internal */
+const interruptOption = self => find(self, cause => cause._tag === OP_INTERRUPT ? some(cause.fiberId) : none());
+
+/** @internal */
+const keepDefects = self => match(self, {
+  onEmpty: none(),
+  onFail: () => none(),
+  onDie: defect => some(die$1(defect)),
+  onInterrupt: () => none(),
+  onSequential: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(sequential(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  },
+  onParallel: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(parallel(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  }
+});
+
+/** @internal */
+const keepDefectsAndElectFailures = self => match(self, {
+  onEmpty: none(),
+  onFail: failure => some(die$1(failure)),
+  onDie: defect => some(die$1(defect)),
+  onInterrupt: () => none(),
+  onSequential: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(sequential(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  },
+  onParallel: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(parallel(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  }
+});
+
+/** @internal */
+const linearize = self => match(self, {
+  onEmpty: empty$3(),
+  onFail: error => make(fail$1(error)),
+  onDie: defect => make(die$1(defect)),
+  onInterrupt: fiberId => make(interrupt$1(fiberId)),
+  onSequential: (leftSet, rightSet) => pipe(leftSet, flatMap$2(leftCause => pipe(rightSet, map$3(rightCause => sequential(leftCause, rightCause))))),
+  onParallel: (leftSet, rightSet) => pipe(leftSet, flatMap$2(leftCause => pipe(rightSet, map$3(rightCause => parallel(leftCause, rightCause)))))
+});
+
+/** @internal */
+const stripFailures = self => match(self, {
+  onEmpty: empty$1,
+  onFail: () => empty$1,
+  onDie: defect => die$1(defect),
+  onInterrupt: fiberId => interrupt$1(fiberId),
+  onSequential: sequential,
+  onParallel: parallel
+});
+
+/** @internal */
+const electFailures = self => match(self, {
+  onEmpty: empty$1,
+  onFail: failure => die$1(failure),
+  onDie: defect => die$1(defect),
+  onInterrupt: fiberId => interrupt$1(fiberId),
+  onSequential: (left, right) => sequential(left, right),
+  onParallel: (left, right) => parallel(left, right)
+});
+
+/** @internal */
+const stripSomeDefects = /*#__PURE__*/dual(2, (self, pf) => match(self, {
+  onEmpty: some(empty$1),
+  onFail: error => some(fail$1(error)),
+  onDie: defect => {
+    const option = pf(defect);
+    return isSome(option) ? none() : some(die$1(defect));
+  },
+  onInterrupt: fiberId => some(interrupt$1(fiberId)),
+  onSequential: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(sequential(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  },
+  onParallel: (left, right) => {
+    if (isSome(left) && isSome(right)) {
+      return some(parallel(left.value, right.value));
+    }
+    if (isSome(left) && isNone(right)) {
+      return some(left.value);
+    }
+    if (isNone(left) && isSome(right)) {
+      return some(right.value);
+    }
+    return none();
+  }
+}));
+
+// -----------------------------------------------------------------------------
+// Mapping
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const as$1 = /*#__PURE__*/dual(2, (self, error) => map$1(self, () => error));
+
+/** @internal */
+const map$1 = /*#__PURE__*/dual(2, (self, f) => flatMap$1(self, e => fail$1(f(e))));
+
+// -----------------------------------------------------------------------------
+// Sequencing
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const flatMap$1 = /*#__PURE__*/dual(2, (self, f) => match(self, {
+  onEmpty: empty$1,
+  onFail: error => f(error),
+  onDie: defect => die$1(defect),
+  onInterrupt: fiberId => interrupt$1(fiberId),
+  onSequential: (left, right) => sequential(left, right),
+  onParallel: (left, right) => parallel(left, right)
+}));
+
+/** @internal */
+const flatten$2 = self => flatMap$1(self, identity);
+
+// -----------------------------------------------------------------------------
+// Equality
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const contains = /*#__PURE__*/dual(2, (self, that) => {
+  if (that._tag === OP_EMPTY || self === that) {
+    return true;
+  }
+  return reduce$1(self, false, (accumulator, cause) => {
+    return some(accumulator || causeEquals(cause, that));
+  });
+});
+
+/** @internal */
+const causeEquals = (left, right) => {
+  let leftStack = of(left);
+  let rightStack = of(right);
+  while (isNonEmpty(leftStack) && isNonEmpty(rightStack)) {
+    const [leftParallel, leftSequential] = pipe(headNonEmpty(leftStack), reduce$1([empty$3(), empty$2()], ([parallel, sequential], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return some([pipe(parallel, union(par)), pipe(sequential, appendAll(seq))]);
+    }));
+    const [rightParallel, rightSequential] = pipe(headNonEmpty(rightStack), reduce$1([empty$3(), empty$2()], ([parallel, sequential], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return some([pipe(parallel, union(par)), pipe(sequential, appendAll(seq))]);
+    }));
+    if (!equals(leftParallel, rightParallel)) {
+      return false;
+    }
+    leftStack = leftSequential;
+    rightStack = rightSequential;
+  }
+  return true;
+};
+
+// -----------------------------------------------------------------------------
+// Flattening
+// -----------------------------------------------------------------------------
+
+/**
+ * Flattens a cause to a sequence of sets of causes, where each set represents
+ * causes that fail in parallel and sequential sets represent causes that fail
+ * after each other.
+ *
+ * @internal
+ */
+const flattenCause = cause => {
+  return flattenCauseLoop(of(cause), empty$2());
+};
+
+/** @internal */
+const flattenCauseLoop = (causes, flattened) => {
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    const [parallel, sequential] = pipe(causes, reduce$2([empty$3(), empty$2()], ([parallel, sequential], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return [pipe(parallel, union(par)), pipe(sequential, appendAll(seq))];
+    }));
+    const updated = size$1(parallel) > 0 ? pipe(flattened, prepend(parallel)) : flattened;
+    if (isEmpty$1(sequential)) {
+      return reverse(updated);
+    }
+    causes = sequential;
+    flattened = updated;
+  }
+  throw new Error("BUG: Cause.flattenCauseLoop - please report an issue at https://github.com/Effect-TS/io/issues");
+};
+
+// -----------------------------------------------------------------------------
+// Squashing
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const squash = self => {
+  return squashWith(identity)(self);
+};
+
+/** @internal */
+const squashWith = /*#__PURE__*/dual(2, (self, f) => {
+  const option = pipe(self, failureOption, map$2(f));
+  switch (option._tag) {
+    case "None":
+      {
+        return pipe(defects(self), head, match$1({
+          onNone: () => {
+            const interrupts = Array.from(interruptors(self)).flatMap(fiberId => Array.from(ids(fiberId)).map(id => `#${id}`));
+            return InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0);
+          },
+          onSome: identity
+        }));
+      }
+    case "Some":
+      {
+        return option.value;
+      }
+  }
+});
+
+// -----------------------------------------------------------------------------
+// Finding
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const find = /*#__PURE__*/dual(2, (self, pf) => {
+  const stack = [self];
+  while (stack.length > 0) {
+    const item = stack.pop();
+    const option = pf(item);
+    switch (option._tag) {
+      case "None":
+        {
+          switch (item._tag) {
+            case OP_SEQUENTIAL:
+            case OP_PARALLEL:
+              {
+                stack.push(item.right);
+                stack.push(item.left);
+                break;
+              }
+          }
+          break;
+        }
+      case "Some":
+        {
+          return option;
+        }
+    }
+  }
+  return none();
+});
+
+// -----------------------------------------------------------------------------
+// Filtering
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const filter = /*#__PURE__*/dual(2, (self, predicate) => reduceWithContext(self, void 0, FilterCauseReducer(predicate)));
+
+// -----------------------------------------------------------------------------
+// Evaluation
+// -----------------------------------------------------------------------------
+
+/**
+ * Takes one step in evaluating a cause, returning a set of causes that fail
+ * in parallel and a list of causes that fail sequentially after those causes.
+ *
+ * @internal
+ */
+const evaluateCause = self => {
+  let cause = self;
+  const stack = [];
+  let _parallel = empty$3();
+  let _sequential = empty$2();
+  while (cause !== undefined) {
+    switch (cause._tag) {
+      case OP_EMPTY:
+        {
+          if (stack.length === 0) {
+            return [_parallel, _sequential];
+          }
+          cause = stack.pop();
+          break;
+        }
+      case OP_FAIL:
+        {
+          if (stack.length === 0) {
+            return [pipe(_parallel, add(cause.error)), _sequential];
+          }
+          _parallel = pipe(_parallel, add(cause.error));
+          cause = stack.pop();
+          break;
+        }
+      case OP_DIE:
+        {
+          if (stack.length === 0) {
+            return [pipe(_parallel, add(cause.defect)), _sequential];
+          }
+          _parallel = pipe(_parallel, add(cause.defect));
+          cause = stack.pop();
+          break;
+        }
+      case OP_INTERRUPT:
+        {
+          if (stack.length === 0) {
+            return [pipe(_parallel, add(cause.fiberId)), _sequential];
+          }
+          _parallel = pipe(_parallel, add(cause.fiberId));
+          cause = stack.pop();
+          break;
+        }
+      case OP_SEQUENTIAL:
+        {
+          switch (cause.left._tag) {
+            case OP_EMPTY:
+              {
+                cause = cause.right;
+                break;
+              }
+            case OP_SEQUENTIAL:
+              {
+                cause = sequential(cause.left.left, sequential(cause.left.right, cause.right));
+                break;
+              }
+            case OP_PARALLEL:
+              {
+                cause = parallel(sequential(cause.left.left, cause.right), sequential(cause.left.right, cause.right));
+                break;
+              }
+            default:
+              {
+                _sequential = pipe(_sequential, prepend(cause.right));
+                cause = cause.left;
+                break;
+              }
+          }
+          break;
+        }
+      case OP_PARALLEL:
+        {
+          stack.push(cause.right);
+          cause = cause.left;
+          break;
+        }
+    }
+  }
+  throw new Error("BUG: Cause.evaluateCauseLoop - please report an issue at https://github.com/Effect-TS/io/issues");
+};
+
+// -----------------------------------------------------------------------------
+// Reducing
+// -----------------------------------------------------------------------------
+
+/** @internal */
+const SizeCauseReducer = {
+  emptyCase: () => 0,
+  failCase: () => 1,
+  dieCase: () => 1,
+  interruptCase: () => 1,
+  sequentialCase: (_, left, right) => left + right,
+  parallelCase: (_, left, right) => left + right
+};
+
+/** @internal */
+const IsInterruptedOnlyCauseReducer = {
+  emptyCase: constTrue,
+  failCase: constFalse,
+  dieCase: constFalse,
+  interruptCase: constTrue,
+  sequentialCase: (_, left, right) => left && right,
+  parallelCase: (_, left, right) => left && right
+};
+
+/** @internal */
+const FilterCauseReducer = predicate => ({
+  emptyCase: () => empty$1,
+  failCase: (_, error) => fail$1(error),
+  dieCase: (_, defect) => die$1(defect),
+  interruptCase: (_, fiberId) => interrupt$1(fiberId),
+  sequentialCase: (_, left, right) => {
+    if (predicate(left)) {
+      if (predicate(right)) {
+        return sequential(left, right);
+      }
+      return left;
+    }
+    if (predicate(right)) {
+      return right;
+    }
+    return empty$1;
+  },
+  parallelCase: (_, left, right) => {
+    if (predicate(left)) {
+      if (predicate(right)) {
+        return parallel(left, right);
+      }
+      return left;
+    }
+    if (predicate(right)) {
+      return right;
+    }
+    return empty$1;
+  }
+});
+
+/** @internal */
+
+const OP_SEQUENTIAL_CASE = "SequentialCase";
+const OP_PARALLEL_CASE = "ParallelCase";
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const match = /*#__PURE__*/dual(2, (self, {
+  onDie,
+  onEmpty,
+  onFail,
+  onInterrupt,
+  onParallel,
+  onSequential
+}) => {
+  return reduceWithContext(self, void 0, {
+    emptyCase: () => onEmpty,
+    failCase: (_, error) => onFail(error),
+    dieCase: (_, defect) => onDie(defect),
+    interruptCase: (_, fiberId) => onInterrupt(fiberId),
+    sequentialCase: (_, left, right) => onSequential(left, right),
+    parallelCase: (_, left, right) => onParallel(left, right)
+  });
+});
+
+/** @internal */
+const reduce$1 = /*#__PURE__*/dual(3, (self, zero, pf) => {
+  let accumulator = zero;
+  let cause = self;
+  const causes = [];
+  while (cause !== undefined) {
+    const option = pf(accumulator, cause);
+    accumulator = isSome(option) ? option.value : accumulator;
+    switch (cause._tag) {
+      case OP_SEQUENTIAL:
+        {
+          causes.push(cause.right);
+          cause = cause.left;
+          break;
+        }
+      case OP_PARALLEL:
+        {
+          causes.push(cause.right);
+          cause = cause.left;
+          break;
+        }
+      default:
+        {
+          cause = undefined;
+          break;
+        }
+    }
+    if (cause === undefined && causes.length > 0) {
+      cause = causes.pop();
+    }
+  }
+  return accumulator;
+});
+
+/** @internal */
+const reduceWithContext = /*#__PURE__*/dual(3, (self, context, reducer) => {
+  const input = [self];
+  const output = [];
+  while (input.length > 0) {
+    const cause = input.pop();
+    switch (cause._tag) {
+      case OP_EMPTY:
+        {
+          output.push(right(reducer.emptyCase(context)));
+          break;
+        }
+      case OP_FAIL:
+        {
+          output.push(right(reducer.failCase(context, cause.error)));
+          break;
+        }
+      case OP_DIE:
+        {
+          output.push(right(reducer.dieCase(context, cause.defect)));
+          break;
+        }
+      case OP_INTERRUPT:
+        {
+          output.push(right(reducer.interruptCase(context, cause.fiberId)));
+          break;
+        }
+      case OP_SEQUENTIAL:
+        {
+          input.push(cause.right);
+          input.push(cause.left);
+          output.push(left({
+            _tag: OP_SEQUENTIAL_CASE
+          }));
+          break;
+        }
+      case OP_PARALLEL:
+        {
+          input.push(cause.right);
+          input.push(cause.left);
+          output.push(left({
+            _tag: OP_PARALLEL_CASE
+          }));
+          break;
+        }
+    }
+  }
+  const accumulator = [];
+  while (output.length > 0) {
+    const either = output.pop();
+    switch (either._tag) {
+      case "Left":
+        {
+          switch (either.left._tag) {
+            case OP_SEQUENTIAL_CASE:
+              {
+                const left = accumulator.pop();
+                const right = accumulator.pop();
+                const value = reducer.sequentialCase(context, left, right);
+                accumulator.push(value);
+                break;
+              }
+            case OP_PARALLEL_CASE:
+              {
+                const left = accumulator.pop();
+                const right = accumulator.pop();
+                const value = reducer.parallelCase(context, left, right);
+                accumulator.push(value);
+                break;
+              }
+          }
+          break;
+        }
+      case "Right":
+        {
+          accumulator.push(either.right);
+          break;
+        }
+    }
+  }
+  if (accumulator.length === 0) {
+    throw new Error("BUG: Cause.reduceWithContext - please report an issue at https://github.com/Effect-TS/io/issues");
+  }
+  return accumulator.pop();
+});
+
+// -----------------------------------------------------------------------------
+// Errors
+// -----------------------------------------------------------------------------
+
+const makeException = (proto, tag) => {
+  const _tag = {
+    value: tag,
+    enumerable: true
+  };
+  const protoWithToString = {
+    ...proto,
+    toString() {
+      return `${this._tag}: ${this.message}`;
+    }
+  };
+  return message => Object.create(protoWithToString, {
+    _tag,
+    message: {
+      value: message,
+      enumerable: true
+    }
+  });
+};
+
+/** @internal */
+const RuntimeExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/RuntimeException");
+
+/** @internal */
+const RuntimeException = /*#__PURE__*/makeException({
+  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
+}, "RuntimeException");
+
+/** @internal */
+const isRuntimeException = u => {
+  return typeof u === "object" && u != null && RuntimeExceptionTypeId in u;
+};
+
+/** @internal */
+const InterruptedExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InterruptedException");
+
+/** @internal */
+const InterruptedException = /*#__PURE__*/makeException({
+  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
+}, "InterruptedException");
+
+/** @internal */
+const isInterruptedException = u => {
+  return typeof u === "object" && u != null && InterruptedExceptionTypeId in u;
+};
+
+/** @internal */
+const IllegalArgumentExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/IllegalArgument");
+
+/** @internal */
+const IllegalArgumentException = /*#__PURE__*/makeException({
+  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
+}, "IllegalArgumentException");
+
+/** @internal */
+const isIllegalArgumentException = u => {
+  return typeof u === "object" && u != null && IllegalArgumentExceptionTypeId in u;
+};
+
+/** @internal */
+const NoSuchElementExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/NoSuchElement");
+
+/** @internal */
+const NoSuchElementException = /*#__PURE__*/makeException({
+  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
+}, "NoSuchElementException");
+
+/** @internal */
+const isNoSuchElementException = u => {
+  return typeof u === "object" && u != null && NoSuchElementExceptionTypeId in u;
+};
+
+/** @internal */
+const InvalidHubCapacityExceptionTypeId = /*#__PURE__*/Symbol.for("effect/Cause/errors/InvalidHubCapacityException");
+
+/** @internal */
+const InvalidHubCapacityException = /*#__PURE__*/makeException({
+  [InvalidHubCapacityExceptionTypeId]: InvalidHubCapacityExceptionTypeId
+}, "InvalidHubCapacityException");
+
+// -----------------------------------------------------------------------------
+// Pretty Printing
+// -----------------------------------------------------------------------------
+
+const filterStack = stack => {
+  const lines = stack.split("\n");
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes("EffectPrimitive") || lines[i].includes("Generator.next") || lines[i].includes("FiberRuntime")) {
+      return out.join("\n");
+    } else {
+      out.push(lines[i]);
+    }
+  }
+  return out.join("\n");
+};
+
+/** @internal */
+const pretty = cause => {
+  if (isInterruptedOnly(cause)) {
+    return "All fibers interrupted without errors.";
+  }
+  const final = prettyErrors(cause).map(e => {
+    let message = e.message;
+    if (e.stack) {
+      message += `\r\n${filterStack(e.stack)}`;
+    }
+    if (e.span) {
+      let current = e.span;
+      let i = 0;
+      while (current && current._tag === "Span" && i < 10) {
+        message += `\r\n    at ${current.name}`;
+        current = getOrUndefined(current.parent);
+        i++;
+      }
+    }
+    return message;
+  }).join("\r\n");
+  return final;
+};
+class PrettyError {
+  constructor(message, stack, span) {
+    this.message = message;
+    this.stack = stack;
+    this.span = span;
+  }
+  toJSON() {
+    const out = {
+      message: this.message
+    };
+    if (this.stack) {
+      out.stack = this.stack;
+    }
+    if (this.span) {
+      out.span = this.span;
+    }
+    return out;
+  }
+}
+
+/**
+ * A utility function for generating human-readable error messages from a generic error of type `unknown`.
+ *
+ * Rules:
+ *
+ * 1) If the input `u` is already a string, it's considered a message, and "Error" is added as a prefix.
+ * 2) If `u` has a user-defined `toString()` method, it uses that method and adds "Error" as a prefix.
+ * 3) If `u` is an object and its only (optional) properties are "name", "message", or "_tag", it constructs
+ *    an error message based on those properties.
+ * 4) Otherwise, it uses `JSON.stringify` to produce a string representation and uses it as the error message,
+ *   with "Error" added as a prefix.
+ *
+ * @internal
+ */
+const prettyErrorMessage = u => {
+  // 1)
+  if (typeof u === "string") {
+    return `Error: ${u}`;
+  }
+  // 2)
+  if (typeof u === "object" && u != null && "toString" in u && typeof u["toString"] === "function" && u["toString"] !== Object.prototype.toString) {
+    return u["toString"]();
+  }
+  // 3)
+  if (typeof u === "object" && u !== null) {
+    if ("message" in u && typeof u["message"] === "string") {
+      const raw = JSON.parse(JSON.stringify(u));
+      const keys = new Set(Object.keys(raw));
+      keys.delete("name");
+      keys.delete("message");
+      keys.delete("_tag");
+      if (keys.size === 0) {
+        const name = "name" in u && typeof u.name === "string" ? u.name : "Error";
+        const tag = "_tag" in u && typeof u["_tag"] === "string" ? `(${u._tag})` : ``;
+        return `${name}${tag}: ${u.message}`;
+      }
+    }
+  }
+  // 4)
+  return `Error: ${JSON.stringify(u)}`;
+};
+const spanSymbol$1 = /*#__PURE__*/Symbol.for("effect/SpanAnnotation");
+const defaultRenderError = error => {
+  const span = typeof error === "object" && error !== null && spanSymbol$1 in error && error[spanSymbol$1];
+  if (typeof error === "object" && error !== null && error instanceof Error) {
+    return new PrettyError(prettyErrorMessage(error), error.stack?.split("\n").filter(_ => !_.startsWith("Error")).join("\n"), span);
+  }
+  return new PrettyError(prettyErrorMessage(error), void 0, span);
+};
+
+/** @internal */
+const prettyErrors = cause => reduceWithContext(cause, void 0, {
+  emptyCase: () => [],
+  dieCase: (_, unknownError) => {
+    return [defaultRenderError(unknownError)];
+  },
+  failCase: (_, error) => {
+    return [defaultRenderError(error)];
+  },
+  interruptCase: () => [],
+  parallelCase: (_, l, r) => [...l, ...r],
+  sequentialCase: (_, l, r) => [...l, ...r]
+});
+
+/** @internal */
+const empty = {
+  _tag: "Empty"
+};
+
+/**
+ * Combines this collection of blocked requests with the specified collection
+ * of blocked requests, in parallel.
+ *
+ * @internal
+ */
+const par = (self, that) => ({
+  _tag: "Par",
+  left: self,
+  right: that
+});
+
+/**
+ * Combines this collection of blocked requests with the specified collection
+ * of blocked requests, in sequence.
+ *
+ * @internal
+ */
+const seq = (self, that) => ({
+  _tag: "Seq",
+  left: self,
+  right: that
+});
+
+/**
+ * Constructs a collection of blocked requests from the specified blocked
+ * request and data source.
+ *
+ * @internal
+ */
+const single = (dataSource, blockedRequest) => ({
+  _tag: "Single",
+  dataSource,
+  blockedRequest
+});
+
+/** @internal */
+const MapRequestResolversReducer = f => ({
+  emptyCase: () => empty,
+  parCase: (left, right) => par(left, right),
+  seqCase: (left, right) => seq(left, right),
+  singleCase: (dataSource, blockedRequest) => single(f(dataSource), blockedRequest)
+});
+/**
+ * Transforms all data sources with the specified data source aspect, which
+ * can change the environment type of data sources but must preserve the
+ * request type of each data source.
+ *
+ * @internal
+ */
+const mapRequestResolvers = (self, f) => reduce(self, MapRequestResolversReducer(f));
+
+/**
+ * Folds over the cases of this collection of blocked requests with the
+ * specified functions.
+ *
+ * @internal
+ */
+const reduce = (self, reducer) => {
+  let input = of$1(self);
+  let output = empty$4();
+  while (isCons(input)) {
+    const current = input.head;
+    switch (current._tag) {
+      case "Empty":
+        {
+          output = cons(right(reducer.emptyCase()), output);
+          input = input.tail;
+          break;
+        }
+      case "Par":
+        {
+          output = cons(left({
+            _tag: "ParCase"
+          }), output);
+          input = cons(current.left, cons(current.right, input.tail));
+          break;
+        }
+      case "Seq":
+        {
+          output = cons(left({
+            _tag: "SeqCase"
+          }), output);
+          input = cons(current.left, cons(current.right, input.tail));
+          break;
+        }
+      case "Single":
+        {
+          const result = reducer.singleCase(current.dataSource, current.blockedRequest);
+          output = cons(right(result), output);
+          input = input.tail;
+          break;
+        }
+    }
+  }
+  const result = reduce$3(output, empty$4(), (acc, current) => {
+    switch (current._tag) {
+      case "Left":
+        {
+          const left = unsafeHead(acc);
+          const right = unsafeHead(unsafeTail(acc));
+          const tail = unsafeTail(unsafeTail(acc));
+          switch (current.left._tag) {
+            case "ParCase":
+              {
+                return cons(reducer.parCase(left, right), tail);
+              }
+            case "SeqCase":
+              {
+                return cons(reducer.seqCase(left, right), tail);
+              }
+          }
+        }
+      case "Right":
+        {
+          return cons(current.right, acc);
+        }
+    }
+  });
+  if (isNil(result)) {
+    throw new Error("BUG: BlockedRequests.reduce - please report an issue at https://github.com/Effect-TS/query/issues");
+  }
+  return result.head;
+};
+
+/**
+ * Flattens a collection of blocked requests into a collection of pipelined
+ * and batched requests that can be submitted for execution.
+ *
+ * @internal
+ */
+const flatten$1 = self => {
+  let current = of$1(self);
+  let updated = empty$4();
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    const [parallel, sequential] = reduce$3(current, [parallelCollectionEmpty(), empty$4()], ([parallel, sequential], blockedRequest) => {
+      const [par, seq] = step$1(blockedRequest);
+      return [parallelCollectionCombine(parallel, par), appendAll$1(sequential, seq)];
+    });
+    updated = merge(updated, parallel);
+    if (isNil(sequential)) {
+      return reverse$1(updated);
+    }
+    current = sequential;
+  }
+  throw new Error("BUG: BlockedRequests.flatten - please report an issue at https://github.com/Effect-TS/query/issues");
+};
+
+/**
+ * Takes one step in evaluating a collection of blocked requests, returning a
+ * collection of blocked requests that can be performed in parallel and a list
+ * of blocked requests that must be performed sequentially after those
+ * requests.
+ */
+const step$1 = requests => {
+  let current = requests;
+  let parallel = parallelCollectionEmpty();
+  let stack = empty$4();
+  let sequential = empty$4();
+  // eslint-disable-next-line no-constant-condition
+  while (1) {
+    switch (current._tag) {
+      case "Empty":
+        {
+          if (isNil(stack)) {
+            return [parallel, sequential];
+          }
+          current = stack.head;
+          stack = stack.tail;
+          break;
+        }
+      case "Par":
+        {
+          stack = cons(current.right, stack);
+          current = current.left;
+          break;
+        }
+      case "Seq":
+        {
+          const left = current.left;
+          const right = current.right;
+          switch (left._tag) {
+            case "Empty":
+              {
+                current = right;
+                break;
+              }
+            case "Par":
+              {
+                const l = left.left;
+                const r = left.right;
+                current = par(seq(l, right), seq(r, right));
+                break;
+              }
+            case "Seq":
+              {
+                const l = left.left;
+                const r = left.right;
+                current = seq(l, seq(r, right));
+                break;
+              }
+            case "Single":
+              {
+                current = left;
+                sequential = cons(right, sequential);
+                break;
+              }
+          }
+          break;
+        }
+      case "Single":
+        {
+          parallel = parallelCollectionCombine(parallel, parallelCollectionMake(current.dataSource, current.blockedRequest));
+          if (isNil(stack)) {
+            return [parallel, sequential];
+          }
+          current = stack.head;
+          stack = stack.tail;
+          break;
+        }
+    }
+  }
+  throw new Error("BUG: BlockedRequests.step - please report an issue at https://github.com/Effect-TS/query/issues");
+};
+
+/**
+ * Merges a collection of requests that must be executed sequentially with a
+ * collection of requests that can be executed in parallel. If the collections
+ * are both from the same single data source then the requests can be
+ * pipelined while preserving ordering guarantees.
+ */
+const merge = (sequential, parallel) => {
+  if (isNil(sequential)) {
+    return of$1(parallelCollectionToSequentialCollection(parallel));
+  }
+  if (parallelCollectionIsEmpty(parallel)) {
+    return sequential;
+  }
+  const seqHeadKeys = sequentialCollectionKeys(sequential.head);
+  const parKeys = parallelCollectionKeys(parallel);
+  if (seqHeadKeys.length === 1 && parKeys.length === 1 && equals(seqHeadKeys[0], parKeys[0])) {
+    return cons(sequentialCollectionCombine(sequential.head, parallelCollectionToSequentialCollection(parallel)), sequential.tail);
+  }
+  return cons(parallelCollectionToSequentialCollection(parallel), sequential);
+};
+
+//
+// circular
+//
+
+/** @internal */
+const EntryTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/Entry");
+
+/** @internal */
+class EntryImpl {
+  [EntryTypeId] = blockedRequestVariance;
+  constructor(request, result, listeners, ownerId, state) {
+    this.request = request;
+    this.result = result;
+    this.listeners = listeners;
+    this.ownerId = ownerId;
+    this.state = state;
+  }
+}
+
+/** @internal */
+const blockedRequestVariance = {
+  _R: _ => _
+};
+
+/** @internal */
+const isEntry = u => {
+  return typeof u === "object" && u != null && EntryTypeId in u;
+};
+
+/** @internal */
+const makeEntry = options => new EntryImpl(options.request, options.result, options.listeners, options.ownerId, options.state);
+
+/** @internal */
+const RequestBlockParallelTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockParallel");
+const parallelVariance = {
+  _R: _ => _
+};
+class ParallelImpl {
+  [RequestBlockParallelTypeId] = parallelVariance;
+  constructor(map) {
+    this.map = map;
+  }
+}
+
+/** @internal */
+const parallelCollectionEmpty = () => new ParallelImpl(empty$5());
+
+/** @internal */
+const parallelCollectionMake = (dataSource, blockedRequest) => new ParallelImpl(make$1([dataSource, Array.of(blockedRequest)]));
+
+/** @internal */
+const parallelCollectionCombine = (self, that) => new ParallelImpl(reduce$4(self.map, that.map, (map, value, key) => set(map, key, match$1(get(map, key), {
+  onNone: () => value,
+  onSome: a => [...a, ...value]
+}))));
+
+/** @internal */
+const parallelCollectionIsEmpty = self => isEmpty$2(self.map);
+
+/** @internal */
+const parallelCollectionKeys = self => Array.from(keys(self.map));
+
+/** @internal */
+const parallelCollectionToSequentialCollection = self => sequentialCollectionMake(map$4(self.map, x => Array.of(x)));
+
+/** @internal */
+const SequentialCollectionTypeId = /*#__PURE__*/Symbol.for("effect/RequestBlock/RequestBlockSequential");
+
+/** @internal */
+const sequentialVariance = {
+  _R: _ => _
+};
+class SequentialImpl {
+  [SequentialCollectionTypeId] = sequentialVariance;
+  constructor(map) {
+    this.map = map;
+  }
+}
+
+/** @internal */
+const sequentialCollectionMake = map => new SequentialImpl(map);
+
+/** @internal */
+const sequentialCollectionCombine = (self, that) => new SequentialImpl(reduce$4(that.map, self.map, (map, value, key) => set(map, key, match$1(get(map, key), {
+  onNone: () => [],
+  onSome: a => [...a, ...value]
+}))));
+
+/** @internal */
+const sequentialCollectionKeys = self => Array.from(keys(self.map));
+
+/** @internal */
+const sequentialCollectionToChunk = self => Array.from(self.map);
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const OP_STATE_PENDING = "Pending";
+
+/** @internal */
+
+/** @internal */
+const OP_STATE_DONE = "Done";
+
+/** @internal */
+
+/** @internal */
+const DeferredSymbolKey = "effect/Deferred";
+
+/** @internal */
+const DeferredTypeId = /*#__PURE__*/Symbol.for(DeferredSymbolKey);
+
+/** @internal */
+const deferredVariance = {
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+const pending = joiners => {
+  return {
+    _tag: OP_STATE_PENDING,
+    joiners
+  };
+};
+
+/** @internal */
+const done = effect => {
+  return {
+    _tag: OP_STATE_DONE,
+    effect
+  };
+};
+
+// -----------------------------------------------------------------------------
+// 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$1](that) {
+    return this === that;
+  }
+  [symbol]() {
+    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$1](that) {
+    return this === that;
+  }
+  [symbol]() {
+    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$1](that) {
+    return this === that;
+  }
+  [symbol]() {
+    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$1) => 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$1) => 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$1(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$1(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());
+}));
+
+/* @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]() {
+    return this.target ? hash(this.target) : random(this);
+  }
+  [symbol$1](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$2("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$6());
+
+/** @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$5()));
+
+/** @internal */
+const currentLogLevel = /*#__PURE__*/fiberRefUnsafeMake(logLevelInfo);
+
+/** @internal */
+const currentLogSpan = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentLogSpan"), () => fiberRefUnsafeMake(empty$4()));
+
+/** @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$3());
+
+/* @internal */
+const metricLabels = /*#__PURE__*/fiberRefGet(currentMetricLabels);
+
+/** @internal */
+const currentForkScopeOverride = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentForkScopeOverride"), () => fiberRefUnsafeMake(none(), {
+  fork: () => none(),
+  join: (parent, _) => parent
+}));
+
+/** @internal */
+const currentInterruptedCause = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentInterruptedCause"), () => fiberRefUnsafeMake(empty$1, {
+  fork: () => empty$1,
+  join: (parent, _) => parent
+}));
+
+/** @internal */
+const currentTracerSpan = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentTracerSpan"), () => fiberRefUnsafeMake(empty$4()));
+
+/** @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$5()));
+
+/** @internal */
+const currentTracerSpanLinks = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentTracerSpanLinks"), () => fiberRefUnsafeMake(empty$2()));
+
+// -----------------------------------------------------------------------------
+// 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$1({
+  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());
+      }
+    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();
+      }
+  }
+};
+
+/** @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();
+  }
+  return pipe(tailNonEmpty(list), reduce$2(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$3(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$1(self.state);
+  switch (state._tag) {
+    case OP_STATE_DONE:
+      {
+        return right(state.effect);
+      }
+    case OP_STATE_PENDING:
+      {
+        pipe(self.state, set$1(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$1(self.state);
+  switch (state._tag) {
+    case OP_STATE_DONE:
+      {
+        return false;
+      }
+    case OP_STATE_PENDING:
+      {
+        pipe(self.state, set$1(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$1(self.state)._tag === OP_STATE_DONE);
+
+/* @internal */
+const deferredPoll = self => sync(() => {
+  const state = get$1(self.state);
+  switch (state._tag) {
+    case OP_STATE_DONE:
+      {
+        return some(state.effect);
+      }
+    case OP_STATE_PENDING:
+      {
+        return none();
+      }
+  }
+});
+
+/* @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$1(self.state);
+  if (state._tag === OP_STATE_PENDING) {
+    pipe(self.state, set$1(done(effect)));
+    for (let i = state.joiners.length - 1; i >= 0; i--) {
+      state.joiners[i](effect);
+    }
+  }
+};
+const deferredInterruptJoiner = (self, joiner) => sync(() => {
+  const state = get$1(self.state);
+  if (state._tag === OP_STATE_PENDING) {
+    pipe(self.state, set$1(pending(state.joiners.filter(j => j !== joiner))));
+  }
+});
+
+export { interruptFiber as $, pretty as A, matchCauseEffect as B, failCause as C, defects as D, currentMetricLabels as E, matchEffect as F, exitFail as G, exitSucceed as H, InvalidHubCapacityException as I, zip as J, currentTracerSpan as K, fiberRefUnsafeMakeHashSet as L, isEffect as M, fiberRefLocally as N, currentForkScopeOverride as O, exit as P, exitIsSuccess as Q, onError as R, failureOrCause as S, partitionMap as T, either as U, fail as V, dieSync as W, uninterruptibleMask as X, interruptible as Y, forEachSequential as Z, zipLeft as _, suspend as a, exitIsFailure as a$, exitMatchEffect as a0, flatten as a1, deferredFailCause as a2, contextWithEffect as a3, scopeFork as a4, acquireUseRelease as a5, scopeClose as a6, exitZipWith as a7, parallel as a8, sequential as a9, currentUnhandledErrorLogLevel as aA, isInterruptedOnly as aB, currentLogLevel as aC, currentLogSpan as aD, currentLogAnnotations as aE, exitFailCause as aF, exitUnit as aG, die$1 as aH, currentContext as aI, NoSuchElementException as aJ, stripFailures as aK, blocked as aL, catchAllCause as aM, runRequestBlock as aN, RevertFlags as aO, yieldNow as aP, isEffectError as aQ, isInterruptedException as aR, withRuntimeFlags as aS, if_ as aT, zipWith as aU, currentRequestBatching as aV, transplant as aW, step as aX, par as aY, deferredFail as aZ, exitCollectAll as a_, flip as aa, fiberIdWith as ab, updateRuntimeFlags as ac, runtimeFlags as ad, ScopeTypeId as ae, releaseMapMake as af, CloseableScopeTypeId as ag, releaseMapAdd as ah, scopeAddFinalizerExit as ai, as as aj, mapInputContext as ak, onExit as al, fiberRefUnsafeMakePatch as am, fiberRefGet as an, fiberRefSet as ao, fiberRefUpdate as ap, fiberRefDelete as aq, fiberRefUnsafeMakeContext as ar, fiberRefUnsafeMakeRuntimeFlags as as, forEachSequentialDiscard as at, currentInterruptedCause as au, async as av, interrupt$1 as aw, currentSchedulingPriority as ax, isEmpty as ay, whileLoop as az, deferredAwait as b, exitExists as b$, IllegalArgumentException as b0, exitAsUnit as b1, interruptAsFiber as b2, flatten$1 as b3, sequentialCollectionToChunk as b4, flatMapStep as b5, catchAll as b6, DeferredTypeId as b7, deferredMakeAs as b8, deferredComplete as b9, intoDeferred as bA, failures as bB, provideContext as bC, keepDefects as bD, flatten$2 as bE, currentTracerSpanAnnotations as bF, currentTracerSpanLinks as bG, isNoSuchElementException as bH, interruptors as bI, currentTracerTimingEnabled as bJ, isCause as bK, exitDie as bL, never as bM, logLevelAll as bN, logLevelFatal as bO, logLevelError as bP, logLevelWarning as bQ, logLevelInfo as bR, logLevelDebug as bS, logLevelTrace as bT, logLevelNone as bU, allLogLevels as bV, currentMaxOpsBeforeYield as bW, exitIsExit as bX, exitIsInterrupted as bY, exitAs as bZ, exitCauseOption as b_, deferredCompleteWith as ba, deferredDone as bb, deferredFailSync as bc, deferredFailCauseSync as bd, deferredDie as be, deferredDieSync as bf, deferredInterrupt as bg, deferredIsDone as bh, deferredPoll as bi, deferredSync as bj, asyncEither as bk, fiberRefLocallyWith as bl, mapBoth as bm, mapError as bn, makeEffectError as bo, fail$1 as bp, unified as bq, find as br, isDieType as bs, catchIf as bt, matchCause as bu, context as bv, orElse as bw, dieMessage as bx, failSync as by, failCauseSync as bz, asUnit as c, withUnhandledErrorLogLevel as c$, exitFlatMap as c0, exitFlatMapEffect as c1, exitFlatten as c2, exitForEachEffect as c3, exitFromEither as c4, exitFromOption as c5, exitGetOrElse as c6, exitMap as c7, exitMapBoth as c8, exitMapError as c9, interruptOption as cA, linearize as cB, stripSomeDefects as cC, as$1 as cD, map$1 as cE, flatMap$1 as cF, contains as cG, squash as cH, squashWith as cI, filter as cJ, match as cK, reduce$1 as cL, reduceWithContext as cM, InterruptedException as cN, isIllegalArgumentException as cO, RuntimeException as cP, isRuntimeException as cQ, originalInstance as cR, EffectTypeId as cS, die as cT, catchSome as cU, checkInterruptible as cV, interruptWith as cW, interruptibleMask as cX, withConcurrency as cY, withSchedulingPriority as cZ, withMaxOpsBeforeYield as c_, exitMapErrorCause as ca, exitMatch as cb, exitZip as cc, exitZipLeft as cd, exitZipRight as ce, exitZipPar as cf, exitZipParLeft as cg, exitZipParRight as ch, CauseTypeId as ci, RuntimeExceptionTypeId as cj, InterruptedExceptionTypeId as ck, IllegalArgumentExceptionTypeId as cl, NoSuchElementExceptionTypeId as cm, InvalidHubCapacityExceptionTypeId as cn, isEmptyType as co, isFailType as cp, isInterruptType as cq, isSequentialType as cr, isParallelType as cs, size as ct, isFailure as cu, isDie as cv, isInterrupted as cw, failureOption as cx, flipCauseOption as cy, dieOption as cz, deferredMake as d, orDie as d0, orDieWith as d1, metricLabels as d2, withRequestBatching as d3, withTracerTiming as d4, FiberRefTypeId as d5, fiberRefGetAndSet as d6, fiberRefGetAndUpdate as d7, fiberRefGetAndUpdateSome as d8, fiberRefReset as d9, fiberRefModify as da, fiberRefModifySome as db, fiberRefUpdateSome as dc, fiberRefUpdateAndGet as dd, fiberRefUpdateSomeAndGet as de, provideSomeContext as df, single as dg, makeEntry as dh, empty as di, prettyErrors as dj, scopeAddFinalizer as dk, isEntry as dl, mapRequestResolvers as dm, reduce as dn, seq as dp, requestBlockLocally as dq, RequestResolverTypeId as dr, isRequestResolver as ds, resolverLocally as dt, RequestResolverImpl as du, whenEffect as e, flatMap as f, deferredSucceed as g, exitInterrupt as h, interrupt as i, succeed as j, deferredInterruptWith as k, deferredUnsafeMake as l, map as m, fiberId as n, onInterrupt as o, unit as p, deferredUnsafeDone as q, fiberRefUnsafeMake as r, sync as s, tap as t, uninterruptible as u, fiberRefGetWith as v, withFiberRuntime as w, currentConcurrency as x, empty$1 as y, zipRight as z };